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

schubmult/rings/_tensor_schub_ring.py

@@ -0,0 +1,128 @@
+from functools import cache
+
+import symengine
+from symengine import expand
+from sympy import Add, Basic, Dict, Expr, Mul, sympify
+
+import schubmult.perm_lib as pl
+
+
+def _tensor_product_of_dicts(d1, d2):
+    ret_dict = {}
+    for k1, v1 in d1.items():
+        this_dict = {}
+        for k2, v2 in d2.items():
+            this_dict[(k1, k2)] = v1 * v2
+        ret_dict = pl.add_perm_dict(ret_dict, this_dict)
+    return Dict(ret_dict)
+
+
+class TensorBasisElement(Expr):
+    is_commutative = False
+
+    def __new__(cls, k1, k2, basis, tensor_symbol=" # "):
+        obj = Expr.__new__(cls, k1, k2, basis)
+        obj._elem1 = basis.basis1._from_dict({k1: 1})
+        obj._elem2 = basis.basis2._from_dict({k2: 1})
+        obj._tensor_symbol = tensor_symbol
+        return obj
+
+    def _sympystr(self, printer):
+        return f"{printer.doprint(self._elem1)}{self._tensor_symbol}{printer.doprint(self._elem2)}"
+
+
+class TensorAlgebraElement(Expr):
+    # tensor ring
+    def __new__(cls, _dict, basis):
+        return TensorAlgebraElement.__xnew_cached__(cls, Dict(_dict), basis)
+
+    @staticmethod
+    def __xnew__(_class, _dict, basis):
+        _dict = Dict({k: v for k, v in _dict.items() if expand(v) != 0})
+        return Expr.__new__(_class, _dict, basis)
+
+    @property
+    def coeff_dict(self):
+        return self.args[0]
+
+    @staticmethod
+    @cache
+    def __xnew_cached__(_class, _dict, basis):
+        return TensorAlgebraElement.__xnew__(_class, _dict, basis)
+
+    @property
+    def basis(self):
+        return self.args[1]
+
+    def __mul__(self, other):
+        ret_dict = {}
+        for k1, v1 in self.coeff_dict.items():
+            for k2, v2 in other.coeff_dict.items():
+                dict1 = self.basis.basis1._from_dict({k1[0]: v1 * v2}) * self.basis.basis1._from_dict({k2[0]: 1})
+                dict2 = self.basis.basis2._from_dict({k1[1]: 1}) * self.basis.basis2._from_dict({k2[1]: 1})
+                ret_dict = pl.add_perm_dict(ret_dict, _tensor_product_of_dicts(dict1.coeff_dict, dict2.coeff_dict))
+        return self.basis._from_dict(ret_dict)
+
+    def __add__(self, other):
+        return self.basis._from_dict(pl.add_perm_dict(self.coeff_dict, other.coeff_dict))
+
+    def __sub__(self, other):
+        return self.basis._from_dict(pl.add_perm_dict(self.coeff_dict, {k: -v for k, v in other.coeff_dict.items()}))
+
+    @cache
+    def cached_sympystr(self, printer):
+        ret_list = [Mul(v, TensorBasisElement(k[0], k[1], self.basis)) for k, v in self.coeff_dict.items()]
+        return printer.doprint(Add(*ret_list))
+
+    def _sympystr(self, printer):
+        return self.cached_sympystr(printer)
+
+    def expand(self, **_):
+        return sympify(
+            symengine.Add(
+                *[v * symengine.sympify(self.basis.basis1._from_dict({k[0]: 1}).expand()) * symengine.sympify(self.basis.basis2._from_dict({k[1]: 1}).expand()) for k, v in self.coeff_dict.items()],
+            ),
+        )
+
+
+class TensorAlgebraBasis(Basic):
+    # tensor ring
+    def __new__(cls, basis1, basis2):
+        return TensorAlgebraBasis.__xnew_cached__(cls, basis1, basis2)
+
+    @staticmethod
+    def __xnew__(_class, basis1, basis2):
+        return Basic.__new__(_class, basis1, basis2)
+
+    @property
+    def basis1(self):
+        return self.args[0]
+
+    @property
+    def basis2(self):
+        return self.args[1]
+
+    @property
+    def coeff_dict(self):
+        return self.args[0]
+
+    def _from_dict(self, _dict):
+        return TensorAlgebraElement(_dict, self)
+
+    @staticmethod
+    @cache
+    def __xnew_cached__(_class, basis1, basis2):
+        return TensorAlgebraBasis.__xnew__(_class, basis1, basis2)
+
+    def call2(self, *args):
+        def calla(*a):
+            return TensorAlgebraElement._from_dict(_tensor_product_of_dicts(self.basis1(*args).coeff_dict, self.basis2(*a).coeff_dict))
+
+        return calla
+
+    def __call__(self, *args):
+        return self.call2(args)
+
+
+# def TensorAlgebra_basis(Basic):
+#     pass

schubmult/rings/_utils.py

@@ -0,0 +1,55 @@
+from functools import cache
+
+from symengine import sympify
+
+from schubmult.poly_lib.variables import GeneratingSet
+
+NoneVar = 1e10
+ZeroVar = 0
+
+
+
+
+
+@cache
+def poly_ring(v: str):
+    if v == ZeroVar:
+        return tuple([sympify(0) for i in range(100)])
+    if v == NoneVar:
+        return tuple([sympify(0) for i in range(100)])
+    return GeneratingSet(str(v))
+
+# def _schubifyit(func):
+#     @wraps(func)
+#     def wrapper(f, g):
+#         g = _sympify(g)
+#         if isinstance(g, Poly):
+#             return func(f, g)
+#         elif isinstance(g, Integer):
+#             g = f.from_expr(g, *f.gens, domain=f.domain)
+#             return func(f, g)
+#         elif isinstance(g, Expr):
+#             try:
+#                 g = f.from_expr(g, *f.gens)
+#             except PolynomialError:
+#                 if g.is_Matrix:
+#                     return NotImplemented
+#                 expr_method = getattr(f.as_expr(), func.__name__)
+#                 result = expr_method(g)
+#                 if result is not NotImplemented:
+#                     sympy_deprecation_warning(
+#                         """
+#                         Mixing Poly with non-polynomial expressions in binary
+#                         operations is deprecated. Either explicitly convert
+#                         the non-Poly operand to a Poly with as_poly() or
+#                         convert the Poly to an Expr with as_expr().
+#                         """,
+#                         deprecated_since_version="1.6",
+#                         active_deprecations_target="deprecated-poly-nonpoly-binary-operations",
+#                     )
+#                 return result
+#             else:
+#                 return func(f, g)
+#         else:
+#             return NotImplemented
+#     return wrapper

schubmult/{sage_integration → sage}/__init__.py

@@ -1,4 +1,7 @@
-from sage.all import *  # noqa: F403
+try:
+    import sage  # noqa: F401
+except ImportError:
+    raise ImportError("SageMath is not installed. Please install SageMath to use this module.")
 
 from ._fast_double_schubert_polynomial_ring import (
     FastDoubleSchubertPolynomial,

schubmult/{sage_integration → sage}/_fast_double_schubert_polynomial_ring.py

@@ -10,7 +10,7 @@ from sage.combinat.composition import (
     Compositions,
 )
 from sage.combinat.free_module import CombinatorialFreeModule
-from sage.combinat.permutation import Permutation, Permutations, 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
@@ -19,14 +19,16 @@ from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_base
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 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
-import schubmult.schubmult_double as yz
-import schubmult.schubmult_q_double as qyz
+# )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 ._indexing import _coerce_index
@@ -153,12 +155,13 @@ class FastDoubleSchubertPolynomial_class(CombinatorialFreeModule.Element):
             return None
         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(),
@@ -169,12 +172,12 @@ class FastDoubleSchubertPolynomial_class(CombinatorialFreeModule.Element):
             )
         return sum(
             [
-                yz.schubmult(
-                    {(1, 2): v},
-                    tuple(_coerce_index(k[0], self.parent()._ascode, False)),
+                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((1, 2), 0)
+                ).get(pl.Permutation([]), 0)
                 for k, v in self.monomial_coefficients().items()
             ],
         )
@@ -305,6 +308,16 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
 
         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,29 +340,22 @@ 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)
-        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()})
-            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):
                 elem = self._from_dict(
@@ -362,9 +369,9 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
 
                 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
@@ -375,9 +382,9 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                             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
@@ -401,16 +408,16 @@ 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._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()],
@@ -437,28 +444,28 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         ]
 
     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):
@@ -477,65 +484,16 @@ 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):

schubmult/{sage_integration → sage}/_fast_schubert_polynomial_ring.py

@@ -17,11 +17,12 @@ from sage.rings.polynomial.multi_polynomial_ring import MPolynomialRing_base
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 from sympy import sympify
 
-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.perm_lib as pl
+import schubmult.sage._fast_double_schubert_polynomial_ring as bork
+import schubmult.schub_lib.double as yz
+import schubmult.schub_lib.quantum as sq
+import schubmult.schub_lib.quantum_double as qyz
+import schubmult.schub_lib.single as py
 from schubmult.perm_lib import permtrim
 
 from ._indexing import _coerce_index
@@ -143,7 +144,7 @@ class FastSchubertPolynomial_class(CombinatorialFreeModule.Element):
                 [
                     self.parent()._polynomial_ring(
                         qyz.schubpoly_quantum(
-                            tuple(_coerce_index(k, self.parent()._ascode, False)),
+                            pl.Permutation(_coerce_index(k, self.parent()._ascode, False)),
                             self.parent()._polynomial_ring.gens(),
                             [0 for i in range(100)],
                             self.parent()._q_ring.gens(),
@@ -156,17 +157,24 @@ class FastSchubertPolynomial_class(CombinatorialFreeModule.Element):
         return sum(
             [
                 self.parent()._polynomial_ring(
-                    yz.schubmult(
-                        {(1, 2): v},
-                        tuple(_coerce_index(k, self.parent()._ascode, False)),
+                    yz.schubmult_double(
+                        {pl.Permutation([]): v},
+                        pl.Permutation(_coerce_index(k, self.parent()._ascode, False)),
                         self.parent()._polynomial_ring.gens(),
                         [0 for i in range(100)],
-                    ).get((1, 2), 0),
+                    ).get(pl.Permutation([]), 0),
                 )
                 for k, v in self.monomial_coefficients().items()
             ],
         )
 
+    # PDB STEP WHEN LATEX CALLED
+    # def _latex_(self):
+    #     rep = "\\mathfrak{S}"
+    #     if self.is_quantum:
+    #         rep+=f"^{'{'}{self.q_varname}{'}'}"
+    #     rep+="_{"+str(()"
+
 
 @cache
 def _single_schub_parser(passed):
@@ -265,12 +273,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     def _element_constructor_(self, x):
         if isinstance(x, str):
             return self.parser().parse(x)
-        if (
-            isinstance(x, list)
-            or isinstance(x, tuple)
-            or isinstance(x, Composition)
-            or isinstance(x, Permutation)
-        ):
+        if isinstance(x, (list, tuple, Composition, Permutation, pl.Permutation)):
             # 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()},
@@ -296,15 +299,15 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             sympy_floff = sympify(str(x))
             val = syme.sympify(sympy_floff)
             if self._quantum:
-                result = sq.mult_poly(
-                    {(1, 2): 1},
+                result = sq.mult_poly_q(
+                    {pl.Permutation([]): 1},
                     val,
                     [syme.Symbol(str(g)) for g in self._polynomial_ring.gens()],
                     [syme.Symbol(str(g)) for g in self._q_ring.gens()],
                 )
             else:
-                result = py.mult_poly(
-                    {(1, 2): 1},
+                result = py.mult_poly_py(
+                    {pl.Permutation([]): 1},
                     val,
                     [syme.Symbol(str(g)) for g in self._polynomial_ring.gens()],
                 )
@@ -334,17 +337,17 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             return sum(
                 [
                     self.base_ring()(str(v)) * self(_coerce_index(k, False, self._ascode))
-                    for k, v in sq.schubmult_db(
-                        {tuple(_coerce_index(left, self._ascode, False)): self.base_ring()(1)},
-                        tuple(_coerce_index(right, self._ascode, False)),
-                        list(self._q_ring.gens()),
+                    for k, v in sq.schubmult_q_fast(
+                        {pl.Permutation(_coerce_index(left, self._ascode, False)): 1},
+                        pl.Permutation(_coerce_index(right, self._ascode, False)),
+                        [syme.sympify(str(g)) for g in self._q_ring.gens()],
                     ).items()
                 ],
             )
         return sum(
             [
                 self.base_ring()(v) * self(_coerce_index(k, False, self._ascode))
-                for k, v in py.schubmult(
+                for k, v in py.schubmult_py(
                     {tuple(_coerce_index(left, self._ascode, False)): 1},
                     tuple(_coerce_index(right, self._ascode, False)),
                 ).items()
@@ -365,7 +368,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         N = len(kcd)
         kperm = from_lehmer_code(kcd2).inverse()
         coeff_dict = {tuple(kperm): 1}
-        coeff_dict = py.schubmult(coeff_dict, tuple(mperm))
+        coeff_dict = py.schubmult_py(coeff_dict, tuple(mperm))
 
         inv_kperm = kperm.number_of_inversions()
         inverse_kperm = kperm.inverse()
@@ -390,9 +393,11 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                 ).tensor(self(_coerce_index(secondperm, False, self._ascode)))
         return total_sum
 
+    def _latex_(self, S):
+        return f"Boobfucker {S}"
 
-def _repr_(self):
-    return f"Ring of  Schubert polynomials in {self._base_varname} with {len(self._polynomial_ring.gens())} variables over {self._q_ring.base_ring()}"
+    def _repr_(self):
+        return f"Ring of  Schubert polynomials in {self._base_varname} with {len(self._polynomial_ring.gens())} variables over {self._q_ring.base_ring()}"
 
 
 FastSchubertPolynomial = FastSchubertPolynomial_class

schubmult/{sage_integration → sage}/_indexing.py

@@ -1,21 +1,24 @@
 from sage.combinat.composition import Composition
 from sage.combinat.permutation import Permutation
 
+import schubmult.perm_lib as pl
 from schubmult.perm_lib import permtrim, trimcode, uncode
 
 
 def _coerce_index(indexed_obj, is_comp, should_be_comp):
     if is_comp == should_be_comp:
-        if isinstance(indexed_obj, list) or isinstance(indexed_obj, tuple):
+        if isinstance(indexed_obj, (list, tuple, pl.Permutation)):
             if is_comp:
                 return Composition(trimcode(permtrim(uncode(list(indexed_obj)))))
-            return Permutation(permtrim(list(indexed_obj))).remove_extra_fixed_points()
+            return Permutation(list(permtrim(list(indexed_obj))))
         if not is_comp:
             if isinstance(indexed_obj, Permutation):
                 return indexed_obj.remove_extra_fixed_points()
+            if isinstance(indexed_obj, pl.Permutation):
+                return Permutation(list(indexed_obj))
             if isinstance(indexed_obj, dict):
                 {
-                Permutation(permtrim(list(k))).remove_extra_fixed_points(): v
+                Permutation(list(permtrim(list(k)))): v
                 for k, v in indexed_obj.items()
             }
     elif is_comp:
@@ -24,11 +27,11 @@ def _coerce_index(indexed_obj, is_comp, should_be_comp):
             or isinstance(indexed_obj, tuple)
             or isinstance(indexed_obj, Composition)
         ):
-            return Permutation(permtrim(uncode(list(indexed_obj)))).remove_extra_fixed_points()
+            return Permutation(list(permtrim(uncode(list(indexed_obj)))))
 
         if isinstance(indexed_obj, dict):  # keys are comps
             return {
-                Permutation(permtrim(uncode(list(k)))).remove_extra_fixed_points(): v
+                Permutation(list(permtrim(uncode(list(k))))): v
                 for k, v in indexed_obj.items()
             }
     else:
@@ -36,6 +39,7 @@ def _coerce_index(indexed_obj, is_comp, should_be_comp):
             isinstance(indexed_obj, list)
             or isinstance(indexed_obj, tuple)
             or isinstance(indexed_obj, Permutation)
+            or isinstance(indexed_obj, pl.Permutation)
         ):
             return Composition(trimcode(list(indexed_obj)))