Trait ExtensionBuilder 

pub trait ExtensionBuilder: AirBuilder
where
    Self::F: Field,
{
    type EF: ExtensionField<Self::F>;
    type ExprEF: Algebra<Self::Expr> + Algebra<Self::EF>;
    type VarEF: Into<Self::ExprEF> + Copy + Send + Sync;

    // Required method
    fn assert_zero_ext<I>(&mut self, x: I)
       where I: Into<Self::ExprEF>;

    // Provided methods
    fn assert_eq_ext<I1, I2>(&mut self, x: I1, y: I2)
       where I1: Into<Self::ExprEF>,
             I2: Into<Self::ExprEF> { ... }
    fn assert_one_ext<I>(&mut self, x: I)
       where I: Into<Self::ExprEF> { ... }
}

Extension of AirBuilder for working over extension fields.

Required Associated Types

type EF: ExtensionField<Self::F>

Extension field type.

type ExprEF: Algebra<Self::Expr> + Algebra<Self::EF>

Expression type over extension field elements.

type VarEF: Into<Self::ExprEF> + Copy + Send + Sync

Variable type over extension field elements.

Required Methods

fn assert_zero_ext<I>(&mut self, x: I)

where I: Into<Self::ExprEF>,

Assert that an extension field expression is zero.

Provided Methods

fn assert_eq_ext<I1, I2>(&mut self, x: I1, y: I2)

where I1: Into<Self::ExprEF>, I2: Into<Self::ExprEF>,

Assert that two extension field expressions are equal.

fn assert_one_ext<I>(&mut self, x: I)

where I: Into<Self::ExprEF>,

Assert that an extension field expression is equal to one.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<AB> ExtensionBuilder for FilteredAirBuilder<'_, AB>

where AB: ExtensionBuilder,

type EF = <AB as ExtensionBuilder>::EF

type ExprEF = <AB as ExtensionBuilder>::ExprEF

type VarEF = <AB as ExtensionBuilder>::VarEF

impl<F, EF> ExtensionBuilder for DebugConstraintBuilder<'_, F, EF>

where F: Field, EF: ExtensionField<F>,

type EF = EF

type ExprEF = EF

type VarEF = EF

impl<F, EF> ExtensionBuilder for SymbolicAirBuilder<F, EF>

where F: Field, EF: ExtensionField<F>, SymbolicExpr<ExtLeaf<F, EF>>: Algebra<EF>,

type EF = EF

type ExprEF = SymbolicExpr<ExtLeaf<F, EF>>

type VarEF = SymbolicVariableExt<F, EF>