Enum AirExpr 

pub enum AirExpr<F: Field> {
    Constant(F),
    Ref(ColumnRef),
    Neg(Box<AirExpr<F>>),
    Sum(Box<AirExpr<F>>, Box<AirExpr<F>>),
    Product(Box<AirExpr<F>>, Box<AirExpr<F>>),
}

A symbolic polynomial expression over row-relative column references.

Used to define AIR transition constraints: expressions that must equal zero for every consecutive row pair (row[i], row[i+1]).

Examples

use field_cat::F101;
use machine_cat::{AirExpr, Column};

// Constraint: next_a - current_b = 0
let current_b = AirExpr::<F101>::current(Column::new(1));
let next_a = AirExpr::<F101>::next(Column::new(0));
let constraint = next_a - current_b;

Variants

Constant(F)

A field constant.

Ref(ColumnRef)

A row-relative column reference.

Neg(Box<AirExpr<F>>)

Negation.

Sum(Box<AirExpr<F>>, Box<AirExpr<F>>)

Sum of two expressions.

Product(Box<AirExpr<F>>, Box<AirExpr<F>>)

Product of two expressions.

Implementations

impl<F: Field> AirExpr<F>

pub fn constant(c: F) -> Self

A constant expression.

pub fn current(col: Column) -> Self

Reference a column in the current row.

pub fn next(col: Column) -> Self

Reference a column in the next row.

pub fn evaluate<A: Fn(ColumnRef) -> Result<F, Error>>( &self, assignment: &A, ) -> Result<F, Error>

Evaluate this expression given a row-pair assignment.

The assignment maps each ColumnRef to a field value for a specific (row[i], row[i+1]) pair.

Errors

Returns an error if the assignment fails for any referenced column (e.g., column out of bounds).

Trait Implementations

impl<F: Field> Add for AirExpr<F>

type Output = AirExpr<F>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self

Performs the + operation.

impl<F: Clone + Field> Clone for AirExpr<F>

fn clone(&self) -> AirExpr<F>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for AirExpr<F>

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

Formats the value using the given formatter.

impl<F: Field> Mul for AirExpr<F>

type Output = AirExpr<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Self) -> Self

Performs the * operation.

impl<F: Field> Neg for AirExpr<F>

type Output = AirExpr<F>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<F: Field> Sub for AirExpr<F>

type Output = AirExpr<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Self) -> Self

Performs the - operation.