Schubert Polynomials

sage.combinat.schubert_polynomial.SchubertPolynomialRing(R)

Return the Schubert polynomial ring over R on the X basis.

This is the basis made of the Schubert polynomials.

EXAMPLES:

sage: X = SchubertPolynomialRing(ZZ); X
Schubert polynomial ring with X basis over Integer Ring
sage: TestSuite(X).run()
sage: X(1)
X[1]
sage: X([1,2,3])*X([2,1,3])
X[2, 1]
sage: X([2,1,3])*X([2,1,3])
X[3, 1, 2]
sage: X([2,1,3])+X([3,1,2,4])
X[2, 1] + X[3, 1, 2]
sage: a = X([2,1,3])+X([3,1,2,4])
sage: a^2
X[3, 1, 2] + 2*X[4, 1, 2, 3] + X[5, 1, 2, 3, 4]
class sage.combinat.schubert_polynomial.SchubertPolynomialRing_xbasis(R)

Bases: sage.combinat.free_module.CombinatorialFreeModule

EXAMPLES:

sage: X = SchubertPolynomialRing(QQ)
sage: X == loads(dumps(X))
True
Element

alias of SchubertPolynomial_class

one_basis()

Return the index of the unit of this algebra.

EXAMPLES:

sage: X = SchubertPolynomialRing(QQ)
sage: X.one()  # indirect doctest
X[1]
product_on_basis(left, right)

EXAMPLES:

sage: p1 = Permutation([3,2,1])
sage: p2 = Permutation([2,1,3])
sage: X = SchubertPolynomialRing(QQ)
sage: X.product_on_basis(p1,p2)
X[4, 2, 1, 3]
some_elements()

Return some elements.

EXAMPLES:

sage: X = SchubertPolynomialRing(QQ)
sage: X.some_elements()
[X[1], X[1] + 2*X[2, 1], -X[3, 2, 1] + X[4, 2, 1, 3]]
class sage.combinat.schubert_polynomial.SchubertPolynomial_class

Bases: sage.modules.with_basis.indexed_element.IndexedFreeModuleElement

divided_difference(i, algorithm='sage')

Return the i-th divided difference operator, applied to self.

Here, i can be either a permutation or a positive integer.

INPUT:

  • i – permutation or positive integer

  • algorithm – (default: 'sage') either 'sage' or 'symmetrica'; this determines which software is called for the computation

OUTPUT:

The result of applying the i-th divided difference operator to self.

If \(i\) is a positive integer, then the \(i\)-th divided difference operator \(\delta_i\) is the linear operator sending each polynomial \(f = f(x_1, x_2, \ldots, x_n)\) (in \(n \geq i+1\) variables) to the polynomial

\[\frac{f - f_i}{x_i - x_{i+1}}, \qquad \text{ where } f_i = f(x_1, x_2, ..., x_{i-1}, x_{i+1}, x_i, x_{i+1}, ..., x_n) .\]

If \(\sigma\) is a permutation in the \(n\)-th symmetric group, then the \(\sigma\)-th divided difference operator \(\delta_\sigma\) is the composition \(\delta_{i_1} \delta_{i_2} \cdots \delta_{i_k}\), where \(\sigma = s_{i_1} \circ s_{i_2} \circ \cdots \circ s_{i_k}\) is any reduced expression for \(\sigma\) (the precise choice of reduced expression is immaterial).

Note

The expand() method results in a polynomial in \(n\) variables named x0, x1, ..., x(n-1) rather than \(x_1, x_2, \ldots, x_n\). The variable named xi corresponds to \(x_{i+1}\). Thus, self.divided_difference(i) involves the variables x(i-1) and xi getting switched (in the numerator).

EXAMPLES:

sage: X = SchubertPolynomialRing(ZZ)
sage: a = X([3,2,1])
sage: a.divided_difference(1)
X[2, 3, 1]
sage: a.divided_difference([3,2,1])
X[1]
sage: a.divided_difference(5)
0

Any divided difference of \(0\) is \(0\):

sage: X.zero().divided_difference(2)
0

This is compatible when a permutation is given as input:

sage: a = X([3,2,4,1])
sage: a.divided_difference([2,3,1])
0
sage: a.divided_difference(1).divided_difference(2)
0

sage: a = X([4,3,2,1])
sage: a.divided_difference([2,3,1])
X[3, 2, 4, 1]
sage: a.divided_difference(1).divided_difference(2)
X[3, 2, 4, 1]
sage: a.divided_difference([4,1,3,2])
X[1, 4, 2, 3]
sage: b = X([4, 1, 3, 2])
sage: b.divided_difference(1).divided_difference(2)
X[1, 3, 4, 2]
sage: b.divided_difference(1).divided_difference(2).divided_difference(3)
X[1, 3, 2]
sage: b.divided_difference(1).divided_difference(2).divided_difference(3).divided_difference(2)
X[1]
sage: b.divided_difference(1).divided_difference(2).divided_difference(3).divided_difference(3)
0
sage: b.divided_difference(1).divided_difference(2).divided_difference(1)
0
expand()

EXAMPLES:

sage: X = SchubertPolynomialRing(ZZ)
sage: X([2,1,3]).expand()
x0
sage: [X(p).expand() for p in Permutations(3)]
[1, x0 + x1, x0, x0*x1, x0^2, x0^2*x1]
multiply_variable(i)

Return the Schubert polynomial obtained by multiplying self by the variable \(x_i\).

EXAMPLES:

sage: X = SchubertPolynomialRing(ZZ)
sage: a = X([3,2,4,1])
sage: a.multiply_variable(0)
X[4, 2, 3, 1]
sage: a.multiply_variable(1)
X[3, 4, 2, 1]
sage: a.multiply_variable(2)
X[3, 2, 5, 1, 4] - X[3, 4, 2, 1] - X[4, 2, 3, 1]
sage: a.multiply_variable(3)
X[3, 2, 4, 5, 1]
scalar_product(x)

Return the standard scalar product of self and x.

EXAMPLES:

sage: X = SchubertPolynomialRing(ZZ)
sage: a = X([3,2,4,1])
sage: a.scalar_product(a)
0
sage: b = X([4,3,2,1])
sage: b.scalar_product(a)
X[1, 3, 4, 6, 2, 5]
sage: Permutation([1, 3, 4, 6, 2, 5, 7]).to_lehmer_code()
[0, 1, 1, 2, 0, 0, 0]
sage: s = SymmetricFunctions(ZZ).schur()
sage: c = s([2,1,1])
sage: b.scalar_product(a).expand()
x0^2*x1*x2 + x0*x1^2*x2 + x0*x1*x2^2 + x0^2*x1*x3 + x0*x1^2*x3 + x0^2*x2*x3 + 3*x0*x1*x2*x3 + x1^2*x2*x3 + x0*x2^2*x3 + x1*x2^2*x3 + x0*x1*x3^2 + x0*x2*x3^2 + x1*x2*x3^2
sage: c.expand(4)
x0^2*x1*x2 + x0*x1^2*x2 + x0*x1*x2^2 + x0^2*x1*x3 + x0*x1^2*x3 + x0^2*x2*x3 + 3*x0*x1*x2*x3 + x1^2*x2*x3 + x0*x2^2*x3 + x1*x2^2*x3 + x0*x1*x3^2 + x0*x2*x3^2 + x1*x2*x3^2