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

schubmult/{sage_integration → sage}/_fast_schubert_polynomial_ring.py

@@ -1,32 +1,32 @@
+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
 
+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
-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 ._indexing import _coerce_index
 
-from sympy import sympify
-
-# 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 +38,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 +68,7 @@ def FastSchubertPolynomialRing(
 
     Returns:
         FastSchubertPolynomialRing_xbasis: Element constructor of the ring
+
     """
     if is_quantum:
         QR = PolynomialRing(R, num_vars, q_varname)
@@ -91,7 +93,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 +109,7 @@ def FastQuantumSchubertPolynomialRing(
 
     Returns:
         FastSchubertPolynomialRing_xbasis: Element constructor of the ring
+
     """
     return FastSchubertPolynomialRing(
         R,
@@ -140,30 +144,36 @@ 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(),
                             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_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(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
@@ -185,12 +195,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,15 +273,10 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     def _element_constructor_(self, x):
         if isinstance(x, str):
             return self.parser().parse(x)
-        elif (
-            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()}
+                {_coerce_index(x, self._ascode, self._ascode): self.base_ring().one()},
             )
         elif isinstance(x, FastSchubertPolynomial):
             if (
@@ -283,7 +288,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())
@@ -294,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()],
                 )
@@ -312,7 +317,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}")
@@ -332,23 +337,22 @@ 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()
-                ]
-            )
-        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_py(
+                    {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:
@@ -364,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()
@@ -382,16 +386,18 @@ 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
 
+    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/_indexing.py

@@ -0,0 +1,51 @@
+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, tuple, pl.Permutation)):
+            if is_comp:
+                return Composition(trimcode(permtrim(uncode(list(indexed_obj)))))
+            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(list(permtrim(list(k)))): v
+                for k, v in indexed_obj.items()
+            }
+    elif is_comp:
+        if (
+            isinstance(indexed_obj, list)
+            or isinstance(indexed_obj, tuple)
+            or isinstance(indexed_obj, Composition)
+        ):
+            return Permutation(list(permtrim(uncode(list(indexed_obj)))))
+
+        if isinstance(indexed_obj, dict):  # keys are comps
+            return {
+                Permutation(list(permtrim(uncode(list(k))))): v
+                for k, v in indexed_obj.items()
+            }
+    else:
+        if (
+            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)))
+
+        if isinstance(indexed_obj, dict):  # keys are comps
+            return {
+                Composition(trimcode(permtrim(list(k)))): v
+                for k, v in indexed_obj.items()
+            }
+    raise TypeError

schubmult/schub_lib/__init__.py

@@ -0,0 +1,51 @@
+# from .quantum_double import (
+#     schubpoly_quantum,
+# )
+# from .schub_lib import (
+#     check_blocks,
+#     compute_vpathdicts,
+#     divdiffable,
+#     double_elem_sym_q,
+#     elem_sym_perms,
+#     elem_sym_perms_op,
+#     elem_sym_perms_q,
+#     elem_sym_perms_q_op,
+#     is_coeff_irreducible,
+#     is_hook,
+#     is_reducible,
+#     is_split_two,
+#     kdown_perms,
+#     pull_out_var,
+#     reduce_coeff,
+#     reduce_descents,
+#     reduce_q_coeff,
+#     reduce_q_coeff_u_only,
+#     try_reduce_u,
+#     try_reduce_v,
+#     will_formula_work,
+# )
+
+# __all__ = [
+#     "check_blocks",
+#     "compute_vpathdicts",
+#     "divdiffable",
+#     "double_elem_sym_q",
+#     "elem_sym_perms",
+#     "elem_sym_perms_op",
+#     "elem_sym_perms_q",
+#     "elem_sym_perms_q_op",
+#     "is_coeff_irreducible",
+#     "is_hook",
+#     "is_reducible",
+#     "is_split_two",
+#     "kdown_perms",
+#     "pull_out_var",
+#     "reduce_coeff",
+#     "reduce_descents",
+#     "reduce_q_coeff",
+#     "reduce_q_coeff_u_only",
+#     "schubpoly_quantum",
+#     "try_reduce_u",
+#     "try_reduce_v",
+#     "will_formula_work",
+# ]