Struct ArithCircuit

pub struct ArithCircuit<F: Field> { /* private fields */ }

Arithmetic expressions that can be evaluated symbolically.

Arithmetic expressions are trees, where the leaves are either constants or variables, and the non-leaf nodes are arithmetic operations, such as addition, multiplication, etc. They are specific representations of multivariate polynomials.

We store a tree in a form of a simple circuit. This implementation isn’t optimized for performance, but rather for simplicity to allow easy conversion and preservation of the common subexpressions

Implementations

impl<F: Field> ArithCircuit<F>

pub fn var(index: usize) -> Self

pub fn constant(value: F) -> Self

pub fn zero() -> Self

pub fn one() -> Self

pub fn pow(self, exp: u64) -> Self

pub fn steps(&self) -> &[ArithCircuitStep<F>]

Steps of the circuit.

pub fn degree(&self) -> usize

The total degree of the polynomial the expression represents.

pub fn n_vars(&self) -> usize

The number of variables the expression contains.

pub fn binary_tower_level(&self) -> usize

where F: TowerField,

The maximum tower level of the constant terms in the circuit.

pub fn eval_cost(&self) -> EvalCost

Returns the evaluation cost of the circuit.

pub fn leading_term(&self) -> Self

Return a new arithmetic expression that contains only the terms of highest degree (useful for interpolation at Karatsuba infinity point).

pub fn evaluate(&self, query: &[F]) -> Result<F, Error>

pub fn convert_field<FTgt: Field + From<F>>(&self) -> ArithCircuit<FTgt>

pub fn try_convert_field<FTgt: Field + TryFrom<F>>( &self, ) -> Result<ArithCircuit<FTgt>, <FTgt as TryFrom<F>>::Error>

pub fn remap_vars(&self, indices: &[usize]) -> Result<Self, Error>

Creates a new expression with the variable indices remapped.

This recursively replaces the variable sub-expressions with an index i with the variable indices[i].

Throws

• Error::IncorrectArgumentLength if indices has length less than the current number of variables

pub fn const_subst(self, var: usize, value: F) -> Self

Substitute variable with index var with a constant value

pub fn get_constant(&self) -> Option<F>

Returns Some(F) if the expression is a constant.

pub fn linear_normal_form(&self) -> Result<LinearNormalForm<F>, Error>

Returns the normal form of an expression if it is linear.

Throws

• Error::NonLinearExpression if the expression is not linear.

pub fn vars_usage(&self) -> Vec<bool>

Returns a vector of booleans indicating which variables are used in the expression.

The vector is indexed by variable index, and the value at index i is true if and only if the variable is used in the expression.

pub fn optimize_constants_in_place(&mut self)

Fold constants in the circuit.

pub fn optimize_constants(self) -> Self

Same as optimize_constants_in_place, but returns a new instance of the circuit.

pub fn optimize_in_place(&mut self)

Optimize the current instance of the circuit:

• Fold constants
• Extract common steps
• Remove unused steps

pub fn optimize(self) -> Self

Same as optimize_in_place, but returns a new instance of the circuit.

Trait Implementations

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

type Output = ArithCircuit<F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Field> AddAssign for ArithCircuit<F>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

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

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

Returns a copy of the value.

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

Performs copy-assignment from source.

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

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

Formats the value using the given formatter.

impl<F: Field + DeserializeBytes> DeserializeBytes for ArithCircuit<F>

fn deserialize( read_buf: impl Buf, mode: SerializationMode, ) -> Result<Self, SerializationError>

where Self: Sized,

impl<F: Field> Display for ArithCircuit<F>

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

Formats the value using the given formatter.

impl<F: Field> From<&ArithCircuit<F>> for ArithExpr<F>

fn from(circuit: &ArithCircuit<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<&ArithExpr<F>> for ArithCircuit<F>

fn from(expr: &ArithExpr<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<ArithCircuit<F>> for ArithExpr<F>

fn from(circuit: ArithCircuit<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<ArithExpr<F>> for ArithCircuit<F>

fn from(expr: ArithExpr<F>) -> Self

Converts to this type from the input type.

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

type Output = ArithCircuit<F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field> MulAssign for ArithCircuit<F>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<F: Field> PartialEq for ArithCircuit<F>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

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

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

impl<F: Field> Product for ArithCircuit<F>

fn product<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by multiplying the items.

impl<F: Field + SerializeBytes> SerializeBytes for ArithCircuit<F>

fn serialize( &self, write_buf: impl BufMut, mode: SerializationMode, ) -> Result<(), SerializationError>

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

type Output = ArithCircuit<F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Field> SubAssign for ArithCircuit<F>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F: Field> Sum for ArithCircuit<F>

fn sum<I: Iterator<Item = Self>>(iter: I) -> Self

Takes an iterator and generates Self from the elements by “summing up” the items.

impl<F: Eq + Field> Eq for ArithCircuit<F>