Struct Var 

pub struct Var<'ctx, F> { /* private fields */ }

A value in a circuit being built.

Vars are created with Self::witness and Self::constant, combined with the usual arithmetic operators, and constrained with Self::assert_eq. Vars implement the algebra traits from commonware_math, so code written against Ring or Field runs unchanged over circuit values.

Values produced by Additive::zero and Ring::one are “native”: they live outside the circuit until combined with a circuit value. This is visible in two places: equality compares what vars refer to, not what they evaluate to (a native var is never equal to a circuit-backed var, even when their values agree), and Self::assert_eq panics on two unequal native vars. Generic code that branches on equality may therefore behave differently over vars than over plain values.

Implementations

impl<'ctx, F> Var<'ctx, F>

pub fn witness( ctx: Context<'ctx, F>, init: impl for<'a> FnOnce(Values<'a, F>) -> F, ) -> Self

Allocate a fresh witness.

In prover mode, init receives the values assigned so far, and must return the value of this witness. In verifier mode, init does not run.

init must not use the Context: doing so deadlocks. See Values.

pub const fn native(value: F) -> Self

Create a “native” var holding a value outside any circuit.

Like the vars produced by Additive::zero and Ring::one, a native var lives outside the circuit until it is combined with a circuit-backed var, at which point it is folded in as a constant. This is convenient for fixed constants (such as curve parameters) that are the same in every circuit and so do not need a Context to create.

pub fn constant(ctx: Context<'ctx, F>, value: F) -> Self

Create a var with a fixed, public value.

pub fn assert_eq(&self, other: &Self)

where F: Clone + PartialEq,

Assert that this var equals other.

The constraint must hold for the circuit to be satisfied.

Panics

Panics if both vars are native and their values differ, since there is no circuit to record the failure in.

impl<'ctx, F: Clone> Var<'ctx, F>

pub fn value(&self, values: Values<'_, F>) -> F

The value of this var, under a prover-mode assignment.

Trait Implementations

impl<'ctx, F: Additive> Add<&Var<'ctx, F>> for Var<'ctx, F>

type Output = Var<'ctx, F>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<'ctx, F: Additive> AddAssign<&Var<'ctx, F>> for Var<'ctx, F>

fn add_assign(&mut self, rhs: &Self)

Performs the += operation.

impl<'ctx, F: Additive + Ring> Additive for Var<'ctx, F>

fn zero() -> Self

The neutral element for addition.

fn double(&mut self)

Add an element to itself.

fn scale(&self, bits_le: &[u64]) -> Self

Scale this number by a positive integer.

impl<'ctx, F: Clone> Clone for Var<'ctx, F>

fn clone(&self) -> Var<'ctx, F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug> Debug for Var<'_, F>

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

Formats the value using the given formatter.

impl<'ctx, F: Field> Div<&Var<'ctx, F>> for Var<'ctx, F>

Division by rhs, computed as a single multiplication constraint.

Rather than inverting rhs and multiplying (which costs two multiplications), the prover supplies the quotient q = self / rhs as a witness and the circuit constrains q * rhs == self.

Caveats

Like Field::inv on a circuit-backed var, this deviates from the inv(0) = 0 field contract: dividing by a circuit-backed rhs of zero adds an unsatisfiable constraint when self != 0. Worse, 0 / 0 constrains q * 0 == 0, which holds for any q, leaving the quotient unconstrained. Only use / where rhs is known to be nonzero.

type Output = Var<'ctx, F>

The resulting type after applying the / operator.

fn div(self, rhs: &Self) -> Self

Performs the / operation.

impl<'ctx, F: Field> DivAssign<&Var<'ctx, F>> for Var<'ctx, F>

fn div_assign(&mut self, rhs: &Self)

Performs the /= operation.

impl<F: Eq> Eq for Var<'_, F>

impl<'ctx, F: Field> Field for Var<'ctx, F>

Unlike the Field::inv contract, inverting a circuit-backed zero does not produce zero: it adds an unsatisfiable constraint to the circuit.

fn inv(&self) -> Self

The multiplicative inverse of an element.

impl<'ctx, F: Multiplicative> Mul<&Var<'ctx, F>> for Var<'ctx, F>

type Output = Var<'ctx, F>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<'ctx, F: Multiplicative> MulAssign<&Var<'ctx, F>> for Var<'ctx, F>

fn mul_assign(&mut self, rhs: &Self)

Performs the *= operation.

impl<'ctx, F: Multiplicative> Multiplicative for Var<'ctx, F>

fn square(&mut self)

Multiply an element with itself.

impl<'ctx, F: Additive + Ring> Neg for Var<'ctx, F>

type Output = Var<'ctx, F>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<'ctx, F: Object> Object for Var<'ctx, F>

impl<F: PartialEq> PartialEq for Var<'_, F>

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

Equality operator ==.

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

Inequality operator !=.

impl<'ctx, F: Ring> Ring for Var<'ctx, F>

fn one() -> Self

The neutral element for multiplication.

fn exp(&self, bits_le: &[u64]) -> Self

Exponentiate this number by a positive integer.

impl<'ctx, F: Additive + Ring> Sub<&Var<'ctx, F>> for Var<'ctx, F>

type Output = Var<'ctx, F>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<'ctx, F: Additive + Ring> SubAssign<&Var<'ctx, F>> for Var<'ctx, F>

fn sub_assign(&mut self, rhs: &Self)

Performs the -= operation.