schubmult.rings.schubert.double_schubert_ring¶

Double Schubert polynomial ring: the DSx interface.

DoubleSchubertRing represents Z[y][x] in the basis of double Schubert polynomials S_w(x; y), dispatching products to schubmult.mult.double. It is also the workhorse behind the single ring (schubert_ring.SingleSchubertRing is a DoubleSchubertRing with an all-zero coefficient alphabet). Beyond ring arithmetic, DoubleSchubertElement supports divided differences, isobaric divided differences, variable substitution/evaluation, coproducts, and expansion into elementary-symmetric ("CEM"/"SEM") bases.

Variants: ElemDoubleSchubertRing keeps coefficients as unevaluated factorial elementary symmetric functions; DoubleSchubertRingDown uses the descent-side ("down") kernels.

is_fact_elem_sym¶

def is_fact_elem_sym(obj)

Whether obj is an (unevaluated) factorial elementary symmetric function.

is_fact_complete_sym¶

def is_fact_complete_sym(obj)

Whether obj is an (unevaluated) factorial complete homogeneous symmetric function.

DoubleSchubertElement Objects¶

class DoubleSchubertElement(BaseSchubertElement)

An element of a DoubleSchubertRing: {Permutation: coefficient} in the double Schubert basis S_w(x; y), with sympy coefficients in y.

to_genset_dict¶

def to_genset_dict(trim=False)

Expand to a polynomial and return {exponent_tuple: coeff} over the x variables; trim=True merges keys that differ only by trailing zeros.

divdiff¶

def divdiff(i)

Divided difference partial_i: S_w -> S_{w s_i} when i is a descent of w, else 0.

simpleref¶

def simpleref(i)

Action of the simple reflection s_i on the x variables: f + (x_{i+1} - x_i) partial_i f.

coeff_isobaric¶

def coeff_isobaric(i, beta)

Isobaric divided difference acting on the y (coefficient) alphabet, transported through the basis via the antipode-style inversion S_w -> (-1)^{l(w)} S_{w^{-1}}.

isobaric¶

def isobaric(i, beta)

Beta-deformed isobaric divided difference pi_i = partial_i + beta (x_i partial_i - 1).

divdiff_perm¶

def divdiff_perm(perm)

Apply partial_w for w = perm, peeling simple reflections from the last descent.

isobaric_perm¶

def isobaric_perm(perm, beta)

Apply the beta-isobaric pi_w for w = perm.

isobaric_plus_beta¶

def isobaric_plus_beta(i, beta)

The variant partial_i + beta x_i partial_i (isobaric without the -beta identity term).

act¶

def act(perm)

Permute the x variables by perm, as a composition of simplerefs.

max_index¶

def max_index()

The largest x index (1-indexed) any basis permutation actually depends on.

eval¶

def eval(x)

Substitute {generator: value} pairs one at a time (via pull_out_gen); returns a scalar if the result collapses to the identity basis element.

subs¶

def subs(old, new)

Substitute old -> new where old is an x variable (moved to the last position and pulled out via pull_out_var), a y variable (transported through the basis), or a plain coefficient symbol.

free_symbols¶

@property
def free_symbols()

Coefficient symbols plus the x/y variables the basis permutations actually depend on.

pull_out_gen¶

def pull_out_gen(gen)

Factor out all dependence on one generator gen (an x or y variable), returning an element over a MaskedGeneratingSet ring with gen removed and explicit (gen - y_j) (or factorial-elementary-symmetric) prefactors.

in_CEM_basis¶

def in_CEM_basis()

Expand in the complete-elementary-monomial (CEM) basis using the ring's symbolic elementary function.

cem_rep¶

def cem_rep(elem_func, mumu=None)

CEM expansion with a custom elem_func; mumu selects a dominant permutation to expand against (defaults to the classical route).

coproduct¶

def coproduct(*indices,
              alt_coeff_genset=None,
              on_coeff_gens=False,
              gname1=None,
              gname2=None)

Coproduct splitting the x variables (or y if on_coeff_gens) at the given 1-indexed indices: returns an element of the TensorRing of two DoubleSchubertRings over the complementary MaskedGeneratingSets, labeled gname1/gname2.

max_gens¶

@cached_property
def max_gens()

Largest 0-indexed descent over all basis permutations.

positive_elem_sym_rep¶

def positive_elem_sym_rep()

Manifestly positive expansion in factorial elementary symmetric functions (forward pull_out_var).

positive_elem_sym_rep_backward¶

def positive_elem_sym_rep_backward()

Like positive_elem_sym_rep but peeling from the last descent backward.

antipode¶

def antipode()

The antipode: swap the two alphabets and invert each basis permutation (see DoubleSchubertRing.antipode).

DoubleSchubertRing Objects¶

class DoubleSchubertRing(BaseSchubertRing)

The ring of double Schubert polynomials S_w(x; y) over genset (x) and coeff_genset (y). Call the ring with a permutation, Lehmer code, or polynomial expression to construct an element; the module-level DSx is the standard instance.

coeff_ring¶

@cached_property
def coeff_ring()

The single Schubert ring over the coefficient alphabet y (used by coeff_isobaric).

antipode_ring¶

@cached_property
def antipode_ring()

The same ring with the two alphabets swapped.

antipode¶

def antipode(elem)

Map sum c_w S_w(x; y) to sum c_w S_{w^{-1}}(y; x) in the swapped-alphabet ring.

rmul¶

def rmul(elem, other)

Right-multiply by a scalar (coefficient-domain element) or, failing that, by an expression.

positive_elem_sym_rep¶

def positive_elem_sym_rep(perm, index=1)

Manifestly positive expansion of S_perm in factorial elementary symmetric functions, peeling the first variable of ~perm at each step (pull_out_var(1, ...)).

positive_elem_sym_rep_backward¶

def positive_elem_sym_rep_backward(perm)

Like positive_elem_sym_rep but peeling from the last descent of ~perm backward.

printing_term¶

def printing_term(k, prefix="")

The DSchubPoly display symbol for basis element k.

elem_sym¶

@property
def elem_sym()

FactorialElemSym.

is_elem_mul_type¶

def is_elem_mul_type(other)

Whether other is a factorial elementary symmetric function (eligible for elem_mul).

elem_mul¶

def elem_mul(ring_elem, elem)

Multiply by a factorial elementary symmetric function in x variables via the positional Pieri rule (elem_sym_positional_perms), expanding the leftover factor with expand_func.

symbol_elem_func¶

@property
def symbol_elem_func()

FactorialElemSym (kept unevaluated for symbolic expansions).

schubert_schur_elem_func¶

def schubert_schur_elem_func(numvars)

Elementary-symmetric substitute for the Schubert-tensor-Schur expansion: e_p(x_1..x_k) maps to a Schubert basis element on the left factor when k >= numvars and on the right otherwise.

in_schubert_schur_basis¶

def in_schubert_schur_basis(perm, numvars)

Expand S_perm in the Schubert-tensor-Schur basis, treating the last numvars variables as the symmetric (Schur) part.

in_descending_schur_basis¶

def in_descending_schur_basis(perm, numvars)

Iterate in_schubert_schur_basis down through numvars, numvars-1, ..., 1, producing a nested tensor of Schur-like factors.

elem_sym_subs¶

def elem_sym_subs(kk)

Substitution dict {e_p_k: elem_sym_poly(p, k, x)} for all 1 <= p <= k <= kk.

flip¶

@staticmethod
def flip(elem)

Re-express a factorial elementary symmetric function with its two alphabets swapped, via the corresponding Grassmannian Schubert polynomial's CEM expansion.

in_quantum_basis¶

def in_quantum_basis(elem)

Expand each basis element via quantum_schubpoly (a quantum double Schubert element).

in_classical_basis¶

def in_classical_basis(elem)

Identity (this ring is already classical).

quantum_schubpoly¶

@cache
def quantum_schubpoly(perm)

The classical S_perm expressed in the quantum double Schubert basis (via quantum_elem_func).

cached_product¶

@cache
def cached_product(u, v, basis2)

Structure constants of S_u(x; y) * S_v(x; z) (z = basis2.coeff_genset), via schubmult_double.

cached_positive_product¶

@cache
def cached_positive_product(u, v, basis2)

Like cached_product but with manifestly positive coefficients (generic alphabets, then substituted).

double_mul¶

@property
def double_mul()

schubmult.mult.double.schubmult_double.

single_mul¶

@property
def single_mul()

schubmult.mult.single.schubmult_py.

mult_poly_single¶

@property
def mult_poly_single()

schubmult.mult.single.mult_poly_py.

mult_poly_double¶

@property
def mult_poly_double()

schubmult.mult.double.mult_poly_double.

quantum_elem_func¶

@property
def quantum_elem_func()

Elementary symmetric function valued in the quantum double Schubert ring, computed by a divide-and-conquer recursion on the variable set (used by quantum_schubpoly).

monomial_schub¶

def monomial_schub(monom)

The monomial x^monom expressed in the Schubert basis (trailing zeros in monom ignored).

cached_schubpoly¶

@cache
def cached_schubpoly(k)

The explicit polynomial S_k(x; y) (cached).

complete_mul¶

def complete_mul(elem, x)

Multiply by a factorial complete homogeneous symmetric function in x variables via complete_sym_positional_perms (the dual Pieri rule).

handle_sympoly¶

def handle_sympoly(other)

How a symmetric-function coefficient is stored: evaluated to a polynomial here.

single_variable¶

def single_variable(elem, varnum)

Multiply by the single variable x_varnum (equivariant Monk rule).

from_expr¶

def from_expr(expr)

Convert a polynomial expression in x/y into the Schubert basis.

mul_expr¶

def mul_expr(elem, x)

Multiply elem by an arbitrary expression x: single variables use the Monk rule, (factorial) elementary/complete symmetric functions use their Pieri rules (splitting out variables from the wrong alphabet as needed), and Add/Mul/Pow recurse; anything else is treated as a coefficient.

new¶

def new(x)

Build an element from a permutation/Lehmer list, an existing element of this ring, or an expression.

DoubleSchubertRingDown Objects¶

class DoubleSchubertRingDown(DoubleSchubertRing)

DoubleSchubertRing using the descent-side ("down") multiplication kernels (schubmult_double_down/schubmult_py_down); basis symbols print with an op prefix.

double_mul¶

@property
def double_mul()

schubmult.mult.double.schubmult_double_down.

single_mul¶

@property
def single_mul()

schubmult.mult.single.schubmult_py_down.

cached_product¶

@cache
def cached_product(u, v, basis2)

Down-kernel structure constants over generic alphabets, substituted back to the ring's alphabets.

cached_positive_product¶

@cache
def cached_positive_product(u, v, basis2)

Positive variant of cached_product for the down kernel.

printing_term¶

def printing_term(k, prefix="op")

The DSchubPoly display symbol, prefixed with op by default.

ElemDoubleSchubertRing Objects¶

class ElemDoubleSchubertRing(DoubleSchubertRing)

DoubleSchubertRing whose coefficients are kept as unevaluated FactorialElemSym functions instead of being expanded to polynomials; products use the *_from_elems kernels.

replacematch¶

@property
def replacematch()

A (a, b) -> expression rewriter turning differences a - b into FactorialElemSym(1, 1, ...) forms, respecting which alphabet each symbol belongs to.

elem_func¶

@property
def elem_func()

FactorialElemSym.

handle_sympoly¶

def handle_sympoly(other)

Keep symmetric-function coefficients unevaluated.

elem_mul¶

def elem_mul(ring_elem, elem)

Positional Pieri rule for a factorial elementary symmetric function, keeping the leftover factor as an unevaluated coefficient.

complete_mul¶

def complete_mul(elem, x)

Dual Pieri rule for a factorial complete symmetric function, keeping the leftover factor unevaluated.

cached_product¶

@cache
def cached_product(u, v, basis2)

Structure constants via schubmult_double_from_elems with FactorialElemSym coefficients.

cached_positive_product¶

@cache
def cached_positive_product(u, v, basis2)

Structure constants via the positive schubmult_double_alt_from_elems route.

new¶

def new(x)

Build an element from a permutation/Lehmer list, an element of this ring, or an expression.

DSx¶

def DSx(x, genset=GeneratingSet("y"), elem_sym=False, down=False)

Construct a double Schubert polynomial element in x with coefficient alphabet genset.

DSx([3, 1, 2]) is S_{312}(x; y). Pass genset="z" (or a GeneratingSet) for a different coefficient alphabet; elem_sym=True uses ElemDoubleSchubertRing, down=True uses DoubleSchubertRingDown.