and beyond!

This module contains all functionalities that are not already organized into the other files. New functionalities written to the library often appear here, and eventually get organized into separate files.

AUTHORS:

• Matthew Lancellotti (2018): Initial version

REFERENCES:

[Fun]

(1, 2, 3, 4, 5) Raising operators and the Littlewood-Richardson polynomials. Fun, Alex.

[LN]	(1, 2) Finite sum Cauchy identity for dual Grothendieck polynomials.

class all.CatalanFunction(roots, index, base_ring=None, prefix=None)

A catalan function \(H(\Psi; \gamma)\) as discussed in [cat] section 4.

By definition,

\[H(\Psi; \gamma) := \prod_{ij \in \Psi} (1 - R_{ij})^{-1} s_\gamma = \prod_{ij \in \Delta^+ \smallsetminus \Psi} (1 - R_{ij}) H_\gamma\]

where \(s_\gamma\) is a schur function and \(H_\gamma\) is a Hall-Littlewood Q’ function.

The parameters for initializing a catalan function are exactly the same as in CatalanFunctions.init_from_indexed_root_ideal().

EXAMPLES:

sage: CatalanFunction([(0,2), (1,2)], [6, 6, 5])
H([(0, 2), (1, 2)]; [6, 6, 5])

See also

There are more ways to initialize a catalan function, and the methods for doing so are found in CatalanFunctions.

eval(t=None)

Return the catalan function in terms of the Hall-Littlewood Q’ basis.

EXAMPLES:

sage: delta_plus = partition_to_root_ideal([2, 1], n=3)
sage: cf = CatalanFunction(delta_plus, [3, 1, 1])
sage: cf.eval()
HLQp[3, 1, 1]

sage: s = SymmetricFunctions(QQ['t']).schur()
sage: cf = CatalanFunction([], [4, 1])
sage: cf.eval()
HLQp[4, 1] - t*HLQp[5]
sage: s(cf.eval())
s[4, 1]

This function can also specialize \(t\) to an arbitrary integer:

sage: cf.eval(t=1)
HLQp[4, 1] - HLQp[5]
sage: cf.eval(t=-1)
HLQp[4, 1] + HLQp[5]
sage: s(cf.eval(t=-1))
s[4, 1]

See also

expand()

expand(*args, **kwargs)

Expand the catalan function as a symmetric polynomial in n variables.

INPUT:

• n – a nonnegative integer
• alphabet – (default: 'x') a variable for the expansion

OUTPUT:

A monomial expansion of self in the \(n\) variables labelled x0, x1, …, x{n-1} (or just x if \(n = 1\)), where x is alphabet.

EXAMPLES:

sage: cf = CatalanFunction([], [4, 1])
sage: cf.expand(1)
0
sage: cf.expand(2)
x0^4*x1 + x0^3*x1^2 + x0^2*x1^3 + x0*x1^4
sage: cf.expand(2, alphabet='y')
y0^4*y1 + y0^3*y1^2 + y0^2*y1^3 + y0*y1^4

See also

eval()

class all.CatalanFunctions

The family of catalan functions, as discussed in [cat] section 4.

Use this class as a factory to initialize a CatalanFunction object with any valid identifying data. See the init_from... methods below for all possible ways to create a catalan function.

init_from_indexed_root_ideal(roots, index, base_ring=None, prefix=None)

INPUTS:

• roots – iterable of roots \(\Phi\) (typically a root ideal)
• index – composition \(\gamma\) that indexes the root ideal and appears in \(s_\gamma\) and \(H_\gamma\) below

OPTIONAL INPUTS:

• base_ring – (default QQ['t']) the ring over which to build the \(h_\gamma(x; \alpha)\)‘s

OUTPUTS:

The catalan function

\[H(\Phi; \gamma) := \prod_{ij \in \Phi} (1 - R_{ij})^{-1} s_\gamma = \prod_{ij \in \Delta^+ \smallsetminus \Phi} (1 - R_{ij}) H_\gamma\]

where \(s_\gamma\) is a schur function and \(H_\gamma\) is a Hall-Littlewood Q’ function.

EXAMPLES:

sage: CatalanFunctions().init_from_indexed_root_ideal([(0,2), (1,2)], [6, 6, 5])
H([(0, 2), (1, 2)]; [6, 6, 5])

init_from_k_schur(func, base_ring=None, prefix=None)

Given a \(k\)-schur function func \(= s^k_\lambda(x;t)\), initialize the catalan function \(H(\Delta^k(\lambda); \lambda)\).

Mathematically, these two functions are equal. The usefulness of this method is that you input a sage.combinat.sf.new_kschur.kSchur_with_category object and you obtain a CatalanFunction object.

EXAMPLES:

sage: base_ring = QQ['t']
sage: Sym = SymmetricFunctions(base_ring)
sage: t = base_ring.gen()
sage: ks = Sym.kBoundedSubspace(4, t).kschur()
sage: func = ks[2, 1, 1]
sage: CatalanFunction(func, base_ring=base_ring)
H([]; [2, 1, 1])

init_from_k_shape(p, k, base_ring=None, prefix=None, algorithm='removable roots')

Given k and a \(k\)-shape p, return the catalan function \(H(\Phi^+(p); rs(p))\).

EXAMPLES:

sage: CFS = CatalanFunctions()
sage: CFS.init_from_k_shape([4, 3, 2, 1], 1)
H([]; [4, 3, 2, 1])

init_from_row_and_column_lengths(row_lengths, column_lengths, base_ring=None, prefix=None, algorithm='removable roots')

Determine the skew partition \(D\) with row-shape row_lengths and column-shape column_lengths, and return the catalan function \(H(\Phi^+(D); \text{row_lengths})\).

EXAMPLES:

sage: CFS = CatalanFunctions()
sage: CFS.init_from_row_and_column_lengths([1, 1, 1], [2, 1])
H([(0, 1), (0, 2)]; [1, 1, 1])

See also

init_from_skew_partition()

init_from_skew_partition(sp, base_ring=None, prefix=None, algorithm='removable roots')

Given a skew partition sp, return the catalan function \(H(\Phi^+(sp); rs(sp))\).

Given a linked SkewPartition sp, return the CatalanFunction \(H(\Phi^+(sp); rs(sp))\).

EXAMPLES:

sage: CFS = CatalanFunctions()
sage: sp = SkewPartition([[2, 1, 1], [1]])
sage: CFS.init_from_skew_partition(sp)
H([(0, 1), (0, 2)]; [1, 1, 1])

See also

init_from_row_and_column_lengths()

init_parabolic_from_composition_and_index(composition, index, base_ring=None, prefix=None)

Given a composition \(\eta\) of positive integers and an index \(\gamma\), return the parabolic catalan function \(H(\Delta(\eta), \gamma)\), where

\[\Delta(\eta) := \{ \alpha \in \Delta^+_{|\eta|} \:\text{above the block diagonal with block sizes}\: \eta_1, \ldots, \eta_r\}\]

as in [cat] just below Conjecture 3.3.

EXAMPLES:

sage: CatalanFunctions().init_parabolic_from_composition_and_index([1, 3, 2], [1, 2, 3, 4, 5, 6])
H([(0, 1), (0, 2), (0, 3), (0, 4), (0, 5), (1, 4), (1, 5), (2, 4), (2, 5), (3, 4), (3, 5)]; [1, 2, 3, 4, 5, 6])

class all.DoubleHomogeneous(index1, index2, prefix='h')

INPUTS:

mu1 – composition

mu2 – composition

n – number of \(x\) variables

EXAMPLES:

Create the double homogeneous \(h^{(4)}_{\mu, \beta}\):

sage: DoubleHomogeneous(mu, beta, 4)

Create the double homogeneous shifted building block \(h_{r, s}\) in 4 variables:

sage: r = 5
sage: s = 2
sage: DoubleHomogeneous([r], [s], 4)

Create the double homogeneous symmetric building block \(h_p(x \,||\, a)\) in 4 variables:

sage: p = 3
sage: DoubleHomogeneous([p], [0], 4)

eval(n)

Given the number of variables n, return self expanded in terms of the shifted double homogeneous building blocks \(h_{r, s}\).

all.DoubleRing = InfiniteDimensionalFreeAlgebra_with_category with generators indexed by Integer Ring, over Integer Ring

DoubleRing is the ring \(\Lambda(a)\) found in [Fun] section 3.

EXAMPLES:

sage: DoubleRing
InfiniteDimensionalFreeAlgebra_with_category with generators indexed by Integer Ring, over Integer Ring

See also

InfiniteDimensionalFreeAlgebra

class all.HallLittlewoodVertexOperator(composition, base_ring=Univariate Polynomial Ring in t over Rational Field, t=None)

The Hall-Littlewood vertex operator.

Garsia’s version of Jing’s Hall-Littlewood vertex operators. These are defined in equations 4.2 and 4.3 of [cat] and appear visually as a bold capital H.

INPUTS:

• base_ring – (default QQ['t']) the base ring to build the SymmetricFunctions upon.

EXAMPLES:

sage: H = HallLittlewoodVertexOperator
sage: one = SymmetricFunctions(QQ['t']).hall_littlewood().Qp().one()
sage: H([4, 1, 3])(one) == H(4)(H(1)(H(3)(one)))
True

See also

sage.combinat.sf.new_kschur.KBoundedSubspaceBases.ElementMethods.hl_creation_operator()

class all.InfiniteDimensionalFreeAlgebra(base_ring=Integer Ring, prefix='x', basis_indices=None, index_set=Non negative integer semiring)

By default, the algebra generated by x[0], x[1], x[2], ... over the integers.

To change the index set of the generators, use index_set= (default NN). To overhaul the set of generators entirely (not recommended), use basis_indices=.

To change the ring that the algebra works over, use base_ring= (default ZZ).

To change the prefix of the generators, use prefix= (default 'x').

See also

sage.algebras.free_algebra, https://doc.sagemath.org/html/en/reference/monoids/sage/monoids/free_abelian_monoid.html, sage.monoids.free_monoid, sage.monoids.free_abelian_monoid

is_prime_field()

Return whether the infinite dimensional free algebra is a prime field (it never is!).

Note that this method exists for internal compatability.

EXAMPLES:

sage: A = InfiniteDimensionalFreeAlgebra()
sage: A.is_prime_field()
False

one_basis()

Return the index of the identity element.

EXAMPLES:

sage: A.one_basis()
1

product_on_basis(monoid_el1, monoid_el2)

Given indices monoid_el1 and monoid_el2, return the product of the basis elements indexed by those indices.

class all.PieriOperatorAlgebra(base_ring=Univariate Polynomial Ring in t over Rational Field, prefix='u')

The Pieri operator \(u_i\).

EXAMPLES:

sage: u = PieriOperatorAlgebra()

Act on catalan function:

sage: cf = CatalanFunction([(0,2), (1,2)], [6, 6, 6])
sage: u.i(2)(cf)
CatalanFunction([(0,2), (1,2)], [6, 6, 5])

Act on k-schur function:

sage: base_ring = QQ['t']
sage: Sym = SymmetricFunctions(base_ring)
sage: t = base_ring.gen()
sage: ks = Sym.kBoundedSubspace(4, t).kschur()
sage: u.i(2)(ks[2, 2, 1])
ks4[2, 2, 1] + t^2*ks4[3, 2] + t^3*ks4[4, 1]

See also

ShiftingOperatorAlgebra

i(i)

Return the Pieri operator \(u_i\).

Shorthand element constructor that allows you to create Pieri operators using the familiar \(u_i\) notation, with the exception that indices here are 0-based, not 1-based.

EXAMPLES:

Create the Pieri operator which lowers part 2 (indices are 0-based):

sage: u.i(2)
u((0, 0, -1))

See also

ShiftingOperatorAlgebra._element_constructor_(), ShiftingOperatorAlgebra.__getitem__()

class all.RaisingOperatorAlgebra(base_ring=Univariate Polynomial Ring in t over Rational Field, prefix='R')

An algebra of raising operators.

This class subclasses ShiftingOperatorAlgebra and inherits the large majority of its functionality from there.

We follow the following convention!:

R[(1, 0, -1)] is the raising operator that raises the first part by 1 and lowers the third part by 1.

For a definition of raising operators, see [cat] Definition 2.1, but be wary that the notation is different there. See ij() for a way to create operators using the notation in the paper.

If you do NOT want any restrictions on the allowed sequences, use ShiftingOperatorAlgebra instead of RaisingOperatorAlgebra.

OPTIONAL ARGUMENTS:

• base_ring – (default QQ['t']) the ring you will use on the raising operators.
• prefix – (default "R") the label for the raising operators.

EXAMPLES:

sage: R = RaisingOperatorAlgebra()
sage: s = SymmetricFunctions(QQ['t']).s()
sage: h = SymmetricFunctions(QQ['t']).h()

sage: R[(1, -1)]
R(1, -1)
sage: R[(1, -1)](s[5, 4])
s[6, 3]
sage: R[(1, -1)](h[5, 4])
h[6, 3]

sage: (1 - R[(1,-1)]) * (1 - R[(0,1,-1)])
R() - R(0, 1, -1) - R(1, -1) + R(1, 0, -1)
sage: ((1 - R[(1,-1)]) * (1 - R[(0,1,-1)]))(s[2, 2, 1])
(-3*t-2)*s[] + s[2, 2, 1] - s[3, 1, 1] + s[3, 2]

See also

ShiftingOperatorAlgebra

ij(i, j)

Return the raising operator \(R_{ij}\) as notated in [cat] Definition 2.1.

Shorthand element constructor that allows you to create raising operators using the familiar \(R_{ij}\) notation found in [cat] Definition 2.1, with the exception that indices here are 0-based, not 1-based.

EXAMPLES:

Create the raising operator which raises part 0 and lowers part 2 (indices are 0-based):

sage: R.ij(0, 2)
R((1, 0, -1))

See also

ShiftingOperatorAlgebra._element_constructor_(), ShiftingOperatorAlgebra.__getitem__()

class all.RaisingSequenceSpace(base=Integer Ring)

A helper for RaisingOperatorAlgebra.

Helps RaisingOperatorAlgebra know which indices are valid and which indices are not for the basis.

EXAMPLES:

sage: RS = RaisingSequenceSpace()
sage: (1, -1) in RS
True
sage: (1, 0, -1) in RS
True
sage: (1, -1, 0, 9) in RS
False
sage: [1, -1] in RS
False

class all.ShiftingOperatorAlgebra(base_ring=Univariate Polynomial Ring in t over Rational Field, prefix='S', basis_indices=<all.ShiftingSequenceSpace instance>)

An algebra of shifting operators.

We follow the following convention:

S[(1, 0, -1, 2)] is the shifting operator that raises the first part by 1, lowers the third part by 1, and raises the fourth part by 2.

OPTIONAL ARGUMENTS:

• base_ring – (default QQ['t']) the ring you will use on the raising operators.
• prefix – (default "R") the label for the raising operators.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: s = SymmetricFunctions(QQ['t']).s()
sage: h = SymmetricFunctions(QQ['t']).h()

sage: S[(1, -1, 2)]
S(1, -1, 2)
sage: S[(1, -1, 2)](s[5, 4])
s[6, 3, 2]
sage: S[(1, -1, 2)](h[5, 4])
h[6, 3, 2]

sage: (1 - S[(1,-1)]) * (1 - S[(4,)])
S() - S(1, -1) - S(4,) + S(5, -1)
sage: ((1 - S[(1,-1)]) * (1 - S[(4,)]))(s[2, 2, 1])
s[2, 2, 1] - s[3, 1, 1] - s[6, 2, 1] + s[7, 1, 1]

See also

RaisingOperatorAlgebra, PieriOperatorAlgebra

class Element

An element of a :class`ShiftingOperatorAlgebra`.

index()

Return the index of self.

This method is only for basis elements.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: S[2, 1].index()
(2, 1)
sage: (S[2, 1] + S[1, 1]).index()
Traceback (most recent call last):
...
ValueError: This is only defined for basis elements.  For other elements, use indices() instead.

indices()

Return the support of self.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: (S[2, 1] + S[1, 1]).indices()
[(1, 1), (2, 1)]

one_basis()

Return the index of the identity element.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: S.one_basis()
()

product_on_basis(index1, index2)

Given indices index1 and index2, return the product of the basis elements indexed by those indices.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: S.product_on_basis([1, 1], [0, 1, 2])
S(1, 2, 2)

class ShiftingOperatorAlgebra.Element

An element of a :class`ShiftingOperatorAlgebra`.

index()

Return the index of self.

This method is only for basis elements.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: S[2, 1].index()
(2, 1)
sage: (S[2, 1] + S[1, 1]).index()
Traceback (most recent call last):
...
ValueError: This is only defined for basis elements.  For other elements, use indices() instead.

indices()

Return the support of self.

EXAMPLES:

sage: S = ShiftingOperatorAlgebra()
sage: (S[2, 1] + S[1, 1]).indices()
[(1, 1), (2, 1)]

class all.ShiftingSequenceSpace(base=Integer Ring)

A helper for ShiftingOperatorAlgebra.

Helps ShiftingOperatorAlgebra know which indices are valid and which indices are not for the basis.

EXAMPLES:

sage: S = ShiftingSequenceSpace()
sage: (1, -1) in S
True
sage: (1, -1, 0, 9) in S
True
sage: [1, -1] in S
False
sage: (0.5, 1) in S
False

check(seq)

Verify that seq is a valid shifting sequence.

If it is not, raise an error.

EXAMPLES:

sage: S = ShiftingSequenceSpace()
sage: S.check((1, -1))
sage: S.check((1, -1, 0, 9))
sage: S.check([1, -1])
Traceback (most recent call last):
...
ValueError: Expected valid index (a tuple of Integer Ring), but instead received [1, -1].
sage: S.check((0.5, 1))
Traceback (most recent call last):
...
ValueError: Expected valid index (a tuple of Integer Ring), but instead received [1, -1].

all.compositional_hall_littlewood_Qp(gamma, base_ring=Univariate Polynomial Ring in t over Rational Field, t=None)

Given gamma, returns the compositional Hall-Littlewood polynomial \(H_{\gamma}(\mathbf{x}; t)\) in the Q’ basis, as defined in [cat] section 4.4.

If the composition gamma is a partition, this is just the Hall-Littlewood Q’ polynomial.

EXAMPLES:

sage: hl = SymmetricFunctions(QQ['t']).hall_littlewood().Qp()
sage: compositional_hall_littlewood_Qp([3, 3, 2]) == hl[3, 3, 2]
True

See also

sage.combinat.sf.hall_littlewood.HallLittlewood.Qp()

all.double_catalan_function(roots, index, n)

Given some roots (typically a RootIdeal), an index, and the something something of the double homemgeneous function n, return the corresponding double catalan function.

all.double_homogeneous_building_block(p, n)

The double complete homogeneous symmetric polynomial “building block” \(h_p(x || a)\).

Defined as

\[h_p(x_1, \ldots, x_n \,||\, a) \,= \sum_{n \geq i_1 \geq \ldots \geq i_p \geq 1} (x_{i_1} - a_{i_1})(x_{i_2} - a_{i_2 - 1}) \cdots (x_{i_p} - a_{i_p - p + 1})\]

in [Fun] section 3 between equation (6) and (7). Note that our indices are 0-based.

See also

DoubleHomogeneous, double_homogeneous_building_block_shifted(), shift()

all.double_homogeneous_building_block_shifted(r, s, n)

Given \(r\) and \(s\), returns \(h_{r, s} = \tau^s h_r(x \,||\, a)\), as defined in [Fun] before eq (8).

See also

DoubleHomogeneous, double_homogeneous_building_block(), shift()

all.double_schur(index, n)

Given a composition index \(= \lambda\) and the number of variables \(n\), return the double Schur function defined by

\[s_\lambda(x_1, \ldots, x_n \,||\, a) = \text{det}\left(h^{(n)}_{\lambda_i + i - j, j - 1}\right)\]

or equivalently, defined by

\[s_\lambda(x_1, \ldots, x_n \,||\, a) = \prod_{ij \in \Delta^+(l)} (1 - R_{ij}) h^{(n)}_{\lambda, (0, \ldots, l-1)}\]

where \(l\) is the length of \(\lambda\), in [Fun] p.9 equation (9).

all.dual_grothendieck_function(composition, base_ring=Rational Field)

Given a composition \(composition = \lambda\), return the dual Grothendieck function defined by \(g_\lambda(x) = \text{det}(h_{\lambda_i + j - i}(x, i - 1))\) in [LN] p.88 equation (4).

Equivalently, the dual Grothendieck function is \(g_\lambda(x) = \prod_{ij \in \Delta^+} (1 - R_{ij}) h_\lambda(x; (0, 1, \ldots, n-1))\).

EXAMPLES:

sage: h = SymmetricFunctions(QQ).h()
sage: dual_grothendieck_function([2, 1])
h[1]*h[2] + h[2] - h[3]

See also

dual_k_catalan_function()

all.dual_k_catalan_function(roots, index, index2, base_ring=Rational Field)

INPUTS:

• roots – iterable of roots \(\Phi\) (typically a RootIdeal)
• index – composition \(\gamma\) that indexes \(h_\gamma(x; \alpha)\)
• index2 – composition \(\alpha\) used in \(h_\gamma(x; \alpha)\)

OPTIONAL INPUTS:

• base_ring – (default QQ) the ring over which to build the \(h_\gamma(x; \alpha)\)‘s

OUTPUTS:

The ‘dual k’ catalan function

\[\prod_{ij \in \Delta^+ \smallsetminus \Phi} (1 - R_{ij}) h_\gamma(x; \alpha).\]

See also

dual_k_theoretic_homogeneous(), dual_grothendieck_function()

all.dual_k_theoretic_homogeneous(k, r, base_ring=Rational Field)

The dual K-theoretic h, often denoted Kh, is defined for any integer \(k\) by the formula \(h_k(x, r) = \sum_{i=0}^{k} \binom{r + i - 1}{i} h_{k - i}(x)\) in [LN] p.88 top-right.

If k and r are compositions, then it is recursively defined as \(h_k(x, r) := \prod_j h_{k_j}(x, r_j)\).

EXAMPLES:

sage: dual_k_theoretic_homogeneous(0, 0)
1

sage: dual_k_theoretic_homogeneous(1, 2, base_ring=QQ['t'])
h[1] + 2

sage: dual_k_theoretic_homogeneous([2, 1], [1, 1])
h[1]**2 + h[1]*h[2] + 2*h[1] + h[2] + 1

See also

dual_k_catalan_function()

all.get_k_irreducible_partition_lists(k)

Return the list of k-irreducible partitions.

The \(k\)-irreducible partitions are output at lists, not Partition objects.

There are \(k!\) such partitions, and computation time starts to get slow around \(k = 10\).

EXAMPLES:

sage: get_k_irreducible_partition_lists(0)
[[]]
sage: get_k_irreducible_partition_lists(1)
[[]]
sage: get_k_irreducible_partition_lists(2)
[[], [1]]
sage: get_k_irreducible_partition_lists(3)
[[], [1], [1, 1], [2], [2, 1], [2, 1, 1]]

See also

get_k_irreducible_partitions()

all.get_k_irreducible_partitions(k)

Return the list of k-irreducible partitions.

The output is a list of Partition objects.

There are \(k!\) such partitions, and computation time starts to get slow around \(k = 10\).

EXAMPLES:

sage: get_k_irreducible_partitions(0)
[[]]
sage: get_k_irreducible_partitions(1)
[[]]
sage: get_k_irreducible_partitions(2)
[[], [1]]
sage: get_k_irreducible_partitions(3)
[[], [1], [1, 1], [2], [2, 1], [2, 1, 1]]

See also

get_k_irreducible_partition_lists()

all.get_k_rectangles(k)

Return the list of k-rectangles.

A __``k``-rectangle__ is a partition whose Ferrer’s diagram is a rectangle whose largest hook-length is \(k\).

EXAMPLES:

sage: get_k_rectangles(0)
[]
sage: get_k_rectangles(1)
[[1]]
sage: get_k_rectangles(2)
[[2], [1, 1]]
sage: get_k_rectangles(3)
[[3], [2, 2], [1, 1, 1]]

all.k_plus_one_core_to_k_schur_function(p, k, base_ring=Univariate Polynomial Ring in t over Rational Field)

Given a \(k+1\)-core p, the natural number k itself, and optionally a base_ring, return the corresponding \(k\)-schur function.

all.qt_raising_roots_operator(roots, base_ring=Multivariate Polynomial Ring in t, q over Rational Field, t=None, q=None)

Return the operator \(\prod_{ij \in \Phi} (1 - tR_{ij}) \prod_{ij \in roots} (1 - qR_{ij})\).

The q-t analogue of raising_roots_operator(), defined by

\[\prod_{ij \in \Phi} (1 - tR_{ij}) \prod_{ij \in \Phi} (1 - qR_{ij}).\]

EXAMPLES:

Consider the root ideal [(0, 1)] in the 2 x 2 grid. This root ideal gives the “qt” raising roots operator \((1 - t R_{01})(1 - q R_{01})\) which equals \(1 + (-t-q) R_{01} + t q R_{01}^2\):

sage: K = QQ['t', 'q']
sage: (t, q) = K.gens()
sage: R = RaisingOperatorAlgebra(base_ring=K)

sage: (1 - t*R.ij(0, 1)) * (1 - q*R.ij(0, 1))
R() + (-t-q)*R(1, -1) + t*q*R(2, -2)

sage: qt_raising_roots_operator([(0, 1)], base_ring=K, t=t, q=q)
R() + (-t-q)*R(1, -1) + t*q*R(2, -2)

Since QQ['t', 'q'] happens to be the default base ring, and its generators are t and q, we did not actually need to pass in the base ring, \(t\), nor \(q\) in the above example:

sage: qt_raising_roots_operator([(0, 1)])
R() + (-t-q)*R(1, -1) + t*q*R(2, -2)

See also

raising_roots_operator()

all.raising_roots_operator(roots, base_ring=Univariate Polynomial Ring in t over Rational Field, t=1)

Return the operator \(\prod_{(i,j) \in roots} (1 - tR_{ij})\).

Given a list of roots \(roots = \Phi\) (often a root ideal), and optionally a variable \(t\), return the operator

\[\prod_{(i,j) \in \Phi} (1 - tR_{ij}).\]

If you input an integer for roots (e.g. roots = 3), it will use the biggest possible root ideal in the \(n\) x \(n\) grid (the ‘\(n\)-th staircase root ideal’).

EXAMPLES:

Consider the root ideal [(0, 1)] in the 2 x 2 grid. This root ideal gives the raising roots operator \(1 - R_{01}\):

sage: R = RaisingOperatorAlgebra()
sage: 1 - R.ij(0, 1)
R() - R(1, -1)

sage: raising_roots_operator([(0, 1)])
R() - R(1, -1)

sage: raising_roots_operator(2)
R() - R(1, -1)

We can pass in \(t\) in addition to get the raising roots operator \(1 - t R_{01}\). We can also choose a base ring to work over:

sage: K = FractionField(ZZ['t'])
sage: t = K.gen()
sage: R = RaisingOperatorAlgebra(base_ring=K)

sage: 1 - t * R.ij(0, 1)
R() - t*R(1, -1)

sage: raising_roots_operator([(0, 1)], base_ring=K, t=t)
R() - t*R(1, -1)

sage: raising_roots_operator(2, base_ring=K, t=t)
R() - t*R(1, -1)

See also

qt_raising_roots_operator(), CatalanFunction

all.shift(element)

The function \(\tau\) which acts on any element of \(\Lambda(a)\) (DoubleRing) by sending each element \(a_i\) to \(a_{i+1}\) for all \(i\). It can be found in [Fun] p.8 between equations (6) and (7).

See also

double_homogeneous_building_block_shifted(), double_homogeneous_building_block()

all.size_to_k_shapes(n, k)

Return all partitions of size n that are k-shapes.

all.size_to_num_linked_partition_self_pairs(size)

Given a natural number size, count how many partitions \(l\) of size size have the property that \((l, l)\) has a corresponding skew-linked-diagram.

Note: A ‘skew-linked-diagram’ is a SkewPartition that is linked.

EXAMPLES:

sage: size_to_num_linked_partition_self_pairs(0)
1
sage: size_to_num_linked_partition_self_pairs(1)
1
sage: size_to_num_linked_partition_self_pairs(2)
1
sage: size_to_num_linked_partition_self_pairs(3)
2

See also

SkewPartition.is_linked()

all.straighten(basis, gamma)

Perform Schur function straightening by the Schur straightening rule.

See [cat], Prop. 4.1. Also known as the slinky rule.

\[\begin{split}s_{\gamma}(\mathbf{x}) = \begin{cases} \text{sgn}(\gamma+\rho) s_{\text{sort}(\gamma+\rho) -\rho}(\mathbf{x}) & \text{if } \gamma + \rho \text{ has distinct nonnegative parts,} \\ 0 & \text{otherwise,} \end{cases}\end{split}\]

where \(\rho=(\ell-1,\ell-2,\dots,0)\), \(\text{sort}(\beta)\) denotes the weakly decreasing sequence obtained by sorting \(\beta\), and \(\text{sgn}(\beta)\) denotes the sign of the (shortest possible) sorting permutation.

EXAMPLES:

We know s[2, 1, 3] := -s[2, 2, 2]:

sage: s = SymmetricFunctions(QQ).s()
sage: straighten(s, [2, 1, 3])
-s[2, 2, 2]

all.substitute(f, t=None, q=None)

Given a symmetric function f, plug the inputted t and q values into it and return the resulting function.

See also

SymmetricFunctionAlgebra_schur_with_category.element_class.plethysm(), ungraded()

all.ungraded(f)

Given a symmetric function f, return the result of plugging in \(t = 1\).

See also

substitute()