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

schubmult/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "3.0.0"
+__version__ = "3.0.1"
 #schubpoly_from_elems?
 from .perm_lib import Permutation, permtrim, theta, uncode
 from .poly_lib.poly_lib import efficient_subs, elem_sym_poly, elem_sym_poly_q, q_vector, xreplace_genvars
@@ -7,6 +7,7 @@ from .poly_lib.variables import CustomGeneratingSet, GeneratingSet, GeneratingSe
 from .rings._quantum_schubert_polynomial_ring import (
     QDSx,
     QPDSx,
+    QPSx,
     QSx,
 )
 from .rings._schubert_polynomial_ring import (
@@ -52,6 +53,7 @@ __all__ = [
     "Permutation",
     "QDSx",
     "QPDSx",
+    "QPSx",
     "QSx",
     "Sx",
     "apply_peterson_woodward",

schubmult/perm_lib.py

@@ -47,6 +47,26 @@ class Permutation(Basic):
         L.sort(key=lambda i: itera[i - 1])
         return Permutation(L)
 
+    def _latex(self, printer):
+        if Permutation.print_as_code:
+            return printer.doprint(trimcode(self))
+        return printer.doprint(list(self._perm))
+
+    # pattern is a list, not a permutation
+    def has_pattern(self, pattern):
+        if self == Permutation(pattern):
+            return True
+        if len(self._perm) <= len(Permutation(pattern)):
+            return False
+        expanded = list(self) + [i for i in range(len(self)+1,len(pattern)+1)]
+        for i in range(len(expanded)):
+            rmval = expanded[i]
+            perm2 = [*expanded[:i], *expanded[i+1:]]
+            perm2 = tuple([val-1 if val>rmval else val for val in perm2])
+            if Permutation(perm2).has_pattern(pattern):
+                return True
+        return False
+
     def _sympystr(self, printer):
         if Permutation.print_as_code:
             return printer.doprint(trimcode(self))
@@ -350,3 +370,5 @@ def split_perms(perms):
         if not did:
             perms2 += [perm]
     return perms2
+
+bad_classical_patterns = [Permutation([1,4,2,3]), Permutation([1,4,3,2]), Permutation([4,1,3,2]), Permutation([3,1,4,2])]

schubmult/poly_lib/poly_lib.py

@@ -1,6 +1,7 @@
 from functools import cache, cached_property
 
 import symengine
+import sympy
 from symengine import Mul, Pow, sympify
 
 import schubmult.perm_lib as pl
@@ -56,6 +57,20 @@ zero = sympify(0)
 
 _vars = _gvars()
 
+def sv_posify(val, var2):
+    var_r = vv.GeneratingSet("r")
+    subs_dict = {}
+    for i in range(1, 100):
+        sm = sympify(var2[1])
+        for j in range(1, i):
+            sm += var_r[j]
+        subs_dict[sympify(var2[i])] = sm
+    val = sympify(sympy.simplify(efficient_subs(sympify(val), subs_dict)))
+    bingle_dict = {}
+    for i in range(1, len(var_r) - 1):
+        bingle_dict[var_r[i]] = var2[i + 1] - var2[i]  # sympy.Add(*[_vars.var2[i+1], - _vars.var2[i]],evaluate=False)
+    return val.xreplace(bingle_dict)
+
 def act(w, poly, genset):
     if not isinstance(w, pl.Permutation):
         w = pl.Permutation(w)
@@ -148,6 +163,23 @@ def elem_sym_poly_q(p, k, varl1, varl2, q_var=_vars.q_var):
     )
 
 
+def complete_sym_poly(p, k, vrs):
+    if p == 0 and k>=0:
+        return 1
+    if p != 0 and k == 0:
+        return 0
+    if k < 0:
+        return 0
+    if k == 1:
+        return vrs[0]**p
+    sm = 0
+    mid = k // 2
+    for i in range(p + 1):
+        sm += complete_sym_poly(i, mid, vrs[:mid])*complete_sym_poly(p-i, k-mid, vrs[mid:])
+    return sm
+
+
+
 def elem_sym_poly(p, k, varl1, varl2, xstart=0, ystart=0):
     if p > k:
         return zero

schubmult/rings/__init__.py

@@ -1,4 +1,4 @@
-from ._quantum_schubert_polynomial_ring import QDSx, QPDSx, QSx, QuantumDoubleSchubertAlgebraElement, QuantumDoubleSchubertAlgebraElement_basis, make_parabolic_quantum_basis
+from ._quantum_schubert_polynomial_ring import QDSx, QPDSx, QPSx, QSx, QuantumDoubleSchubertAlgebraElement, QuantumDoubleSchubertAlgebraElement_basis, make_parabolic_quantum_basis
 from ._schubert_polynomial_ring import DoubleSchubertAlgebraElement, DoubleSchubertAlgebraElement_basis, DSx, Sx
 from ._utils import poly_ring
 
@@ -8,6 +8,7 @@ __all__ = [
     "DoubleSchubertAlgebraElement_basis",
     "QDSx",
     "QPDSx",
+    "QPSx",
     "QSx",
     "QuantumDoubleSchubertAlgebraElement",
     "QuantumDoubleSchubertAlgebraElement_basis",

schubmult/rings/_quantum_schubert_polynomial_ring.py

@@ -4,7 +4,7 @@ from bisect import bisect_left
 from functools import cache
 
 import sympy
-from symengine import S, sympify
+from symengine import S, Symbol, sympify
 from sympy import Basic
 
 import schubmult.rings._schubert_polynomial_ring as spr
@@ -12,7 +12,7 @@ import schubmult.rings._utils as utils
 import schubmult.schub_lib.quantum as py
 import schubmult.schub_lib.quantum_double as yz
 from schubmult.perm_lib import Permutation, longest_element
-from schubmult.poly_lib.poly_lib import elem_sym_poly, elem_sym_poly_q, xreplace_genvars
+from schubmult.poly_lib.poly_lib import complete_sym_poly, elem_sym_poly, elem_sym_poly_q, xreplace_genvars
 from schubmult.poly_lib.schub_poly import schubpoly_from_elems
 from schubmult.poly_lib.variables import GeneratingSet, GeneratingSet_base
 from schubmult.utils.logging import get_logger
@@ -31,14 +31,14 @@ class QuantumDoubleSchubertAlgebraElement(spr.BasisSchubertAlgebraElement):
         return spr.BasisSchubertAlgebraElement.__new__(cls, _dict, basis)
 
     def subs(self, old, new):
-        logger.debug("ferefef")
-        elb = self.as_classical().subs(old, new).as_quantum()
-        logger.debug(f"{elb=}")
-        return elb
+        return self.as_classical().subs(old, new).as_quantum()
 
 
 # # TODO: not a noncommutative symbol, something else
 # # Atomic Schubert polynomial
+_pretty_schub_char = "𝕼𝔖"  # noqa: RUF001
+
+
 class QDSchubPoly(QuantumDoubleSchubertAlgebraElement):
     is_Atom = True
 
@@ -49,6 +49,7 @@ class QDSchubPoly(QuantumDoubleSchubertAlgebraElement):
     def __xnew__(_class, k, basis):
         obj = QuantumDoubleSchubertAlgebraElement.__new__(_class, sympy.Dict({(Permutation(k[0]), k[1]): 1}), basis)
         obj._perm = k[0]
+        obj._key = k
         obj._coeff_var = k[1]
         # obj._base_var = base_var
         return obj
@@ -63,6 +64,23 @@ class QDSchubPoly(QuantumDoubleSchubertAlgebraElement):
             return printer.doprint(f"QS{self.genset.label}({printer.doprint(self._perm)})")
         return printer.doprint(f"QDS{self.genset.label}({printer.doprint(self._perm)}, {spr._varstr(self._coeff_var)})")
 
+    def _pretty(self, printer):
+        if self._key[0] == Permutation([]):
+            return printer._print(1)
+        subscript = printer.doprint(int("".join([str(i) for i in self._key[0]])))
+        if self._key[1] == 0 or self._key[1] == utils.NoneVar:
+            return printer._print_Function(sympy.Function(f"{_pretty_schub_char}_{subscript}")(sympy.Symbol(self.genset.label)))
+        return printer._print_Function(sympy.Function(f"{_pretty_schub_char}_{subscript}")(sympy.Symbol(f"{self.genset.label}; {self._key[1]}")))
+
+    def _latex(self, printer):
+        if self._key[0] == Permutation([]):
+            return printer._print(1)
+        # subscript = printer._print(int("".join([str(i) for i in self._key[0]])))
+        subscript = sympy.sstr(self._key[0])
+        if self._key[1] == 0 or self._key[1] == utils.NoneVar:
+            return printer._print_Function(sympy.Function("\\widetilde{\\mathfrak{S}}" + f"_{'{' + subscript + '}'}")(sympy.Symbol(self.genset.label)))
+        return printer._print_Function(sympy.Function("\\widetilde{\\mathfrak{S}}" + f"_{'{' + subscript + '}'}")(sympy.Symbol(f"{self.genset.label}; {self._key[1]}")))
+
 
 class ParabolicQuantumDoubleSchubertAlgebraElement(spr.BasisSchubertAlgebraElement):
     def __new__(cls, _dict, basis):
@@ -91,6 +109,7 @@ class PQDSchubPoly(ParabolicQuantumDoubleSchubertAlgebraElement):
     def __xnew__(_class, k, basis):
         obj = ParabolicQuantumDoubleSchubertAlgebraElement.__new__(_class, sympy.Dict({(Permutation(k[0]), k[1]): 1}), basis)
         obj._perm = k[0]
+        obj._key = k
         # obj._perm._print_as_code = True
         obj._coeff_var = k[1]
         # obj._base_var = base_var
@@ -106,11 +125,48 @@ class PQDSchubPoly(ParabolicQuantumDoubleSchubertAlgebraElement):
             return printer.doprint(f"QPS{self.genset.label}{(tuple(self.index_comp))}({printer.doprint(self._perm)})")
         return printer.doprint(f"QPDS{self.genset.label}{tuple(self.index_comp)}({printer.doprint(self._perm)}, {spr._varstr(self._coeff_var)})")
 
+    def _pretty(self, printer):
+        if self._key[0] == Permutation([]):
+            return printer._print(1)
+        subscript = printer._print(int("".join([str(i) for i in self._key[0]])))
+        # subscript = sympy.sstr(self._key[0])
+        if self._key[1] == 0 or self._key[1] == utils.NoneVar:
+            return printer._print_Function(sympy.Function(f"{_pretty_schub_char}_{subscript}")(sympy.Symbol(f"{self.genset.label} | {self.basis.index_comp}")))
+        return printer._print_Function(sympy.Function(f"{_pretty_schub_char}_{subscript}")(sympy.Symbol(f"{self.genset.label}; {self._key[1]} | {self.basis.index_comp}")))
+
+    def _latex(self, printer):
+        if self._key[0] == Permutation([]):
+            return printer._print(1)
+        # subscript = printer._print(int("".join([str(i) for i in self._key[0]])))
+        subscript = printer._print(self._key[0])
+        supscript = printer._print(sympy.Tuple(*self.index_comp))
+        if self._key[1] == 0 or self._key[1] == utils.NoneVar:
+            return printer._print_Function(sympy.Function("\\widetilde{\\mathfrak{S}}" + f"^{'{'}{supscript}{'}'}_{'{' + subscript + '}'}")(sympy.Symbol(self.genset.label)))
+        return printer._print_Function(sympy.Function("\\widetilde{\\mathfrak{S}}" + f"^{'{'}{supscript}{'}'}_{'{' + subscript + '}'}")(sympy.Symbol(f"{self.genset.label}; {self._key[1]}")))
+
 
 class QuantumDoubleSchubertAlgebraElement_basis(Basic):
     def __new__(cls, genset):
         return Basic.__new__(cls, genset)
 
+    @property
+    def symbol_elem_func(self):
+        def elem_func(p, k, varl1, varl2):  # noqa: ARG001
+            if p == 0 and k >= 0:
+                return 1
+            if p < 0 or p > k:
+                return 0
+            return sympy.Add(*[(Symbol(f"e_{p - i}_{k}") if p - i > 0 else 1) * complete_sym_poly(i, k + 1 - p, [-v for v in varl2]) for i in range(p + 1)])
+
+        return elem_func
+
+    def elem_sym_subs(self, kk):
+        elems = []
+        for k in range(1, kk + 1):
+            for p in range(1, k + 1):
+                elems += [(sympy.Symbol(f"e_{p}_{k}"), elem_sym_poly_q(p, k, self.genset[1:], utils.poly_ring(0)))]
+        return dict(elems)
+
     def _from_dict(self, _dict):
         return QuantumDoubleSchubertAlgebraElement(_dict, self)
 
@@ -210,13 +266,13 @@ class QuantumDoubleSchubertAlgebraElement_basis(Basic):
             if x.genset == self.genset:
                 return self(x.expand(), cv, genset)
         else:
-            logger.debug("bagelflap")
+            # logger.debug("bagelflap")
             x = sympify(x)
             if cv is None or cv == utils.NoneVar:
                 cv = utils.NoneVar
-                logger.debug(f"{x=} {list(genset)=}")
+                # logger.debug(f"{x=} {list(genset)=}")
                 result = py.mult_poly_q({Permutation([]): 1}, x, genset)
-                logger.debug(f"{result=}")
+                # logger.debug(f"{result=}")
             else:
                 result = yz.mult_poly_q_double({Permutation([]): 1}, x, genset, utils.poly_ring(cv))
             elem = QuantumDoubleSchubertAlgebraElement({(k, cv): v for k, v in result.items()}, self)
@@ -275,48 +331,39 @@ class QuantumSchubertAlgebraElement_basis(QuantumDoubleSchubertAlgebraElement_ba
             elem = self._from_single_dict(result)
         return elem
 
+    def in_SEM_basis(self):
+        result = S.Zero
+        for k, v in self.coeff_dict.items():
+            if len(k[0]) > len(self._longest):
+                parabolic_index = []
+                start = 0
+                # 1, 2 | 3
+                index_comp = [*self._n, len(k[0]) + 1 - self._N[-1]]
+                for i in range(len(index_comp)):
+                    end = start + index_comp[i]
+                    parabolic_index += list(range(start + 1, end))
+                    # start += int(args.parabolic[i])
+                    start = end
+                otherlong = Permutation(list(range(parabolic_index[-1] + 1, 0, -1)))
+                longpar = Permutation(longest_element(parabolic_index))
+                # print(f"{longpar=} {parabolic_index=}")
+                longest = otherlong * longpar
+                # print(f"new longest = {longest=}")
+            else:
+                longest = self._longest
+            result += v * schubpoly_from_elems(k[0], self.genset, utils.poly_ring(k[1]), elem_func=self.basis.symbol_elem_func, mumu=~longest)
+        return result
+
 
 class ParabolicQuantumDoubleSchubertAlgebraElement_basis(Basic):
     def __new__(cls, genset, index_comp):
-        obj = Basic.__new__(cls, genset, tuple(index_comp))
+        obj = Basic.__new__(cls, genset, sympy.Tuple(*index_comp))
         obj._quantum_basis = QuantumDoubleSchubertAlgebraElement_basis(genset)
         obj._classical_basis = spr.DoubleSchubertAlgebraElement_basis(genset)
         obj._n = list(index_comp)
         obj._N = [sum(obj._n[:i]) for i in range(len(obj._n) + 1)]
-        # print(f"{obj._N=}")
-        # obj._D = []
-        # obj._E = {}
-        # from symengine import Matrix
-        # for j in range(1, len(obj._N)):
-        #     m_arr = [[0 for i in range(obj._N[j])] for p in range(obj._N[j])]
-        #     for i in range(obj._N[j]):
-        #         m_arr[i][i] = a[i+1] - t[1] #genset[i+1] - t[1]
-        #         if i < obj._N[j] - 1:
-        #             m_arr[i][i+1] = -1
-        #     for b in range(1, j):
-        #         njm1 = obj._N[b + 1] - 1
-        #         njp1 = obj._N[b - 1]
-        #         # print(f"{b=}")
-        #         # print(f"{njm1=} {njp1=}")
-        #         if njp1 < obj._N[j] and njm1 < obj._N[j]:
-        #             # print(f"{b=} {obj._n[b]=}")
-        #             m_arr[njm1][njp1] = -(-1)**(obj._n[b])*q_var[b]
-        #     # print(Matrix(m_arr))
-        #     poly = Matrix(m_arr).det().simplify()
-        #     # print(f"{poly=}")
-        #     # def dongle(v):
-        #     #     return poly.subs(t[1], v)
-        #     obj._D += [spunky_basis(poly)]
-        #     obj._E[obj._N[j]] = {obj._N[j]: obj._D[-1]}
-        #     for i in range(1,obj._N[j]):
-        #         obj._E[obj._N[j]][obj._N[j] - i] = -obj._E[obj._N[j]][obj._N[j] - i + 1].divdiff(i)
-        # # print(obj._E)
-        # add_am = 6
-        # index_comp += [add_am]
-        # obj._N += [obj._N[-1] + add_am]
         parabolic_index = []
         start = 0
-        # 1, 2 | 3
         for i in range(len(index_comp)):
             end = start + index_comp[i]
             parabolic_index += list(range(start + 1, end))
@@ -325,9 +372,27 @@ class ParabolicQuantumDoubleSchubertAlgebraElement_basis(Basic):
         obj._parabolic_index = parabolic_index
         obj._otherlong = Permutation(list(range(obj._N[-1], 0, -1)))
         obj._longest = obj._otherlong * longest_element(parabolic_index)
-        # obj._E[0] = obj._from_dict({(Permutation([]),utils.NoneVar): S.One})
         return obj
 
+    @property
+    def symbol_elem_func(self):
+        def elem_func(p, k, varl1, varl2):  # noqa: ARG001
+            if p == 0 and k >= 0:
+                return 1
+            if p < 0 or p > k:
+                return 0
+            return sympy.Add(*[(Symbol(f"e_{p - i}_{k}") if p - i > 0 else 1) * complete_sym_poly(i, k + 1 - p, [-v for v in varl2]) for i in range(p + 1)])
+
+        return elem_func
+
+    def elem_sym_subs(self, kk):
+        elems = []
+        elem_func = self.elem_sym
+        for k in range(1, kk + 1):
+            for p in range(1, k + 1):
+                elems += [(sympy.Symbol(f"e_{p}_{k}"), elem_func(p, k, self.genset[1:], utils.poly_ring(0)))]
+        return dict(elems)
+
     @property
     def parabolic_index(self):
         return self._parabolic_index
@@ -379,59 +444,20 @@ class ParabolicQuantumDoubleSchubertAlgebraElement_basis(Basic):
     #         )
     #     return res
 
-    def elem_sym(self):
-        def elem_func(p, k, varl1, varl2):
-            # print(f"{p=} {k=} {self._N=}")
-            if p < 0 or p > k:
-                return 0
-            if p == 0 and k >= 0:
-                return 1
-            if k <= self._N[1]:
-                return elem_sym_poly(p, k, varl1, varl2)
-            ret = 0
-            j = bisect_left(self._N, k)
-            if j < len(self._N) and k == self._N[j]:
-                ret = (-((-1) ** (self._n[j - 1]))) * q_var[j - 1] * elem_func(p - self._N[j] + self._N[j - 2], self._N[j - 2], varl1, varl2)
-            ret += elem_func(p, k - 1, varl1, varl2) + (varl1[k - 1] - varl2[k - p]) * elem_func(p - 1, k - 1, varl1, varl2)
-            return ret
-
-        return elem_func
-
-    def boingle_elem_sym(self):
-        def elem_func(p, k, varl1, varl2):
-            if p == 0 and k >= 0:
-                return S.One
-            if p < 0 or p > k:
-                return S.Zero
-            # print(f"{p=} {k=}")
-            spoink = self._E[k][p]
-            # print(f"{spoink=}")
-            # for i in range(1,k - p + 1):
-            #     spoink = -spoink.divdiff(i)
-            return sympify(sympify(spoink.as_polynomial()).xreplace({t[i]: varl2[i - 1] for i in range(1, len(varl2) + 1)})).xreplace({a[i]: varl1[i - 1] for i in range(1, len(varl1) + 1)})
-            # TEMP
-            # varl2 = utils.poly_ring(0)
-            # if p < 0 or p > k:
-            #     return 0
-            # if p == 0 and k >= 0:
-            #     return 1
-            # if k == self._N[1]:
-            #     return elem_sym_poly(p, k, varl1, varl2)
-            # print(f"{p=} {k=} {self._N=}")
-            # ret = 0
-            # j = bisect_left(self._N, k)
-            # if j < len(self._N) and k == self._N[j]:
-            #     ret = (-((-1) ** (self._n[j - 1]))) * q_var[j - 1] * elem_func(p - self._N[j] + self._N[j - 2], self._N[j - 2], varl1, varl2)
-            #     #ret += elem_func(p, self._N[j-1], varl1, varl2)
-            #     # print(f"{self._n[j-1]=}")
-            #     for i in range(min(p+1,self._n[j-1]+1)):
-            #         # print(f"{p=} {p - i=} {i=} {self._N[j-1]-1=} {self._N[j-1]-1-i=} {len(varl2)=}")
-            #         ret += varl1[self._N[j] - 1 - i] * elem_func(p - i, self._N[j-1], varl1, varl2)
-            # else:
-            #     # print("Bob jones")
-            # return ret
-
-        return elem_func
+    def elem_sym(self, p, k, varl1, varl2):
+        # print(f"{p=} {k=} {self._N=}")
+        if p < 0 or p > k:
+            return 0
+        if p == 0 and k >= 0:
+            return 1
+        if k <= self._N[1]:
+            return elem_sym_poly(p, k, varl1, varl2)
+        ret = 0
+        j = bisect_left(self._N, k)
+        if j < len(self._N) and k == self._N[j]:
+            ret = (-((-1) ** (self._n[j - 1]))) * q_var[j - 1] * self.elem_sym(p - self._N[j] + self._N[j - 2], self._N[j - 2], varl1, varl2)
+        ret += self.elem_sym(p, k - 1, varl1, varl2) + (varl1[k - 1] - varl2[k - p]) * self.elem_sym(p - 1, k - 1, varl1, varl2)
+        return ret
 
     # def classical_elem(self, k, coeff_var):
     #     if k <= self._N[1]:
@@ -451,6 +477,7 @@ class ParabolicQuantumDoubleSchubertAlgebraElement_basis(Basic):
     def process_coeff_dict(self, coeff_dict):
         max_len = max(len(w) for w in coeff_dict)
         parabolic_index = [*self._parabolic_index]
+        # print(f"bagels = {parabolic_index=} {type(self)=}")
         # parabolic_index += list(range(parabolic_index[-1] + 2, max_len + 1))
         if max_len > len(self._longest):
             parabolic_index = []
@@ -587,7 +614,7 @@ class ParabolicQuantumDoubleSchubertAlgebraElement_basis(Basic):
             # print(f"new longest = {longest=}")
         else:
             longest = self._longest
-        return schubpoly_from_elems(k[0], self.genset, utils.poly_ring(k[1]), elem_func=self.elem_sym(), mumu=~longest)  # yz.schubpoly_quantum(k[0], self.genset, utils.poly_ring(k[1]))
+        return schubpoly_from_elems(k[0], self.genset, utils.poly_ring(k[1]), elem_func=self.elem_sym, mumu=~longest)  # yz.schubpoly_quantum(k[0], self.genset, utils.poly_ring(k[1]))
 
     @cache
     def cached_positive_product(self, u, v, va, vb):
@@ -596,11 +623,23 @@ class ParabolicQuantumDoubleSchubertAlgebraElement_basis(Basic):
 
     @property
     def double_mul(self):
-        return yz.schubmult_q_double_fast
+        from schubmult.schub_lib.quantum_double import _vars
+
+        def do_double_mul(perm_dict, v, var2=_vars.var2, var3=_vars.var3, q_var=_vars.q_var):
+            coeff_dict = yz.schubmult_q_double_fast(perm_dict, v, var2, var3, q_var)
+            return self.process_coeff_dict(coeff_dict)
+
+        return do_double_mul
 
     @property
     def single_mul(self):
-        return py.schubmult_q_fast
+        from schubmult.schub_lib.quantum_double import _vars
+
+        def do_single_mul(perm_dict, v, q_var=_vars.q_var):
+            coeff_dict = py.schubmult_q_fast(perm_dict, v, q_var)
+            return self.process_coeff_dict(coeff_dict)
+
+        return do_single_mul
 
     @property
     def mult_poly_single(self):
@@ -662,127 +701,52 @@ def QPDSx(*args):
     return make_parabolic_quantum_basis(args)
 
 
-# is_Add = True
-# is_Mul = True
-# is_Add
-# is_AlgebraicNumber
-# is_Atom
-# is_Boolean
-# is_Derivative
-# is_Dummy
-# is_Equality
-# is_Float
-# is_Function
-# is_Indexed
-# is_Integer
-# is_MatAdd
-# is_MatMul
-# is_Matrix
-# is_Mul
-# is_Not
-# is_Number
-# is_NumberSymbol
-# is_Order
-# is_Piecewise
-# is_Point
-# is_Poly
-# is_Pow
-# is_Rational
-# is_Relational
-# is_Symbol
-# is_Vector
-# is_Wild
-# is_algebraic
-# is_algebraic_expr
-# is_antihermitian
-# is_commutative
-# is_comparable
-# is_complex
-# is_composite
-# is_constant
-# is_even
-# is_extended_negative
-# is_extended_nonnegative
-# is_extended_nonpositive
-# is_extended_nonzero
-# is_extended_positive
-# is_extended_real
-# is_finite
-# is_hermitian
-# is_hypergeometric
-# is_imaginary
-# is_infinite
-# is_integer
-# is_irrational
-# is_meromorphic
-# is_negative
-# is_noninteger
-# is_nonnegative
-# is_nonpositive
-# is_nonzero
-# is_number
-# is_odd
-# is_polar
-# is_polynomial
-# is_positive
-# is_prime
-# is_rational
-# is_rational_function
-# is_real
-# is_scalar
-# is_symbol
-# is_transcendental
-# is_zero
-# is_polynomial = True
-# is_Symbol = True
-
-
-# class SchubAdd(QuantumDoubleSchubertAlgebraElement, Add):
-#     is_Add = True
-
-#     def __new__(cls, *args, evaluate=True, _sympify=True):
-#         obj = Add.__new__(cls, *args, evaluate=evaluate, _sympify=_sympify)
-#         if evaluate:
-#             return obj.doit()
-#         return obj
-
-#     def doit(self):
-#         ret = self.args[0]
-#         for arg in self.args[1:]:
-#             if arg.is_Add or arg.is_Mul:
-#                 arg = arg.doit()
-#             ret = _do_schub_add(ret, arg)
-#         return ret
-
-#     # def _sympystr(self, printer):
-#     #     return _def_printer._print(f"SchubAdd({self.args}")
-
-
-# class SchubMul(QuantumDoubleSchubertAlgebraElement, Mul):
-#     is_Mul = True
-
-#     def __new__(cls, *args, evaluate=True, _sympify=True):
-#         if len(args) == 0:
-#             return 1
-#         # args, a, b = Mul.flatten(list(args))
-#         # if len(args) == 0:
-#         #     return 1
-#         obj = Mul.__new__(cls, *args, evaluate=evaluate, _sympify=_sympify)
-
-#         if evaluate:
-#             return obj.doit()
-#         return obj
-
-#     def doit(self):
-#         ret = self.args[0]
-#         for arg in self.args[1:]:
-#             if arg.is_Add or arg.is_Mul:
-#                 arg = arg.doit()
-#             ret = _do_schub_mul(ret, arg)
-#         return ret
-
-
-# Basic._constructor_postprocessor_mapping[DoubleSchubertAlgebraElement] = {
-#     "Mul": [get_postprocessor(Mul)],
-#     "Add": [get_postprocessor(Add)],
-# }
+class ParabolicQuantumSchubertAlgebraElement_basis(ParabolicQuantumDoubleSchubertAlgebraElement_basis):
+    def __new__(cls, genset, index_comp):
+        return ParabolicQuantumDoubleSchubertAlgebraElement_basis.__new__(cls, genset, index_comp)
+
+    def __hash__(self):
+        return hash((*self.args, utils.NoneVar))
+
+    def _from_single_dict(self, _dict):
+        return ParabolicQuantumDoubleSchubertAlgebraElement({(k, utils.NoneVar): v for k, v in _dict.items()}, self)
+
+    def __call__(self, x):
+        genset = self.genset
+        # logger.debug(f"{x=} {type(x)=}")
+        if not genset:
+            genset = self.genset
+        if isinstance(x, list) or isinstance(x, tuple):
+            perm = Permutation(x)
+            if not is_parabolic(perm, self.parabolic_index):
+                raise ValueError(f"Permutation must be parabolic: {perm} is not")
+            elem = self._from_dict({(perm, utils.NoneVar): 1})
+        elif isinstance(x, Permutation):
+            if not is_parabolic(x, self.parabolic_index):
+                raise ValueError(f"Permutation must be parabolic: {x} is not")
+            elem = self._from_dict({(x, utils.NoneVar): 1})
+        elif isinstance(x, ParabolicQuantumDoubleSchubertAlgebraElement):
+            return x
+        else:
+            dct = self.classical_basis(x, utils.NoneVar)
+            elem = 0
+            if not isinstance(dct, spr.BasisSchubertAlgebraElement):
+                return dct
+            try:
+                for k, v in dct.coeff_dict.items():
+                    if elem == 0:
+                        elem = v * self.classical_in_basis(k)
+                    else:
+                        elem += v * self.classical_in_basis(k)
+            except ValueError:
+                raise ValueError(f"Could not convert {x=} to quantum parabolic")
+        return elem
+
+
+def make_single_parabolic_quantum_basis(index_comp):
+    return ParabolicQuantumSchubertAlgebraElement_basis(GeneratingSet("x"), index_comp)
+
+
+@cache
+def QPSx(*args):
+    return make_single_parabolic_quantum_basis(args)

schubmult/rings/_schubert_polynomial_ring.py

@@ -17,7 +17,7 @@ import schubmult.schub_lib.double as yz
 import schubmult.schub_lib.schub_lib as schub_lib
 import schubmult.schub_lib.single as py
 from schubmult.perm_lib import Permutation, inv
-from schubmult.poly_lib.poly_lib import elem_sym_poly, xreplace_genvars
+from schubmult.poly_lib.poly_lib import complete_sym_poly, elem_sym_poly, xreplace_genvars
 from schubmult.poly_lib.schub_poly import schubpoly_classical_from_elems, schubpoly_from_elems
 from schubmult.poly_lib.variables import CustomGeneratingSet, GeneratingSet, GeneratingSet_base, MaskedGeneratingSet
 from schubmult.utils.logging import get_logger
@@ -157,7 +157,6 @@ class BasisSchubertAlgebraElement(Expr):
             obj.precedence = 1000
         else:
             obj.precedence = 40
-        # obj.prune()
         obj._basis = basis
         return obj
 
@@ -198,22 +197,35 @@ class BasisSchubertAlgebraElement(Expr):
             else:
                 dict2 = self.basis.mult_poly_double({k[0]: v}, poly, self.genset, utils.poly_ring(k[1]))
             res_dict2 = add_perm_dict(res_dict2, {(k2, k[1]): v for k2, v in dict2.items()})
-        logger.debug(f"{res_dict2=}")
+        # logger.debug(f"{res_dict2=}")
         return self.basis._from_dict(res_dict2)
 
-    # def _cached_sympystr(self, printer):
-    #     return printer.doprint(
-    #         sympy.Add(
-    #             *[
-    #                 (self.coeff_dict[k] if k[0] == Permutation([]) else sympy.Mul(self.coeff_dict[k], self.basis.single_element_class(k, self.basis)))
-    #                 for k in sorted(self.coeff_dict.keys(), key=lambda bob: (inv(bob[0]), str(bob[1]), *bob[0]))
-    #             ],
-    #         ),
-    #     )
+    def in_SEM_basis(self):
+        result = S.Zero
+        for k, v in self.coeff_dict.items():
+            result += v * schubpoly_from_elems(k[0], self.genset, utils.poly_ring(k[1]), elem_func=self.basis.symbol_elem_func)
+        return result
+
+    def in_classical_EM_basis(self):
+        result = S.Zero
+        for k, v in self.coeff_dict.items():
+            result += v * schubpoly_classical_from_elems(k[0], self.genset, utils.poly_ring(k[1]), elem_func=self.basis.symbol_elem_func)
+        return result
 
     def _sympystr(self, printer):
+        if printer.order in ("old", "none"):  # needed to avoid infinite recursion
+            return printer._print_Add(self, order="lex")
+        return printer._print_Add(self)
+
+    def _pretty(self, printer):
+        if printer.order in ("old", "none"):  # needed to avoid infinite recursion
+            return printer._print_Add(self, order="lex")
+        return printer._print_Add(self)
+
+    def _latex(self, printer):
+        if printer.order in ("old", "none"):  # needed to avoid infinite recursion
+            return printer._print_Add(self, order="lex")
         return printer._print_Add(self)
-        # return self._cached_sympystr(printer)
 
     def as_terms(self):
         if len(self.coeff_dict.keys()) == 0:
@@ -577,27 +589,14 @@ class DoubleSchubertAlgebraElement(BasisSchubertAlgebraElement):
     #         return self.doit().expand()
     #     return expand(Add(*[v * schubpoly(k[0], self.genset, utils.poly_ring(k[1])) for k, v in self.coeff_dict.items()]))
 
-    def in_SEM_basis(self):
-        result = S.Zero
-        for k, v in self.coeff_dict.items():
-            result += v * schubpoly_from_elems(k[0], self.genset, utils.poly_ring(k[1]), elem_func=self.basis.symbol_elem_func)
-        # print(f"{result=}")
-        # gens = []
-        # for k in range(1, 10):
-        #     gens += [sympy.Symbol(f"e_{p}_{k}") for p in range(1,k+1)]
-        # #print(f"{gens=}")
-        # ply = sympy.poly(sympy.sympify(expand(result)), *gens)
-        # floss = 0
-        # for m, c in ply.as_dict().items():
-        #     floss += c * sympy.prod([gens[i]**m[i] for i in range(len(m))])
-        # return floss
-        return result
-
     @cached_property
     def max_gens(self):
         return max([max(k[0].descents()) for k in self.coeff_dict.keys()])
 
 
+_pretty_schub_char = "𝔖"  # noqa: RUF001
+
+
 # Atomic Schubert polynomial
 class DSchubPoly(DoubleSchubertAlgebraElement):
     is_Atom = True
@@ -641,6 +640,22 @@ class DSchubPoly(DoubleSchubertAlgebraElement):
             return printer.doprint(f"S{self.genset.label}({printer.doprint(self._key[0])})")
         return printer.doprint(f"DS{self.genset.label}({printer.doprint(self._key[0])}, {_varstr(self._key[1])})")
 
+    def _pretty(self, printer):
+        if self._key[0] == Permutation([]):
+            return printer._print(1)
+        subscript = printer._print(int("".join([str(i) for i in self._key[0]])))
+        if self._key[1] == 0 or self._key[1] == utils.NoneVar:
+            return printer._print_Function(sympy.Function(f"{_pretty_schub_char}_{subscript}")(sympy.Symbol(self.genset.label)))
+        return printer._print_Function(sympy.Function(f"{_pretty_schub_char}_{subscript}")(sympy.Symbol(f"{self.genset.label}; {self._key[1]}")))
+
+    def _latex(self, printer):
+        if self._key[0] == Permutation([]):
+            return printer._print(1)
+        subscript = printer._print(self._key[0])
+        if self._key[1] == 0 or self._key[1] == utils.NoneVar:
+            return printer._print_Function(sympy.Function("\\mathfrak{S}" + f"_{'{' + subscript + '}'}")(sympy.Symbol(self.genset.label)))
+        return printer._print_Function(sympy.Function("\\mathfrak{S}" + f"_{'{' + subscript + '}'}")(sympy.Symbol(f"{self.genset.label}; {self._key[1]}")))
+
 
 # def elem_func(p, k, vx, vy):
 #     return DSx(elem_func_q(p, k, vx, vy), "y")
@@ -655,15 +670,22 @@ class DoubleSchubertAlgebraElement_basis(Basic):
 
     @property
     def symbol_elem_func(self):
-        def elem_func(p, k, varl1, varl2):
+        def elem_func(p, k, varl1, varl2):  # noqa: ARG001
             if p == 0 and k >= 0:
                 return 1
             if p < 0 or p > k:
                 return 0
-            return sympy.Add(*[(Symbol(f"e_{p - i}_{k}") if p - i > 0 else 1) * elem_sym_poly(i, k + 1 - p, [-v for v in varl2], [0 for a in varl1]) for i in range(p + 1)])
+            return sympy.Add(*[(Symbol(f"e_{p - i}_{k}") if p - i > 0 else 1) * complete_sym_poly(i, k + 1 - p, [-v for v in varl2]) for i in range(p + 1)])
 
         return elem_func
 
+    def elem_sym_subs(self, kk):
+        elems = []
+        for k in range(1, kk + 1):
+            for p in range(1, k + 1):
+                elems += [(sympy.Symbol(f"e_{p}_{k}"), elem_sym_poly(p, k, self.genset[1:], utils.poly_ring(0)))]
+        return dict(elems)
+
     # def in_SEM_basis(self, elem):
     #     return
 
@@ -754,7 +776,7 @@ class DoubleSchubertAlgebraElement_basis(Basic):
                     xsm,
                     ysm - p2,
                 )
-            logger.debug(f"{res=}")
+            # logger.debug(f"{res=}")
             return res
 
         return elem_func
@@ -830,7 +852,7 @@ class DoubleSchubertAlgebraElement_basis(Basic):
                 # print("splinterfish")
                 result = yz.mult_poly_double({Permutation([]): 1}, x, genset, utils.poly_ring(cv))
             elem = self._from_dict({(k, cv): v for k, v in result.items()})
-            logger.debug(f"Returning {elem=}")
+            # logger.debug(f"Returning {elem=}")
         return elem
 
 
@@ -962,6 +984,9 @@ class SchubertAlgebraElement_basis(DoubleSchubertAlgebraElement_basis):
     def __new__(cls, genset):
         return DoubleSchubertAlgebraElement_basis.__new__(cls, genset)
 
+    def __hash__(self):
+        return hash((*self.args, utils.NoneVar))
+
     def _from_single_dict(self, _dict):
         return DoubleSchubertAlgebraElement({(k, utils.NoneVar): v for k, v in _dict.items()}, self)
 

schubmult/schub_lib/quantum_double.py

@@ -94,9 +94,9 @@ def single_variable(coeff_dict, varnum, var2=_vars.var2, q_var=_vars.q_var):
 def mult_poly_q_double(coeff_dict, poly, var_x=_vars.var1, var_y=_vars.var2, q_var=_vars.q_var):
     if not isinstance(var_x, GeneratingSet_base):
         var_x = CustomGeneratingSet(var_x)
-    logger.debug(f"{poly=} {list(var_x)=}")
+    # logger.debug(f"{poly=} {list(var_x)=}")
     if var_x.index(poly) != -1:
-        logger.debug(f"yay {var_x.index(poly)=}")
+        # logger.debug(f"yay {var_x.index(poly)=}")
         return single_variable(coeff_dict, var_x.index(poly), var_y, q_var)
     if isinstance(poly, Mul):
         ret = coeff_dict

schubmult/utils/argparse.py

@@ -3,7 +3,7 @@ from argparse import SUPPRESS, ArgumentParser, RawDescriptionHelpFormatter
 
 import sympy
 
-# from sympy import Indexed, init_printing
+# from sympy import init_printing
 from schubmult.utils.logging import init_logging
 
 # Indexed._sympystr = lambda x, p: f"{p.doprint(x.args[0])}_{x.args[1]}"
@@ -215,17 +215,17 @@ def schub_argparse(prog_name, description, argv, quantum=False, yz=False):
 
     if args.disp_mode == "latex":
         formatter = (  # noqa: E731
-            lambda bob, width=None: sympy.latex(_sympy(bob)).replace("\\left", "").replace("\\right", "")
+            lambda bob, width=None: sympy.latex(_sympy(bob), order="old").replace("\\left", "").replace("\\right", "")
         )
     elif args.disp_mode == "pretty":
         # pretty we need to keep centered
         formatter = (  # noqa: E731
-            lambda bob, width=None: sympy.pretty(_sympy(bob))
+            lambda bob, width=None: sympy.pretty(_sympy(bob), order="old")
             if width is None
             else sympy.pretty(_sympy(bob), order="rev-lex" if args.same else "none", use_unicode=False).replace("\n", "\n" + " ".join(["" for i in range(width)]))
         )
     elif args.disp_mode == "basic":
-        formatter = lambda bob, width=None: sympy.sstr(_sympy(bob))  # , order="rev-lex" if args.same else "none")  # noqa: E731
+        formatter = lambda bob, width=None: sympy.sstr(_sympy(bob), order="old")  # , order="rev-lex" if args.same else "none")  # noqa: E731
     elif args.disp_mode == "raw":
         formatter = None
     init_logging(debug=args.debug)

{schubmult-3.0.0.dist-info → schubmult-3.0.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: schubmult
-Version: 3.0.0
+Version: 3.0.1
 Summary: Package for algebraic computation with single, double, and quantum Schubert polynomials
 Author-email: Matt Samuel <schubmult@gmail.com>
 Maintainer-email: Matt Samuel <schubmult@gmail.com>

{schubmult-3.0.0.dist-info → schubmult-3.0.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-schubmult/__init__.py,sha256=XOa382I_9HvYUwbuz8dEAoDptLnzbLzZcL5A2TiCIos,2363
-schubmult/perm_lib.py,sha256=h_phdUoIMZn66C4CIWSqalHWC0t7ofgPswDrKzd2Sho,9509
+schubmult/__init__.py,sha256=SqufaRbFLZue-oOMqDUpEVJagcTJoAi5XY5Az_YC1bw,2385
+schubmult/perm_lib.py,sha256=2yUV3nquNnGPLpAJJBCg7SFF-y-eP0zcCxC9hy6keDg,10431
 schubmult/poly_lib/__init__.py,sha256=DUA70oCWv64lqhezrpKgA6813Dp5LTM1bkMrpOoqjTU,674
-schubmult/poly_lib/poly_lib.py,sha256=ymFvBNu7rxDMvaAo2_ts4ikixzykAilUbbyJZbTuYB8,6946
+schubmult/poly_lib/poly_lib.py,sha256=ZgZWY9Q2TBdk5lH2Jtg7LJO-WETtVcYfr8aSpaEKdMU,7839
 schubmult/poly_lib/schub_poly.py,sha256=_GXApXSbmlF0neSZOY9fCFXxSmYJEoHv_PvJJzIhy5E,4586
 schubmult/poly_lib/variables.py,sha256=cnR9Kvzbh7LA0Mvi292h2eMW7d3s2GU9DKvP3M44HNE,6005
-schubmult/rings/__init__.py,sha256=vRaxEBgeT7OtvOOzOTvZffHBRdopVkouTVyklAOg8l0,612
-schubmult/rings/_quantum_schubert_polynomial_ring.py,sha256=Gy11WD4v9V5lcYhYsoU4lf-wPS-UZ3kyfyxjKLt7X4I,28031
-schubmult/rings/_schubert_polynomial_ring.py,sha256=D0Uo8J2BJGZrDWaXHbrC02FAbuYtssVofNkWoMMCYdU,37969
+schubmult/rings/__init__.py,sha256=Xaf8JB64C0tjlb_F8WQqHFGp3MM5LteFgkxNETImMiU,630
+schubmult/rings/_quantum_schubert_polynomial_ring.py,sha256=H71XoK96-Bfel-uel5BPQLIL_Kazjjej3StgXeDBAd0,29951
+schubmult/rings/_schubert_polynomial_ring.py,sha256=mokenMrZJq0nrzV8xZ23xrIQJTYpFdbUCCct1vpIbCE,39338
 schubmult/rings/_tensor_schub_ring.py,sha256=-ahCinjsAyK6EvfPD8T4nB4KJ8syISEbtYL-n34q16I,3952
 schubmult/rings/_utils.py,sha256=hCB9sMJfgINLvqbJbpGd5bnGQL3sb6G1nr1Dr5O-qwM,1787
 schubmult/sage/__init__.py,sha256=bgRIEllThsrH0kYJnEAR_cirTGGfdPojOUajbZjJhq4,906
@@ -16,7 +16,7 @@ schubmult/sage/_indexing.py,sha256=L6ShyDI7ceMSga8jel5mzAWBxfmsXC9uJZYpZ_WrnOI,1
 schubmult/schub_lib/__init__.py,sha256=kFtT2ghMrgFACzJSraeJYGcvGlb3uXt_GJIl36tmOw8,1118
 schubmult/schub_lib/double.py,sha256=x7l84DJ4e0VW90z7GbdRNpF7FUcKGPXhXWOxBLXBLh0,51663
 schubmult/schub_lib/quantum.py,sha256=RcjpAtyxVndo-kR-H31gjtmjaLNq2PWSglvw6LnKOR0,9998
-schubmult/schub_lib/quantum_double.py,sha256=Up9wSqZ6A5u5Ze3sznp3vEA8uktepVSpSdVjw5X_RZE,36770
+schubmult/schub_lib/quantum_double.py,sha256=Ex4Azr-aPGLajFcuOFFNCBKYrDt7fcp7lc_B9SOhGbE,36774
 schubmult/schub_lib/schub_lib.py,sha256=Sca_PAOD0ABEyixpgYpFxPxfCPZnKchFGeKUZIstIyc,22815
 schubmult/schub_lib/single.py,sha256=3ZJzC9dSFc6Ux_DcuSKekwK7D9ZyrCd5OUEiIKW8LZk,5210
 schubmult/schub_lib/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -28,14 +28,14 @@ schubmult/scripts/schubmult_py.py,sha256=ARQn4Ucl5n8dz_q77gjkrazVSDjUMQHkx5EK7Sx
 schubmult/scripts/schubmult_q.py,sha256=ntzcVmFjRbXGKTddkhdNVpxcMTTtK4CeOI4BeIVjePQ,3287
 schubmult/scripts/schubmult_q_double.py,sha256=SANQEvlA5XJUWUh8sd_ObwMOEmct0GLSMbjDAvUTOB4,6086
 schubmult/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-schubmult/utils/argparse.py,sha256=35jg_AtQuue9HuJB7RN_D7YwMOzrcJkrriNAHKiNJh8,7175
+schubmult/utils/argparse.py,sha256=ZY85ZR-h8TOUQuzTVlvRfh07QQ032B3c649rLYZHrp8,7205
 schubmult/utils/logging.py,sha256=h-CgHSl7kPscs9VKp0WjJ4fcrtPplnJYDyrL2klPJJ4,503
 schubmult/utils/parsing.py,sha256=ygkkLqZ1KsNQBPeiF6gkEJYMwjmkqkwfGuIP0Wtawnk,599
 schubmult/utils/perm_utils.py,sha256=mf5VOwLREn_UQWMa67lOsmmwHMJClt_rjsVPIE2yE9w,2716
 schubmult/utils/test_utils.py,sha256=vEIuAkb-mFEs1gow9E76JrRbcEDvxvsTDzp4pPUoT5w,1860
-schubmult-3.0.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-schubmult-3.0.0.dist-info/METADATA,sha256=f9ofBquNwvAKOQ8zCIN1-y-Hj8EErdBgKAGBnoF7Gfg,77074
-schubmult-3.0.0.dist-info/WHEEL,sha256=lTU6B6eIfYoiQJTZNc-fyaR6BpL6ehTzU3xGYxn2n8k,91
-schubmult-3.0.0.dist-info/entry_points.txt,sha256=9iaFSlTd5xZf52635CKaBqmgJTY_NZLkF6AMnL_T84c,240
-schubmult-3.0.0.dist-info/top_level.txt,sha256=IkujyjRu8lbpoSTdPE8DmMJ9sbyXHpo9L0RHL7nOzM0,10
-schubmult-3.0.0.dist-info/RECORD,,
+schubmult-3.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+schubmult-3.0.1.dist-info/METADATA,sha256=ZOHi7RDDLffv5Xnq9FUQfua55DxflmWoNB3O6CsjVPk,77074
+schubmult-3.0.1.dist-info/WHEEL,sha256=pxyMxgL8-pra_rKaQ4drOZAegBVuX-G_4nRHjjgWbmo,91
+schubmult-3.0.1.dist-info/entry_points.txt,sha256=9iaFSlTd5xZf52635CKaBqmgJTY_NZLkF6AMnL_T84c,240
+schubmult-3.0.1.dist-info/top_level.txt,sha256=IkujyjRu8lbpoSTdPE8DmMJ9sbyXHpo9L0RHL7nOzM0,10
+schubmult-3.0.1.dist-info/RECORD,,

{schubmult-3.0.0.dist-info → schubmult-3.0.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (78.1.1)
+Generator: setuptools (79.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any