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: Field> Expression<F>

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: PartialEq>(
    &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

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) -> Self

Square this expression.

Trait Implementations

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

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> Clone for Expression<F>

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> Debug for Expression<F>

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

Formats the value using the given formatter.

impl<F: Field> From<Expression<F>> for Constraint<F>

fn from(poly: Expression<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<Expression<F>> for Vec<Constraint<F>>

fn from(poly: Expression<F>) -> Self

Converts to this type from the input type.

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

type Output = Expression<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Expression<F>

The resulting type after applying the * operator.

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

Performs the * operation.

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

type Output = Expression<F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

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

type Output = Expression<F>

The resulting type after applying the - operator.

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

Performs the - operation.