Struct EquivariantLocalizer 

pub struct EquivariantLocalizer {
    pub grassmannian: (usize, usize),
    pub weights: TorusWeights,
    /* private fields */
}

Equivariant localizer for Grassmannian intersection computations.

Uses the Atiyah-Bott fixed point framework with Schubert calculus for reliable intersection number computation.

Fields

grassmannian: (usize, usize)

Grassmannian parameters (k, n)

weights: TorusWeights

Torus weights

Implementations

impl EquivariantLocalizer

pub fn new(grassmannian: (usize, usize)) -> EnumerativeResult<Self>

Create a new localizer for Gr(k, n) with standard weights.

Contract

requires: k <= n
ensures: result.fixed_point_count() == C(n, k)

pub fn with_weights( grassmannian: (usize, usize), weights: TorusWeights, ) -> EnumerativeResult<Self>

Create a localizer with custom weights.

Contract

requires: k <= n
requires: weights.len() == n

pub fn fixed_point_count(&self) -> usize

Number of fixed points: C(n, k).

pub fn fixed_points(&mut self) -> &[FixedPoint]

Get all fixed points.

pub fn localized_intersection( &mut self, classes: &[SchubertClass], ) -> Rational64

Compute the localized intersection of multiple Schubert classes.

Delegates to LR coefficient computation via SchubertCalculus::multi_intersect for correctness, while the localization framework provides geometric structure.

Contract

requires: total codimension == dim(Gr) for a finite answer
ensures: result agrees with LR coefficient computation

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

Compute intersection result with codimension checks.

Handles the three cases: overdetermined (Empty), transverse (Finite), and underdetermined (PositiveDimensional).

Contract

ensures: result == Empty when sum(codim) > dim(Gr)
ensures: result == Finite(n) when sum(codim) == dim(Gr)
ensures: result == PositiveDimensional when sum(codim) < dim(Gr)

pub fn fixed_point_analysis(&mut self) -> Vec<(&FixedPoint, Rational64)>

Analyze the fixed-point contributions for a transverse intersection.

Returns (fixed_point, euler_class) pairs for geometric analysis.

Contract

ensures: result.len() == C(n, k)
ensures: forall (_, euler) in result. euler != 0 (for distinct weights)

pub fn fq_point_count( &mut self, class: &SchubertClass, q: u64, ) -> EnumerativeResult<u64>

Count F_q-rational points on a Schubert variety via localization.

Uses the Lefschetz trace formula: |X_λ(F_q)| = Σ_{fixed points p in X_λ} q^{dim of attracting cell at p}

pub fn atiyah_bott_intersection( &mut self, classes: &[SchubertClass], ) -> EnumerativeResult<Rational64>

Genuine Atiyah-Bott localization computation.

Computes ∫{Gr(k,n)} σ{λ₁} · … · σ_{λ_m} via: Σ_{I} ∏j σ{λ_j}(e_I) / e_T(T_{e_I} Gr)

pub fn schubert_restriction( &self, class: &SchubertClass, fixed_point: &FixedPoint, ) -> Rational64

Schubert class restriction to a torus fixed point.

σ_λ(e_I) = ∏{(i,j) ∈ λ} (t{I_j} − t_{complement_{i}}) where the product is over boxes (i,j) of the Young diagram of λ.

Trait Implementations

impl Debug for EquivariantLocalizer

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

Formats the value using the given formatter.