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

schubmult/__init__.py

@@ -1 +1 @@
-__version__ = "2.0.1"
+__version__ = "2.0.3"

schubmult/_base_argparse.py

@@ -1,7 +1,7 @@
 from argparse import ArgumentParser, SUPPRESS, RawDescriptionHelpFormatter
 
 
-def schub_argparse(prog_name, description, quantum=False, yz=False):
+def schub_argparse(prog_name, description, argv, quantum=False, yz=False):
     parser = ArgumentParser(
         prog=prog_name,
         description=description,
@@ -14,7 +14,6 @@ def schub_argparse(prog_name, description, quantum=False, yz=False):
     """,
         formatter_class=RawDescriptionHelpFormatter,
     )
-
     parser.add_argument(
         "perms",
         nargs="+",
@@ -139,22 +138,36 @@ def schub_argparse(prog_name, description, quantum=False, yz=False):
                 help="Substitute commuting difference operators for perm1, then apply to Schub indexed by perm2",
             )
 
+    disp_mode_list = ["basic", "pretty", "latex", "raw"]
+
+    if not yz and not quantum:
+        disp_mode_list = ["basic", "raw"]
+
     parser.add_argument(
         "--display-mode",
         type=str,
         required=False,
-        choices=["basic", "pretty", "latex"],
+        choices=disp_mode_list,
         default="basic",
         dest="disp_mode",
         help="Method of displaying the output. Default basic",
     )
 
-    args = parser.parse_args()
+    parser.add_argument(
+        "-g",
+        action="store_true",
+        dest="gen",
+        help=SUPPRESS,
+    )
+
+    args = parser.parse_args(argv)
     args.mulstring = ""
 
     if args.mult is not None:
         args.mulstring = " ".join(args.mult)
         args.mult = True
+    else:
+        args.mult = False
 
     for perm in args.perms:
         try:
@@ -163,12 +176,28 @@ def schub_argparse(prog_name, description, quantum=False, yz=False):
         except Exception as e:
             print("Permutations must have integer values")
             raise e
+
+    if args.gen:
+        import json
+        import sys
+
+        argv.pop(argv.index("-g"))
+        args.__dict__["cmd_line"] = ["script"] + argv
+        del args.__dict__["gen"]
+        json.dump(args.__dict__, sys.stdout, ensure_ascii=False, indent=4)
+        exit(0)
+
     import sympy
 
-    formatter = lambda bob: str(bob)  # noqa: E731
     if args.disp_mode == "latex":
-        formatter = lambda bob: sympy.latex(sympy.sympify(bob)).replace("\\left", "").replace("\\right", "")  # noqa: E731
+        formatter = (  # noqa: E731
+            lambda bob: sympy.latex(sympy.sympify(bob)).replace("\\left", "").replace("\\right", "")
+        )  # noqa: E731
     elif args.disp_mode == "pretty":
         formatter = lambda bob: sympy.pretty(sympy.sympify(bob))  # noqa: E731
+    elif args.disp_mode == "basic":
+        formatter = lambda bob: str(bob)  # noqa: E731
+    elif args.disp_mode == "raw":
+        formatter = None
 
     return args, formatter

schubmult/_tests.py

@@ -0,0 +1,9 @@
+def get_json(file: str):
+    import os
+    import json
+
+    script_dir = os.path.dirname(__file__)
+    rel_path = f"../tests/{file}.json"
+    abs_file_path = os.path.join(script_dir, rel_path)
+    with open(abs_file_path, "r") as f:
+        return json.load(f)

schubmult/sage_integration/__init__.py

@@ -1,5 +1,6 @@
 from sage.all import *  # noqa: F403
 
+
 from ._fast_schubert_polynomial_ring import (
     FastSchubertPolynomialRing,
     FastSchubertPolynomial,

schubmult/sage_integration/_fast_double_schubert_polynomial_ring.py

@@ -13,17 +13,23 @@ from sage.combinat.composition import (
     Compositions,
     Composition,
 )
-from . import (
-    FastSchubertPolynomialRing_base,
-    FastSchubertPolynomial,
-)
-from ._indexing import _coerce_index
 
+# 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
+from schubmult.perm_lib import permtrim
+
+from sage.misc.parser import Parser
 
 
 def FastDoubleSchubertPolynomialRing(
@@ -191,9 +197,51 @@ class FastDoubleSchubertPolynomial_class(CombinatorialFreeModule.Element):
         return self.map_coefficients(lambda foi: RR(foi.subs(subs_dict)))
 
 
+@cache
+def _double_schub_parser(passed):
+    fdict = {}
+    vardict = {}
+    fdict[passed._sc_rep] = passed._element_constructor_
+    if passed._quantum:        
+        QSRing = bork.FastSchubertPolynomialRing(
+            passed._base_polynomial_ring.base_ring(),
+            len(passed._base_polynomial_ring.gens()),
+            passed._base_varname,
+            is_quantum=True,
+            code_display=passed._ascode,
+            q_varname=passed._q_varname,
+        )
+        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,
+        ) 
+    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),
+        )
+    fdict[DRing._sc_rep] = DRing._element_constructor_
+    fdict[SRing._sc_rep] = SRing._element_constructor_        
+    for g in passed._base_polynomial_ring.gens():
+            vardict[str(g)] = g
+    return Parser(make_function=fdict, make_var=vardict)
+
+
 class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     Element = FastDoubleSchubertPolynomial_class
 
+    #def inject_variables:
+
+    def parser(self):
+        if self._parser is None:
+            self._parser = _double_schub_parser(self)
+        return self._parser
+
     def __init__(
         self,
         R,
@@ -255,14 +303,17 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
             else GradedBialgebrasWithBasis(self._coeff_polynomial_ring).Commutative()
         )
 
+        self._sc_rep = f"{'Q' if quantum else ''}DS{base_variable_name}"
+
         CombinatorialFreeModule.__init__(
             self,
             self._coeff_polynomial_ring,
             self._index_wrapper,
             category=cat,
-            prefix=f"{'Q' if quantum else ''}S{base_variable_name}",
+            prefix=self._sc_rep,
         )
         self._populate_coercion_lists_()
+        self._parser = None
 
     @cached_method
     def one_basis(self):
@@ -281,7 +332,9 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         elif len(x) > 2:
             raise ValueError("Bad index for element")
 
-        if (
+        if isinstance(x, str):
+            return self.parser().parse(x)
+        elif (
             isinstance(x, list)
             or isinstance(x, tuple)
             or isinstance(x, Permutation)
@@ -315,7 +368,7 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
                 )
             else:
                 return self(x.expand())
-        elif isinstance(x, FastSchubertPolynomial):
+        elif isinstance(x, bork.FastSchubertPolynomial):
             if (
                 x.base_varname == self._base_varname
                 and x.q_varname == self._q_varname
@@ -447,10 +500,12 @@ class FastDoubleSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
     def _coerce_map_from_(self, S):
         if isinstance(S, MPolynomialRing_base):
             return True
-        if isinstance(S, FastSchubertPolynomialRing_base):
+        if isinstance(S, bork.FastSchubertPolynomialRing_base):
             return True
         if isinstance(S, FastDoubleSchubertPolynomialRing_base):
             return True
+        if isinstance(S, str):
+            return True
         return super().has_coerce_map_from(S)
 
     def coproduct_on_basis(self, indm):
@@ -502,8 +557,10 @@ class FastDoubleSchubertPolynomialRing_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))])
+                )
                 val = TR(val).subs(subs_dict_coprod)
                 total_sum += self._coeff_polynomial_ring(val) * self(
                     (_coerce_index(firstperm, False, self._ascode), indm[1])

schubmult/sage_integration/_fast_schubert_polynomial_ring.py

@@ -14,7 +14,7 @@ from sage.rings.polynomial.multi_polynomial import MPolynomial
 from sage.rings.polynomial.polynomial_ring_constructor import PolynomialRing
 from ._indexing import _coerce_index
 
-
+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
@@ -22,7 +22,12 @@ import schubmult.schubmult_double as yz
 
 
 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
 
 
 def FastSchubertPolynomialRing(
@@ -161,8 +166,31 @@ class FastSchubertPolynomial_class(CombinatorialFreeModule.Element):
             )
 
 
+@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,
@@ -193,18 +221,26 @@ 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
         self._q_varname = q_varname
-        self._polynomial_ring = PolynomialRing(R, num_vars, base_variable_name)
+        self._polynomial_ring = (
+            PolynomialRing(R, num_vars, base_variable_name)
+            if not quantum
+            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):
@@ -213,6 +249,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
@@ -223,7 +261,9 @@ class FastSchubertPolynomialRing_xbasis(CombinatorialFreeModule):
         self._splitter = indices
 
     def _element_constructor_(self, x):
-        if (
+        if isinstance(x, str):
+            return self.parser().parse(x)
+        elif (
             isinstance(x, list)
             or isinstance(x, tuple)
             or isinstance(x, Composition)
@@ -340,8 +380,10 @@ 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)
                 ).tensor(self(_coerce_index(secondperm, False, self._ascode)))

schubmult/sage_integration/_indexing.py

@@ -11,9 +11,16 @@ def _coerce_index(indexed_obj, is_comp, should_be_comp):
             if is_comp:
                 return Composition(trimcode(permtrim(uncode(list(indexed_obj)))))
             else:
-                return Permutation(permtrim(list(indexed_obj)))
+                return Permutation(permtrim(list(indexed_obj))).remove_extra_fixed_points()
         else:
-            return indexed_obj
+            if not is_comp:
+                if isinstance(indexed_obj, Permutation):
+                    return indexed_obj.remove_extra_fixed_points()
+                elif isinstance(indexed_obj, dict):
+                    {
+                    Permutation(permtrim(list(k))).remove_extra_fixed_points(): v
+                    for k, v in indexed_obj.items()
+                }
     else:
         if is_comp:
             if (
@@ -21,11 +28,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))))
+                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
+                    Permutation(permtrim(uncode(list(k)))).remove_extra_fixed_points(): v
                     for k, v in indexed_obj.items()
                 }
         else:

schubmult/schubmult_double/__init__.py

@@ -4,15 +4,19 @@ from ._funcs import (
     single_variable,
     mult_poly,
     posify,
-    div_diff
+    div_diff,
+    schub_coprod
 )
 
 
+
 __all__ = [
     "compute_positive_rep",
     "schubmult",
     "single_variable",
     "mult_poly",
     "posify",
-    "div_diff"
+    "div_diff",
+    "schub_coprod",
+    "main"
 ]

schubmult/schubmult_double/__main__.py

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