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

schubmult/poly_lib/__init__.py

@@ -0,0 +1,31 @@
+# from .poly_lib import (
+#     call_zvars,
+#     efficient_subs,
+#     elem_sym_func,
+#     elem_sym_func_q,
+#     elem_sym_poly,
+#     elem_sym_poly_q,
+#     expand,
+#     q_vector,
+#     xreplace_genvars,
+# )
+# from .schub_poly import div_diff, perm_act, schubpoly, skew_div_diff
+# from .variables import GeneratingSet, base_index
+
+# __all__ = [
+#     "GeneratingSet",
+#     "base_index",
+#     "call_zvars",
+#     "div_diff",
+#     "efficient_subs",
+#     "elem_sym_func",
+#     "elem_sym_func_q",
+#     "elem_sym_poly",
+#     "elem_sym_poly_q",
+#     "expand",
+#     "perm_act",
+#     "q_vector",
+#     "schubpoly",
+#     "skew_div_diff",
+#     "xreplace_genvars",
+# ]

schubmult/poly_lib/poly_lib.py

@@ -0,0 +1,244 @@
+from functools import cache, cached_property
+
+import symengine
+from symengine import Mul, Pow, sympify
+
+import schubmult.perm_lib as pl
+import schubmult.poly_lib.variables as vv
+
+# import vv.GeneratingSet, vv.base_index
+
+
+# Indexed._sympystr = lambda x, p: f"{p.doprint(x.args[0])}_{x.args[1]}"
+def expand(val):
+    return symengine.expand(val)
+
+
+class _gvars:
+    @cached_property
+    def n(self):
+        return 100
+
+    # @cached_property
+    # def fvar(self):
+    #     return 100
+
+    @cached_property
+    def var1(self):
+        return vv.GeneratingSet("x")
+
+    @cached_property
+    def var2(self):
+        return vv.GeneratingSet("y")
+
+    @cached_property
+    def var3(self):
+        return vv.GeneratingSet("z")
+
+    @cached_property
+    def var_r(self):
+        return vv.GeneratingSet("r")
+
+    @cached_property
+    def var_g1(self):
+        return vv.GeneratingSet("y")
+
+    @cached_property
+    def var_g2(self):
+        return vv.GeneratingSet("z")
+
+    @cached_property
+    def q_var(self):
+        return vv.GeneratingSet("q")
+
+
+zero = sympify(0)
+
+_vars = _gvars()
+
+def act(w, poly, genset):
+    if not isinstance(w, pl.Permutation):
+        w = pl.Permutation(w)
+    subs_dict = {}
+    if not isinstance(genset, vv.GeneratingSet_base):
+        genset = vv.CustomGeneratingSet(genset)
+    for s in poly.free_symbols:
+        if genset.index(s) != -1:
+            subs_dict[s] = genset[w(genset.index(s))]
+    return efficient_subs(poly, subs_dict)
+
+def elem_sym_func(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2):
+    newk = k - udiff
+    if newk < vdiff:
+        return zero
+    if newk == vdiff:
+        return one
+    yvars = []
+    for j in range(min(len(u1), k)):
+        if u1[j] == u2[j]:
+            yvars += [varl1[u2[j]]]
+    for j in range(len(u1), min(k, len(u2))):
+        if u2[j] == j + 1:
+            yvars += [varl1[u2[j]]]
+    for j in range(len(u2), k):
+        yvars += [varl1[j + 1]]
+    zvars = [varl2[i] for i in call_zvars(v1, v2, k, i)]
+    return elem_sym_poly(newk - vdiff, newk, yvars, zvars)
+
+
+# def elem_sym_func_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2):
+#     newk = k - udiff
+#     if newk < vdiff:
+#         return zero
+#     if newk == vdiff:
+#         return one
+#     yvars = []
+#     mlen = max(len(u1), len(u2))
+#     u1 = [*u1] + [a + 1 for a in range(len(u1), mlen)]
+#     u2 = [*u2] + [a + 1 for a in range(len(u2), mlen)]
+#     for j in range(min(len(u1), k)):
+#         if u1[j] == u2[j]:
+#             yvars += [varl1[u2[j]]]
+#     for j in range(len(u1), min(k, len(u2))):
+#         if u2[j] == j + 1:
+#             yvars += [varl1[u2[j]]]
+#     for j in range(len(u2), k):
+#         yvars += [varl1[j + 1]]
+#     zvars = [varl2[a] for a in call_zvars(v1, v2, k, i)]
+#     return elem_sym_poly(newk - vdiff, newk, yvars, zvars)
+
+
+def elem_sym_func_q(k, i, u1, u2, v1, v2, udiff, vdiff, varl1, varl2):
+    newk = k - udiff
+    if newk < vdiff:
+        return zero
+    if newk == vdiff:
+        return one
+    yvars = []
+    # print(f"{u1=} {u2=} {max(len(u1),len(u2))=}")
+    # print(f"{u1=} {u2=} {max(len(u1),len(u2))=}")
+    # print(f"{k=}")
+    # u1 = [*u1] + [a + 1 for a in range(len(u1), mlen)]
+    # u2 = [*u2] + [a + 1 for a in range(len(u2), mlen)]
+    for j in range(k):
+        if u1[j] == u2[j]:
+            yvars += [varl1[u2[j]]]
+    # print(f"{yvars=}")
+    # for j in range(len(u1), min(k, len(u2))):
+    #     if u2[j] == j + 1:
+    #         yvars += [varl1[u2[j]]]
+    # for j in range(len(u2), k):
+    #     yvars += [varl1[j + 1]]
+    zvars = [varl2[a] for a in call_zvars(v1, v2, k, i)]
+    return elem_sym_poly(newk - vdiff, newk, yvars, zvars)
+
+
+one = sympify(1)
+
+
+def elem_sym_poly_q(p, k, varl1, varl2, q_var=_vars.q_var):
+    if p == 0 and k >= 0:
+        return one
+    if p < 0 or p > k:
+        return zero
+    return (
+        (varl1[k - 1] - varl2[k - p]) * elem_sym_poly_q(p - 1, k - 1, varl1, varl2, q_var)
+        + elem_sym_poly_q(p, k - 1, varl1, varl2, q_var)
+        + q_var[k - 1] * elem_sym_poly_q(p - 2, k - 2, varl1, varl2, q_var)
+    )
+
+
+def elem_sym_poly(p, k, varl1, varl2, xstart=0, ystart=0):
+    if p > k:
+        return zero
+    if p == 0:
+        return one
+    if p == 1:
+        res = varl1[xstart] - varl2[ystart]
+        for i in range(1, k):
+            res += varl1[xstart + i] - varl2[ystart + i]
+        return res
+    if p == k:
+        res = (varl1[xstart] - varl2[ystart]) * (varl1[xstart + 1] - varl2[ystart])
+        for i in range(2, k):
+            res *= varl1[i + xstart] - varl2[ystart]
+        return res
+    mid = k // 2
+    xsm = xstart + mid
+    ysm = ystart + mid
+    kmm = k - mid
+    res = elem_sym_poly(p, mid, varl1, varl2, xstart, ystart) + elem_sym_poly(
+        p,
+        kmm,
+        varl1,
+        varl2,
+        xsm,
+        ysm,
+    )
+    for p2 in range(max(1, p - kmm), min(p, mid + 1)):
+        res += elem_sym_poly(p2, mid, varl1, varl2, xstart, ystart) * elem_sym_poly(
+            p - p2,
+            kmm,
+            varl1,
+            varl2,
+            xsm,
+            ysm - p2,
+        )
+    return res
+
+
+# def call_zvars(v1, v2, k, i):
+#     v3 = [*v2, *list(range(len(v2) + 1, i + 1))]
+#     return [v3[i - 1]] + [v3[j] for j in range(len(v1), len(v3)) if v3[j] != j + 1 and j != i - 1] + [v3[j] for j in range(len(v1)) if v1[j] != v3[j] and j != i - 1]
+
+
+@cache
+def call_zvars(v1, v2, k, i):  # noqa: ARG001
+    return [v2[i - 1]] + [v2[j] for j in range(len(v1), len(v2) + max(0, i - len(v2))) if v2[j] != j + 1 and j != i - 1] + [v2[j] for j in range(len(v1)) if v1[j] != v2[j] and j != i - 1]
+
+
+def efficient_subs(expr, subs_dict):
+    subs_dict_new = {}
+    expr = sympify(expr)
+    for s in expr.free_symbols:
+        if s in subs_dict:
+            subs_dict_new[s] = subs_dict[s]
+    return expr.subs(subs_dict_new)
+
+
+def q_vector(q_exp, q_var=_vars.q_var):
+    # qvar_list = q_var.tolist()
+    ret = []
+
+    if q_exp == 1:
+        return ret
+    if q_var.index(q_exp) != -1:
+        i = q_var.index(q_exp)
+        return [0 for j in range(i - 1)] + [1]
+    if isinstance(q_exp, Pow):
+        qv = q_exp.args[0]
+        expon = int(q_exp.args[1])
+        i = q_var.index(qv)
+        if i == -1:
+            raise IndexError
+        return [0 for j in range(i - 1)] + [expon]
+    if isinstance(q_exp, Mul):
+        for a in q_exp.args:
+            v1 = q_vector(a)
+            v1 += [0 for i in range(len(v1), len(ret))]
+            ret += [0 for i in range(len(ret), len(v1))]
+            ret = [ret[i] + v1[i] for i in range(len(ret))]
+        return ret
+
+    return None
+
+
+def xreplace_genvars(poly, vars1, vars2):
+    subs_dict = {}
+    for s in sympify(poly).free_symbols:
+        if _vars.var_g1.index(s) != -1:
+            subs_dict[s] = vars1[_vars.var_g1.index(s)]
+        elif _vars.var_g2.index(s) != -1:
+            subs_dict[s] = vars2[_vars.var_g2.index(s)]
+    return sympify(poly).xreplace(subs_dict)
+    # print(f"{poly2=} {poly2.free_symbols=}")

schubmult/poly_lib/schub_poly.py

@@ -0,0 +1,148 @@
+import sympy
+
+import schubmult.perm_lib as pl
+import schubmult.schub_lib.schub_lib as schub_lib
+from schubmult.poly_lib.poly_lib import call_zvars
+from schubmult.poly_lib.variables import GeneratingSet
+
+
+def perm_act(val, i, var2=None):
+    subsdict = {var2[i]: var2[i + 1], var2[i + 1]: var2[i]}
+    return sympy.sympify(val).subs(subsdict)
+
+
+def div_diff(i, poly, var2=None):
+    return sympy.sympify(
+        sympy.div(sympy.sympify(poly - perm_act(poly, i)), sympy.sympify(var2[i] - var2[i + 1]))[0],
+    )
+
+
+def elem_func_func(k, i, v1, v2, vdiff, varl1, varl2, elem_func):
+    newk = k
+    if newk < vdiff:
+        return 0
+    if newk == vdiff:
+        return 1
+    zvars = [varl2[i] for i in call_zvars(v1, v2, k, i)]
+    return elem_func(newk - vdiff, newk, varl1[1:], zvars)
+
+
+def schubpoly_from_elems(v, var_x=None, var_y=None, elem_func=None, mumu=None):
+    if mumu:
+        # print(pl.code(mumu))
+        th = pl.code(mumu)
+        # print(f"{th=}")
+        mu = mumu
+    else:
+        th = pl.strict_theta(~pl.Permutation(v))
+        mu = pl.uncode(th)
+    vmu = pl.Permutation(v) * mu  # permtrim(mulperm([*v], mu))
+    if len(th) == 0:
+        return elem_func(0, 0, var_x, var_y)
+    while len(th) > 0 and th[-1] == 0:
+        th.pop()
+    vpathdicts = schub_lib.compute_vpathdicts(th, vmu)
+    vpathsums = {pl.Permutation([1, 2]): elem_func(0, 0, var_x, var_y)}
+    for index in range(len(th)):
+        mx_th = 0
+        newpathsums = {}
+        for vp in vpathdicts[index]:
+            for v2, vdiff, s in vpathdicts[index][vp]:
+                mx_th = max(mx_th, th[index] - vdiff)
+        for v in vpathdicts[index]:
+            sumval = vpathsums.get(v, 0)
+            if sumval == 0:
+                continue
+            for v2, vdiff, s in vpathdicts[index][v]:
+                newpathsums[v2] = newpathsums.get(
+                    v2,
+                    0,
+                ) + s * sumval * elem_func_func(
+                    th[index],
+                    index + 1,
+                    v,
+                    v2,
+                    vdiff,
+                    var_x,
+                    var_y,
+                    elem_func=elem_func,
+                )
+        vpathsums = newpathsums
+    return vpathsums.get(vmu, 0)
+
+def schubpoly_classical_from_elems(v, var_x=None, var_y=None, elem_func=None):
+    th = pl.theta(~pl.Permutation(v))
+    mu = pl.uncode(th)
+    vmu = pl.Permutation(v) * mu  # permtrim(mulperm([*v], mu))
+    if len(th) == 0:
+        return elem_func(0, 0, var_x, var_y)
+    while len(th) > 0 and th[-1] == 0:
+        th.pop()
+    vpathdicts = schub_lib.compute_vpathdicts(th, vmu)
+    vpathsums = {pl.Permutation([1, 2]): elem_func(0, 0, var_x, var_y)}
+    for index in range(len(th)):
+        mx_th = 0
+        newpathsums = {}
+        for vp in vpathdicts[index]:
+            for v2, vdiff, s in vpathdicts[index][vp]:
+                mx_th = max(mx_th, th[index] - vdiff)
+        for v in vpathdicts[index]:
+            sumval = vpathsums.get(v, 0)
+            if sumval == 0:
+                continue
+            for v2, vdiff, s in vpathdicts[index][v]:
+                newpathsums[v2] = newpathsums.get(
+                    v2,
+                    0,
+                ) + s * sumval * elem_func_func(
+                    th[index],
+                    index + 1,
+                    v,
+                    v2,
+                    vdiff,
+                    var_x,
+                    var_y,
+                    elem_func=elem_func,
+                )
+        vpathsums = newpathsums
+    return vpathsums.get(vmu, 0)
+
+
+def schubpoly(v, var2=GeneratingSet("y"), var3=GeneratingSet("z"), start_var=1):
+    n = 0
+    for j in range(len(v) - 2, -1, -1):
+        if v[j] > v[j + 1]:
+            n = j + 1
+            break
+    if n == 0:
+        return 1
+    lst = schub_lib.pull_out_var(n, v)
+    ret = 0
+    for pw, vp in lst:
+        tomul = 1
+        for p in pw:
+            tomul *= var2[start_var + n - 1] - var3[p]
+        ret += tomul * schubpoly(vp, var2, var3, start_var)
+    return ret
+
+
+def skew_div_diff(u, w, poly):
+    d = -1
+    for i in range(len(w) - 1):
+        if w[i] > w[i + 1]:
+            d = i
+            break
+    d2 = -1
+    for i in range(len(u) - 1):
+        if u[i] > u[i + 1]:
+            d2 = i
+            break
+    if d == -1:
+        if d2 == -1:
+            return poly
+        return 0
+    w2 = w.swap(d, d + 1)
+    if d < len(u) - 1 and u[d] > u[d + 1]:
+        u2 = u.swap(d, d + 1)
+        return skew_div_diff(u2, w2, perm_act(poly, d + 1))
+    return skew_div_diff(u, w2, div_diff(d + 1, poly))

schubmult/poly_lib/variables.py

@@ -0,0 +1,204 @@
+# class generators with base
+# symbols cls argument!
+
+import re
+from bisect import bisect_left
+from functools import cache
+from typing import ClassVar
+
+from symengine import SympifyError, symbols, sympify
+from sympy import Basic, Tuple
+from sympy.core.symbol import Str
+
+from schubmult.utils.logging import get_logger
+
+logger = get_logger(__name__)
+
+
+class GeneratingSet_base(Basic):
+    def __new__(cls, *args):
+        return Basic.__new__(cls, *args)
+
+    def __getitem__(self, i):
+        return NotImplemented
+
+    def __len__(self):
+        return NotImplemented
+
+
+# variable registry
+# TODO: ensure sympifies
+# TODO: masked generating set
+class GeneratingSet(GeneratingSet_base):
+    def __new__(cls, name):
+        return GeneratingSet.__xnew_cached__(cls, name)
+
+    _registry: ClassVar = {}
+
+    _index_pattern = re.compile("^([^_]+)_([0-9]+)$")
+    _sage_index_pattern = re.compile("^([^0-9]+)([0-9]+)$")
+
+    # is_Atom = True
+    # TODO: masked generating set
+    @staticmethod
+    @cache
+    def __xnew_cached__(_class, name):
+        return GeneratingSet.__xnew__(_class, Str(str(name)))
+
+    @staticmethod
+    def __xnew__(_class, name):
+        obj = GeneratingSet_base.__new__(_class, name)
+        obj._symbols_arr = tuple([symbols(f"{name}_{i}") for i in range(100)])
+        obj._index_lookup = {obj._symbols_arr[i]: i for i in range(len(obj._symbols_arr))}
+        return obj
+
+    def __call__(self, index):
+        """1-indexed"""
+        return self[index - 1]
+
+    @property
+    def label(self):
+        return str(self.args[0])
+
+    # index of v in the genset
+    def index(self, v):
+        try:
+            return self._index_lookup.get(v, self._index_lookup.get(sympify(v), -1))
+        except SympifyError:
+            return -1
+
+    def __repr__(self):
+        return f"GeneratingSet('{self.label}')"
+
+    def __str__(self):
+        return self.name
+
+    def _latex(self, printer):
+        return printer.doprint(self.label)
+
+    def _sympystr(self, printer):
+        return printer.doprint(self.label)
+
+    def __getitem__(self, i):
+        return self._symbols_arr[i]
+
+    def __len__(self):
+        return len(self._symbols_arr)
+
+    def __hash__(self):
+        return hash(self.label)
+
+    def __iter__(self):
+        yield from [self[i] for i in range(len(self))]
+
+    def __eq__(self, other):
+        return isinstance(other, GeneratingSet) and self.label == other.label
+
+
+class MaskedGeneratingSet(GeneratingSet_base):
+    def __new__(cls, gset, index_mask):
+        return MaskedGeneratingSet.__xnew_cached__(cls, gset, tuple(sorted(index_mask)))
+
+    @staticmethod
+    @cache
+    def __xnew_cached__(_class, gset, index_mask):
+        return MaskedGeneratingSet.__xnew__(_class, gset, index_mask)
+
+    @staticmethod
+    def __xnew__(_class, gset, index_mask):
+        obj = GeneratingSet_base.__new__(_class, gset, Tuple(*index_mask))
+        # obj._symbols_arr = tuple([symbols(f"{name}_{i}") for i in range(100)])
+        # obj._index_lookup = {obj._symbols_arr[i]: i for i in range(len(obj._symbols_arr))}
+        mask_dict = {}
+        mask_dict[0] = 0
+        for i in range(1, len(gset._symbols_arr)):
+            index = bisect_left(index_mask, i)
+            # logger.debug(f"{index=}")
+            if index >= len(index_mask) or index_mask[index] != i:
+                # logger.debug(f"{i - index} mapsto {i} and {index_mask=}")
+                mask_dict[i - index] = i
+            # if index>=len(index_mask) or index_mask[index] != i:
+            #     mask_dict[cur_index] = i
+            #     cur_index += 1
+        # print(f"{index_mask=} {mask_dict=}")
+        obj._mask = mask_dict
+        obj._index_lookup = {gset[mask_dict[i]]: i for i in range(len(gset) - len(index_mask))}
+        obj._label = gset.label
+        return obj
+
+    @property
+    def label(self):
+        return str(self._label)
+
+    def set_label(self, label):
+        self._label = label
+
+    @property
+    def index_mask(self):
+        return tuple(self.args[1])
+
+    def complement(self):
+        return MaskedGeneratingSet(self.base_genset, [i for i in range(1, len(self.base_genset)) if i not in set(self.index_mask)])
+
+    @property
+    def base_genset(self):
+        return self.args[0]
+
+    def __call__(self, index):
+        """1-indexed"""
+        return self[index - 1]
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            start = index.start if index.start is not None else 0
+            stop = index.stop if index.stop is not None else len(self)
+            return [self[ii] for ii in range(start, stop)]
+        return self.base_genset[self._mask[index]]
+
+    def __iter__(self):
+        yield from [self[i] for i in range(len(self))]
+
+    def index(self, v):
+        try:
+            return self._index_lookup.get(v, self._index_lookup.get(sympify(v), -1))
+        except SympifyError:
+            return -1
+
+    def __len__(self):
+        return len(self.base_genset) - len(self.index_mask)
+
+
+class CustomGeneratingSet(GeneratingSet_base):
+    def __new__(cls, gens):
+        return CustomGeneratingSet.__xnew_cached__(cls, tuple(gens))
+
+    @staticmethod
+    @cache
+    def __xnew_cached__(_class, gens):
+        return CustomGeneratingSet.__xnew__(_class, gens)
+
+    @staticmethod
+    def __xnew__(_class, gens):
+        obj = GeneratingSet_base.__new__(_class, Tuple(*gens))
+        obj._symbols_arr = [sympify(gens[i]) for i in range(len(gens))]
+        obj._index_lookup = {obj._symbols_arr[i]: i for i in range(len(obj._symbols_arr))}
+        return obj
+
+    def __getitem__(self, index):
+        return self._symbols_arr[index]
+
+    def __iter__(self):
+        yield from [self[i] for i in range(len(self))]
+
+    def index(self, v):
+        try:
+            return self._index_lookup.get(v, self._index_lookup.get(sympify(v), -1))
+        except SympifyError:
+            return -1
+
+    def __call__(self, index):
+        """1-indexed"""
+        return self[index - 1]
+
+    def __len__(self):
+        return len(self.args[0])

schubmult/rings/__init__.py

@@ -0,0 +1,17 @@
+from ._quantum_schubert_polynomial_ring import QDSx, QPDSx, QSx, QuantumDoubleSchubertAlgebraElement, QuantumDoubleSchubertAlgebraElement_basis, make_parabolic_quantum_basis
+from ._schubert_polynomial_ring import DoubleSchubertAlgebraElement, DoubleSchubertAlgebraElement_basis, DSx, Sx
+from ._utils import poly_ring
+
+__all__ = [
+    "DSx",
+    "DoubleSchubertAlgebraElement",
+    "DoubleSchubertAlgebraElement_basis",
+    "QDSx",
+    "QPDSx",
+    "QSx",
+    "QuantumDoubleSchubertAlgebraElement",
+    "QuantumDoubleSchubertAlgebraElement_basis",
+    "Sx",
+    "make_parabolic_quantum_basis",
+    "poly_ring",
+]