Enum halo2_proofs::plonk::Expression

pub enum Expression<F> {
    Constant(F),
    Selector(Selector),
    Fixed(FixedQuery),
    Advice(AdviceQuery),
    Instance(InstanceQuery),
    Challenge(Challenge),
    Negated(Box<Expression<F>>),
    Sum(Box<Expression<F>>, Box<Expression<F>>),
    Product(Box<Expression<F>>, Box<Expression<F>>),
    Scaled(Box<Expression<F>>, F),
}

Low-degree expression representing an identity that must hold over the committed columns.

Variants

Constant(F)

This is a constant polynomial

Selector(Selector)

This is a virtual selector

Fixed(FixedQuery)

This is a fixed column queried at a certain relative location

Advice(AdviceQuery)

This is an advice (witness) column queried at a certain relative location

Instance(InstanceQuery)

This is an instance (external) column queried at a certain relative location

Challenge(Challenge)

This is a challenge

Negated(Box<Expression<F>>)

This is a negated polynomial

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

This is the sum of two polynomials

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

This is the product of two polynomials

Scaled(Box<Expression<F>>, F)

This is a scaled polynomial

Implementations

impl<F> Expression<F>

where F: Field,

pub fn query_cells(&mut self, cells: &mut VirtualCells<'_, F>)

Make side effects

pub fn evaluate<T>( &self, constant: &impl Fn(F) -> T, selector_column: &impl Fn(Selector) -> T, fixed_column: &impl Fn(FixedQuery) -> T, advice_column: &impl Fn(AdviceQuery) -> T, instance_column: &impl Fn(InstanceQuery) -> T, challenge: &impl Fn(Challenge) -> T, negated: &impl Fn(T) -> T, sum: &impl Fn(T, T) -> T, product: &impl Fn(T, T) -> T, scaled: &impl Fn(T, F) -> T ) -> T

Evaluate the polynomial using the provided closures to perform the operations.

pub fn evaluate_lazy<T>( &self, constant: &impl Fn(F) -> T, selector_column: &impl Fn(Selector) -> T, fixed_column: &impl Fn(FixedQuery) -> T, advice_column: &impl Fn(AdviceQuery) -> T, instance_column: &impl Fn(InstanceQuery) -> T, challenge: &impl Fn(Challenge) -> T, negated: &impl Fn(T) -> T, sum: &impl Fn(T, T) -> T, product: &impl Fn(T, T) -> T, scaled: &impl Fn(T, F) -> T, zero: &T ) -> T

where T: PartialEq,

Evaluate the polynomial lazily using the provided closures to perform the operations.

pub fn identifier(&self) -> String

Identifier for this expression. Expressions with identical identifiers do the same calculation (but the expressions don’t need to be exactly equal in how they are composed e.g. 1 + 2 and 2 + 1 can have the same identifier).

pub fn degree(&self) -> usize

Compute the degree of this polynomial

pub fn complexity(&self) -> usize

Approximate the computational complexity of this expression.

pub fn square(self) -> Expression<F>

Square this expression.

Trait Implementations

impl<F> Add for Expression<F>

where F: Field,

type Output = Expression<F>

The resulting type after applying the + operator.

fn add(self, rhs: Expression<F>) -> Expression<F>

Performs the + operation.

impl<F> Clone for Expression<F>

where F: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F> Debug for Expression<F>

where F: Debug,

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

Formats the value using the given formatter.

impl<F> Mul<F> for Expression<F>

where F: Field,

type Output = Expression<F>

The resulting type after applying the * operator.

fn mul(self, rhs: F) -> Expression<F>

Performs the * operation.

impl<F> Mul for Expression<F>

where F: Field,

type Output = Expression<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Expression<F>) -> Expression<F>

Performs the * operation.

impl<F> Neg for Expression<F>

where F: Field,

type Output = Expression<F>

The resulting type after applying the - operator.

fn neg(self) -> <Expression<F> as Neg>::Output

Performs the unary - operation.

impl<F> PartialEq for Expression<F>

where F: PartialEq,

fn eq(&self, other: &Expression<F>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> Product for Expression<F>

where F: Field,

fn product<I>(iter: I) -> Expression<F>

where I: Iterator<Item = Expression<F>>,

Method which takes an iterator and generates Self from the elements by multiplying the items.

impl<F> Sub for Expression<F>

where F: Field,

type Output = Expression<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Expression<F>) -> Expression<F>

Performs the - operation.

impl<F> Sum for Expression<F>

where F: Field,

fn sum<I>(iter: I) -> Expression<F>

where I: Iterator<Item = Expression<F>>,

Method which takes an iterator and generates Self from the elements by “summing up” the items.

impl<F> Eq for Expression<F>

where F: Eq,

impl<F> StructuralPartialEq for Expression<F>