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

schubmult/sage_integration/_fast_schubert_polynomial_ring.py

@@ -1,28 +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.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 ._indexing import _coerce_index
 
-from sympy import sympify
-import symengine as syme
+# FastQuantumDoubleSchubertPolynomialRing = bork.FastQuantumDoubleSchubertPolynomialRing
 
 
 def FastSchubertPolynomialRing(
@@ -33,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,
@@ -62,6 +67,7 @@ def FastSchubertPolynomialRing(
 
     Returns:
         FastSchubertPolynomialRing_xbasis: Element constructor of the ring
+
     """
     if is_quantum:
         QR = PolynomialRing(R, num_vars, q_varname)
@@ -86,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.
@@ -101,6 +108,7 @@ def FastQuantumSchubertPolynomialRing(
 
     Returns:
         FastSchubertPolynomialRing_xbasis: Element constructor of the ring
+
     """
     return FastSchubertPolynomialRing(
         R,
@@ -140,30 +148,52 @@ 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
+def _single_schub_parser(passed):
+    if passed._quantum:
+        q_varname = passed._q_varname
+    else:
+        q_varname = "q"
+    QDRing = bork.FastQuantumDoubleSchubertPolynomialRing(
+        passed.base_ring(),
+        len(passed._polynomial_ring.gens()),
+        passed._base_varname,
+        coeff_variable_names="y",
+        code_display=passed._ascode,
+        q_varname=q_varname,
+    )
+    return QDRing.parser()
 
 
 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,
         R,
@@ -193,12 +223,15 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             index_set = Compositions()
             self._ascode = True
 
+        self._sc_rep = f"{'Q' if quantum else ''}S{base_variable_name}"
+
         CombinatorialFreeModule.__init__(
             self,
             R if not quantum else QR,
             index_set,
             category=cat,
-            prefix=f"QS{base_variable_name}",
+            prefix=self._sc_rep,
+            bracket="(",
         )
         self._q_ring = QR
         self._base_varname = base_variable_name
@@ -209,6 +242,7 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             else PolynomialRing(QR, num_vars, base_variable_name)
         )
         self._populate_coercion_lists_()
+        self._parser = None
 
     def _coerce_map_from_(self, S):
         if isinstance(S, MPolynomialRing_base):
@@ -217,6 +251,8 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             return True
         if isinstance(S, FastSchubertPolynomialRing_base):
             return True
+        if isinstance(S, str):
+            return True
         return super()._coerce_map_from_(S)
 
     @cached_method
@@ -227,6 +263,8 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         self._splitter = indices
 
     def _element_constructor_(self, x):
+        if isinstance(x, str):
+            return self.parser().parse(x)
         if (
             isinstance(x, list)
             or isinstance(x, tuple)
@@ -235,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 (
@@ -247,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())
@@ -276,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}")
@@ -301,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:
@@ -344,10 +381,12 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                         break
                 if not flag:
                     continue
-                firstperm = Permutation(list(downperm[0:N]))
-                secondperm = Permutation([downperm[i] - N for i in range(N, len(downperm))])
+                firstperm = Permutation(permtrim(list(downperm[0:N])))
+                secondperm = Permutation(
+                    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
 

schubmult/sage_integration/_indexing.py

@@ -1,8 +1,7 @@
-from sage.combinat.permutation import Permutation
-
 from sage.combinat.composition import Composition
+from sage.combinat.permutation import Permutation
 
-from schubmult.perm_lib import uncode, trimcode, permtrim
+from schubmult.perm_lib import permtrim, trimcode, uncode
 
 
 def _coerce_index(indexed_obj, is_comp, should_be_comp):
@@ -10,35 +9,39 @@ def _coerce_index(indexed_obj, is_comp, should_be_comp):
         if isinstance(indexed_obj, list) or isinstance(indexed_obj, tuple):
             if is_comp:
                 return Composition(trimcode(permtrim(uncode(list(indexed_obj)))))
-            else:
-                return Permutation(permtrim(list(indexed_obj)))
-        else:
-            return indexed_obj
-    else:
-        if is_comp:
-            if (
-                isinstance(indexed_obj, list)
-                or isinstance(indexed_obj, tuple)
-                or isinstance(indexed_obj, Composition)
-            ):
-                return Permutation(permtrim(uncode(list(indexed_obj))))
+            return Permutation(permtrim(list(indexed_obj))).remove_extra_fixed_points()
+        if not is_comp:
+            if isinstance(indexed_obj, Permutation):
+                return indexed_obj.remove_extra_fixed_points()
+            if isinstance(indexed_obj, dict):
+                {
+                Permutation(permtrim(list(k))).remove_extra_fixed_points(): 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(permtrim(uncode(list(indexed_obj)))).remove_extra_fixed_points()
 
-            if isinstance(indexed_obj, dict):  # keys are comps
-                return {
-                    Permutation(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)
-            ):
-                return Composition(trimcode(list(indexed_obj)))
+        if isinstance(indexed_obj, dict):  # keys are comps
+            return {
+                Permutation(permtrim(uncode(list(k)))).remove_extra_fixed_points(): v
+                for k, v in indexed_obj.items()
+            }
+    else:
+        if (
+            isinstance(indexed_obj, list)
+            or isinstance(indexed_obj, tuple)
+            or isinstance(indexed_obj, 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()
-                }
+        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/schubmult_double/__init__.py

@@ -1,18 +1,12 @@
-from ._funcs import (
-    compute_positive_rep,
-    schubmult,
-    single_variable,
-    mult_poly,
-    posify,
-    div_diff
-)
-
+from ._funcs import compute_positive_rep, div_diff, mult_poly, posify, schub_coprod, schubmult, single_variable
 
 __all__ = [
     "compute_positive_rep",
-    "schubmult",
-    "single_variable",
+    "div_diff",
+    "main",
     "mult_poly",
     "posify",
-    "div_diff"
+    "schub_coprod",
+    "schubmult",
+    "single_variable",
 ]

schubmult/schubmult_double/__main__.py

@@ -1,5 +1,6 @@
 import sys
+
 from ._script import main
 
 if __name__ == "__main__":
-    sys.exit(main())
+    sys.exit(main(sys.argv))