Enum CircuitElem 

pub enum CircuitElem<F: Field, B: CircuitBuilder<Field = F>> {
    Constant(F),
    Wire {
        builder: Weak<RefCell<B>>,
        wire: B::Wire,
    },
}

A field element that is either a known constant or a wire in a CircuitBuilder B.

The Wire variant holds a Weak reference to the shared builder; it must outlive any operation performed on the element. Arithmetic over all-Constant operands folds at the F level without touching a builder; any Wire operand routes the operation through B.

Variants

Constant(F)

Wire

Fields

builder: Weak<RefCell<B>>

wire: B::Wire

Implementations

impl<F, B> CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

pub fn wire(builder: &Rc<RefCell<B>>, wire: B::Wire) -> Self

Construct a Self::Wire anchored to a shared builder via a Weak reference.

pub fn to_wire(&self, builder: &mut B) -> B::Wire

Lowers this element to a wire on builder, materializing a Constant via CircuitBuilder::constant. A Wire’s backing builder is assumed to be builder; callers mixing elements from different channels must check that themselves (as Self::combine does).

pub fn combine<const IN: usize, const OUT: usize>( elems: [&Self; IN], f_op: impl Fn([F; IN]) -> [F; OUT], builder_op: impl Fn(&mut B, [B::Wire; IN]) -> [B::Wire; OUT], ) -> [Self; OUT]

Combine elems under an operation. If every input is a Constant, fold at the F level via f_op (no builder is touched). Otherwise convert constants to wires on the shared builder and run builder_op over the wires.

pub fn combine_varlen( elems: &[&Self], n_out: usize, f_op: impl FnOnce(&[F]) -> Vec<F>, builder_op: impl FnOnce(&mut B, &[B::Wire]) -> Vec<B::Wire>, ) -> Vec<Self>

Variable-arity sibling of Self::combine.

f_op and builder_op must return a Vec of length n_out; checked via debug_assert_eq!.

Trait Implementations

impl<F: Field, B: CircuitBuilder<Field = F>> Add for CircuitElem<F, B>

type Output = CircuitElem<F, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F, B> Add for &CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

type Output = CircuitElem<F, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F, B> Add<&CircuitElem<F, B>> for CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

type Output = CircuitElem<F, B>

The resulting type after applying the + operator.

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

Performs the + operation.

impl<F: Field, B: CircuitBuilder<Field = F>> AddAssign for CircuitElem<F, B>

fn add_assign(&mut self, rhs: Self)

Performs the += operation.

impl<F: Field, B: CircuitBuilder<Field = F>> AddAssign<&CircuitElem<F, B>> for CircuitElem<F, B>

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

Performs the += operation.

impl<F: Field, B: CircuitBuilder<Field = F>> Clone for CircuitElem<F, B>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Field, B: CircuitBuilder<Field = F>> Debug for CircuitElem<F, B>

where B::Wire: Debug,

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

Formats the value using the given formatter.

impl<F: Field, B: CircuitBuilder<Field = F>> FieldOps for CircuitElem<F, B>

type Scalar = F

fn zero() -> Self

Returns the zero element (additive identity).

fn one() -> Self

Returns the one element (multiplicative identity).

fn square_transpose<FSub: Field>(elems: &mut [Self])

where Self::Scalar: ExtensionField<FSub>,

Transpose the subfield elements in a slice of field elements.

impl<F: Field, B: CircuitBuilder<Field = F>> From<F> for CircuitElem<F, B>

fn from(val: F) -> Self

Converts to this type from the input type.

impl<F: Field, B: CircuitBuilder<Field = F>> InvertOrZero for CircuitElem<F, B>

fn invert_or_zero(self) -> Self

Not implemented: nothing the wrapper runs inverts a value that may be zero.

The verifier’s own inversions are all of random challenges, which it argues are non-zero, so they go through InvertOrZero::invert below. Constraining the zero case as well would cost extra constraints on every one of them, to admit an input no caller has.

This panics while the circuit is being built rather than at proving time, so a caller that does need it fails loudly and can implement it then.

unsafe fn invert(self) -> Self

Constrains the hinted inverse with the single product the contract allows.

Safety

The caller guarantees the value is non-zero. At zero the emitted constraint x * inv == 1 is unsatisfiable, so the circuit becomes unprovable rather than yielding a wrong proof.

impl<F: Field, B: CircuitBuilder<Field = F>> Mul for CircuitElem<F, B>

type Output = CircuitElem<F, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F, B> Mul for &CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

type Output = CircuitElem<F, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F, B> Mul<&CircuitElem<F, B>> for CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

type Output = CircuitElem<F, B>

The resulting type after applying the * operator.

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

Performs the * operation.

impl<F: Field, B: CircuitBuilder<Field = F>> MulAssign for CircuitElem<F, B>

fn mul_assign(&mut self, rhs: Self)

Performs the *= operation.

impl<F: Field, B: CircuitBuilder<Field = F>> MulAssign<&CircuitElem<F, B>> for CircuitElem<F, B>

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

Performs the *= operation.

impl<F: Field, B: CircuitBuilder<Field = F>> Neg for CircuitElem<F, B>

type Output = CircuitElem<F, B>

The resulting type after applying the - operator.

fn neg(self) -> Self

Performs the unary - operation.

impl<F: Field, B: CircuitBuilder<Field = F>> Product for CircuitElem<F, B>

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

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

impl<'a, F: Field, B: CircuitBuilder<Field = F>> Product<&'a CircuitElem<F, B>> for CircuitElem<F, B>

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

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

impl<F: Field, B: CircuitBuilder<Field = F>> Square for CircuitElem<F, B>

fn square(self) -> Self

Returns the value multiplied by itself

impl<F: Field, B: CircuitBuilder<Field = F>> Sub for CircuitElem<F, B>

type Output = CircuitElem<F, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F, B> Sub for &CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

type Output = CircuitElem<F, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F, B> Sub<&CircuitElem<F, B>> for CircuitElem<F, B>

where F: Field, B: CircuitBuilder<Field = F>,

type Output = CircuitElem<F, B>

The resulting type after applying the - operator.

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

Performs the - operation.

impl<F: Field, B: CircuitBuilder<Field = F>> SubAssign for CircuitElem<F, B>

fn sub_assign(&mut self, rhs: Self)

Performs the -= operation.

impl<F: Field, B: CircuitBuilder<Field = F>> SubAssign<&CircuitElem<F, B>> for CircuitElem<F, B>

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

Performs the -= operation.

impl<F: Field, B: CircuitBuilder<Field = F>> Sum for CircuitElem<F, B>

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

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

impl<'a, F: Field, B: CircuitBuilder<Field = F>> Sum<&'a CircuitElem<F, B>> for CircuitElem<F, B>

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

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