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

schubmult/{sage_integration → sage}/_fast_double_schubert_polynomial_ring.py

@@ -1,35 +1,37 @@
+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 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
+
+import schubmult.perm_lib as pl
 
 # from . import (
 #     FastSchubertPolynomialRing_base,
 #     FastSchubertPolynomialRing,
 #     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
+# )as
+import schubmult.sage._fast_schubert_polynomial_ring as bork
+import schubmult.schub_lib.double as yz
+import schubmult.schub_lib.quantum_double as qyz
 from schubmult.perm_lib import permtrim
 
-from sage.misc.parser import Parser
+from ._indexing import _coerce_index
 
 
 def FastDoubleSchubertPolynomialRing(
@@ -38,12 +40,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 +61,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 +71,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 +100,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 +116,7 @@ def FastQuantumDoubleSchubertPolynomialRing(
 
     Returns:
         FastDoubleSchubertPolynomialRing_xbasis: Basis element generator of the quantum ring
+
     """
     return FastDoubleSchubertPolynomialRing(
         R,
@@ -118,7 +124,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 +139,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,35 +153,34 @@ 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
 
+    # can speed this up
     def expand(self):
         if self.parent()._quantum:
             return sum(
                 [
                     qyz.schubpoly_quantum(
-                        tuple(_coerce_index(k[0], self.parent()._ascode, False)),
+                        pl.Permutation(_coerce_index(k[0], self.parent()._ascode, False)),
                         self.parent()._base_polynomial_ring.gens(),
                         self.parent()._coeff_polynomial_rings[k[1]].gens(),
                         self.parent()._q_ring.gens(),
                         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_double(
+                    {pl.Permutation([]): v},
+                    pl.Permutation(_coerce_index(k[0], self.parent()._ascode, False)),
+                    self.parent()._base_polynomial_ring.gens(),
+                    self.parent()._coeff_polynomial_rings[k[1]].gens(),
+                ).get(pl.Permutation([]), 0)
+                for k, v in self.monomial_coefficients().items()
+            ],
+        )
 
     def __eq__(self, other):
         ss = self.parent().one() * self
@@ -202,7 +206,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 +215,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 +270,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,18 +298,26 @@ 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}"
 
+        #         [('bracket', None),
+        #  ('iterate_key', False),
+        #  ('latex_bracket', False), ('latex_names', None),
+        #  ('latex_prefix', None), ('latex_scalar_mult', None),
+        #  ('names', None), ('prefix', 'x'),
+        #  ('scalar_mult', '*'),
+        #  ('sorting_key', <function ...<lambda> at ...>),
+        #  ('sorting_reverse', False), ('string_quotes', True),
+        #  ('tensor_symbol', None)]
+
         CombinatorialFreeModule.__init__(
             self,
             self._coeff_polynomial_ring,
@@ -312,6 +325,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             category=cat,
             prefix=self._sc_rep,
         )
+        # print_options
         self._populate_coercion_lists_()
         self._parser = None
 
@@ -326,91 +340,64 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     def set_coproduct_indices(self, indices):
         self._splitter = indices
 
-    def _element_constructor_(self, *x):
-        if len(x) == 1:
-            x = x[0]
-        elif len(x) > 2:
-            raise ValueError("Bad index for element")
-
+    def _element_constructor_(self, x, vname=None):
         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)
-        ):
-            # 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()})
-            else:
-                elem = self._from_dict(
-                    {
-                        self._index_wrapper(
-                            (
-                                _coerce_index(x, self._ascode, self._ascode),
-                                self._varlist[0],
-                            )
-                        ): self.base_ring().one()
-                    }
-                )
+        if (x, vname) in self._index_wrapper:
+            elem = self._from_dict({self._index_wrapper((x, vname)): self.base_ring().one()})
+        elif isinstance(x, list) or isinstance(x, tuple) or isinstance(x, Permutation) or isinstance(x, Composition) or isinstance(x, pl.Permutation):
+            elem = self._from_dict(
+                {
+                    self._index_wrapper(
+                        (
+                            _coerce_index(x, self._ascode, self._ascode),
+                            self._varlist[0] if vname is None else vname,
+                        ),
+                    ): 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():
                     if self._quantum:
-                        res = qyz.schubmult_db(
-                            {(1, 2): self._coeff_polynomial_ring(v)},
-                            tuple(_coerce_index(k, x.parent()._ascode, False)),
+                        res = qyz.schubmult_q_double_fast(
+                            {pl.Permutation([]): self._coeff_polynomial_ring(v)},
+                            pl.Permutation(list(_coerce_index(k, x.parent()._ascode, False))),
                             self._coeff_polynomial_rings[self._varlist[0]].gens(),
                             [
                                 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(),
                         )
                     else:
-                        res = yz.schubmult(
-                            {(1, 2): self._coeff_polynomial_ring(v)},
-                            tuple(_coerce_index(k, x.parent()._ascode, False)),
+                        res = yz.schubmult_double(
+                            {pl.Permutation([]): self._coeff_polynomial_ring(v)},
+                            pl.Permutation(list(_coerce_index(k, x.parent()._ascode, False))),
                             self._coeff_polynomial_rings[self._varlist[0]].gens(),
                             [
                                 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())
@@ -421,25 +408,19 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             sympy_floff = sympify(str(x))
             val = syme.sympify(sympy_floff)
             if self._quantum:
-                result = qyz.mult_poly(
-                    {(1, 2): 1},
+                result = qyz.mult_poly_q_double(
+                    {pl.Permutation([]): 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:
-                result = yz.mult_poly(
-                    {(1, 2): 1},
+                result = yz.mult_poly_double(
+                    {pl.Permutation([]): 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 +429,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                         self._varlist[0],
                     ): self._coeff_polynomial_ring(str(v))
                     for k, v in result.items()
-                }
+                },
             )
         else:
             raise TypeError
@@ -458,43 +439,33 @@ 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()
-        ]
+        le = _coerce_index(left[0], self._ascode, False)
+        ri = _coerce_index(right[0], self._ascode, False)
+        var_y = [syme.sympify(str(g)) for g in self._coeff_polynomial_rings[left[1]].gens()]
+        var_z = [syme.sympify(str(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},
-                tuple(_coerce_index(ri, self._ascode, False)),
+            result = qyz.schubmult_q_double_fast(
+                {pl.Permutation(le): 1},
+                pl.Permutation(ri),
                 var_y,
                 var_z,
-                self._q_ring.gens(),
+                [syme.sympify(str(g)) for g in self._q_ring.gens()],
             )
         else:
-            result = yz.schubmult(
-                {tuple(_coerce_index(le, self._ascode, False)): 1},
-                tuple(_coerce_index(ri, self._ascode, False)),
+            result = yz.schubmult_double(
+                {pl.Permutation(le): 1},
+                pl.Permutation(ri),
                 var_y,
                 var_z,
             )
         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(str(v)) * self(_coerce_index(k, False, self._ascode), left[1]) for k, v in result.items()],
         )
 
     def _coerce_map_from_(self, S):
@@ -513,70 +484,21 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             raise NotImplementedError("Quantum double Schubert polynomials have no coproduct")
         indices = self._splitter
         indices = sorted(indices)
-        subs_dict_coprod = {}
-        mperm = indm[0]
-        mperm = _coerce_index(mperm, self._ascode, False)
         RR = self._coeff_polynomial_rings[indm[1]]
-        RBase = self._coeff_polynomial_rings[self._varlist[0]]
-        k = len(indices)
-        n = len(mperm)
-        kcd = [indices[i] - i - 1 for i in range(len(indices))] + [n + 1 - k for i in range(k, n)]
-        max_required = max([kcd[i] + i for i in range(len(kcd))])
-        kcd2 = kcd + [0 for i in range(len(kcd), max_required)] + [0]
-        N = len(kcd)
-        kperm = from_lehmer_code(kcd2).inverse()
-        # r = [sum(self.base_ring()._first_ngens(j)) for j in range(100)]
-        vn = [f"soible_{i}" for i in range(N * 2 + 1)]
-        TR = PolynomialRing(self.base_ring(), N * 2 + 1, vn)
-
-        for i in range(N * 2 + 1):
-            if i <= N:
-                subs_dict_coprod[TR.gens()[i]] = self._coeff_polynomial_ring(RR.gens()[i])
-            else:
-                subs_dict_coprod[TR.gens()[i]] = self._coeff_polynomial_ring(RBase.gens()[i - N])
-
-        coeff_dict = {tuple(kperm): 1}
-        coeff_dict = yz.schubmult(
-            coeff_dict,
-            tuple(mperm),
-            list(TR.gens()),
-            RR.gens(),
-        )
+        TR = self._coeff_polynomial_rings[self._varlist[0]]
 
-        inv_kperm = kperm.number_of_inversions()
-        inverse_kperm = kperm.inverse()
+        coeff_dict = yz.schub_coprod_double(permtrim(indm[0]), indices, [syme.sympify(str(g)) for g in TR.gens()], [syme.sympify(str(g)) for g in RR.gens()])
         total_sum = 0
-        for perm, val in coeff_dict.items():
-            pperm = Permutation(list(perm))
-            downperm = pperm.left_action_product(inverse_kperm)
-            if downperm.number_of_inversions() == pperm.number_of_inversions() - inv_kperm:
-                flag = True
-                for i in range(N):
-                    if downperm[i] > N:
-                        flag = False
-                        break
-                if not flag:
-                    continue
-                firstperm = Permutation(permtrim(list(downperm[0:N])))
-                secondperm = Permutation(
-                    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])
-                ).tensor(
-                    self(
-                        (
-                            _coerce_index(secondperm, False, self._ascode),
-                            self._varlist[0],
-                        )
-                    )
-                )
+        for (fp, sp), val in coeff_dict.items():
+            firstperm = Permutation(list(fp))
+            secondperm = Permutation(list(sp))
+            # val = syme.sympify(val).subs(subs_dict_coprod)
+            total_sum += self._coeff_polynomial_ring(val) * self(_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'}"
         )