Struct SchubertCalculus 

pub struct SchubertCalculus {
    pub grassmannian_dim: (usize, usize),
    /* private fields */
}

Schubert calculus engine

Fields

grassmannian_dim: (usize, usize)

The underlying Grassmannian

Implementations

impl SchubertCalculus

pub fn new(grassmannian_dim: (usize, usize)) -> Self

Create a new Schubert calculus engine

pub fn grassmannian_dimension(&self) -> usize

Get the dimension of the Grassmannian

Contract

ensures: result == k * (n - k)

pub fn intersection_number( &mut self, class1: &SchubertClass, class2: &SchubertClass, ) -> EnumerativeResult<Rational64>

Compute intersection number of two Schubert classes

Contract

requires: class1.grassmannian_dim == class2.grassmannian_dim == self.grassmannian_dim
ensures: result >= 0
ensures: class1.dimension() + class2.dimension() != self.grassmannian_dimension()
         => result == 0

pub fn multi_intersect( &mut self, classes: &[SchubertClass], ) -> IntersectionResult

Intersect multiple Schubert classes

Given classes σ_{λ_1}, …, σ_{λ_m}, compute their intersection number in the Grassmannian Gr(k, n).

Contract

requires: forall c in classes. c.grassmannian_dim == self.grassmannian_dim
ensures:
  - sum(c.codimension() for c in classes) > dim(Gr) => Empty
  - sum(c.codimension() for c in classes) == dim(Gr) => Finite(n)
  - sum(c.codimension() for c in classes) < dim(Gr) => PositiveDimensional

pub fn lr_cached( &mut self, lambda: &Partition, mu: &Partition, nu: &Partition, ) -> u64

Get or compute LR coefficient with caching

Contract

ensures: result == lr_coefficient(lambda, mu, nu)
ensures: lr_cached(lambda, mu, nu) == lr_cached(mu, lambda, nu)  // symmetry

pub fn product( &mut self, class1: &SchubertClass, class2: &SchubertClass, ) -> Vec<(SchubertClass, u64)>

Expand product of two Schubert classes

Contract

requires: class1.grassmannian_dim == class2.grassmannian_dim == self.grassmannian_dim
ensures: forall (c, coeff) in result. coeff > 0
ensures: product(class1, class2) == product(class2, class1)  // commutativity

pub fn pieri_multiply( &self, schubert_class: &SchubertClass, special_class: usize, ) -> EnumerativeResult<Vec<SchubertClass>>

Multiply two Schubert classes using Pieri’s rule (simplified)

Trait Implementations

impl Debug for SchubertCalculus

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for SchubertCalculus

fn default() -> Self

Returns the “default value” for a type.