Struct bellpepper::util_cs::witness_cs::WitnessCS

pub struct WitnessCS<Scalar>
where
    Scalar: PrimeField,
{ /* private fields */ }

A ConstraintSystem which calculates witness values for a concrete instance of an R1CS circuit.

Implementations

impl<Scalar: PrimeField> WitnessCS<Scalar>

pub fn scalar_inputs(&self) -> Vec<Scalar>

pub fn scalar_aux(&self) -> Vec<Scalar>

Trait Implementations

impl<Scalar> Clone for WitnessCS<Scalar>

where Scalar: PrimeField + Clone,

fn clone(&self) -> WitnessCS<Scalar>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Scalar> ConstraintSystem<Scalar> for WitnessCS<Scalar>

where Scalar: PrimeField,

type Root = WitnessCS<Scalar>

Represents the type of the “root” of this constraint system so that nested namespaces can minimize indirection.

fn new() -> Self

fn alloc<F, A, AR>(&mut self, _: A, f: F) -> Result<Variable, SynthesisError>

where F: FnOnce() -> Result<Scalar, SynthesisError>, A: FnOnce() -> AR, AR: Into<String>,

Allocate a private variable in the constraint system. The provided function is used to determine the assignment of the variable. The given annotation function is invoked in testing contexts in order to derive a unique name for this variable in the current namespace.

fn alloc_input<F, A, AR>( &mut self, _: A, f: F, ) -> Result<Variable, SynthesisError>

where F: FnOnce() -> Result<Scalar, SynthesisError>, A: FnOnce() -> AR, AR: Into<String>,

Allocate a public variable in the constraint system. The provided function is used to determine the assignment of the variable.

fn enforce<A, AR, LA, LB, LC>(&mut self, _: A, _a: LA, _b: LB, _c: LC)

where A: FnOnce() -> AR, AR: Into<String>, LA: FnOnce(LinearCombination<Scalar>) -> LinearCombination<Scalar>, LB: FnOnce(LinearCombination<Scalar>) -> LinearCombination<Scalar>, LC: FnOnce(LinearCombination<Scalar>) -> LinearCombination<Scalar>,

Enforce that A * B = C. The annotation function is invoked in testing contexts in order to derive a unique name for the constraint in the current namespace.

fn push_namespace<NR, N>(&mut self, _: N)

where NR: Into<String>, N: FnOnce() -> NR,

Create a new (sub)namespace and enter into it. Not intended for downstream use; use namespace instead.

fn pop_namespace(&mut self)

Exit out of the existing namespace. Not intended for downstream use; use namespace instead.

fn get_root(&mut self) -> &mut Self::Root

Gets the “root” constraint system, bypassing the namespacing. Not intended for downstream use; use namespace instead.

fn is_extensible() -> bool

Most implementations of ConstraintSystem are not ‘extensible’: they won’t implement a specialized version of extend and should therefore also keep the default implementation of is_extensible so callers which optionally make use of extend can know to avoid relying on it when unimplemented.

fn extend(&mut self, other: &Self)

Extend concatenates thew other constraint systems to the receiver, modifying the receiver, whose inputs, allocated variables, and constraints will precede those of the other constraint system. The primary use case for this is parallel synthesis of circuits which can be decomposed into entirely independent sub-circuits. Each can be synthesized in its own thread, then the original ConstraintSystem can be extended with each, in the same order they would have been synthesized sequentially.

fn is_witness_generator(&self) -> bool

Determines if the current ConstraintSystem instance is a witness generator. ConstraintSystems that are witness generators need not assemble the actual constraints. Rather, they exist only to efficiently create a witness.

fn extend_inputs(&mut self, new_inputs: &[Scalar])

Extend the inputs of the ConstraintSystem.

fn extend_aux(&mut self, new_aux: &[Scalar])

Extend the auxiliary inputs of the ConstraintSystem.

fn allocate_empty( &mut self, aux_n: usize, inputs_n: usize, ) -> (&mut [Scalar], &mut [Scalar])

Allocate empty space for the auxiliary inputs and the main inputs of the ConstraintSystem.

fn inputs_slice(&self) -> &[Scalar]

Returns the constraint system’s inputs as a slice of Scalars.

fn aux_slice(&self) -> &[Scalar]

Returns the constraint system’s aux witness as a slice of Scalars.

fn one() -> Variable

Return the “one” input variable

fn namespace<NR, N>(&mut self, name_fn: N) -> Namespace<'_, Scalar, Self::Root>

where NR: Into<String>, N: FnOnce() -> NR,

Begin a namespace for this constraint system.

fn allocate_empty_inputs(&mut self, _n: usize) -> &mut [Scalar]

Allocate empty space for the main inputs of the ConstraintSystem.

fn allocate_empty_aux(&mut self, _n: usize) -> &mut [Scalar]

Allocate empty space for the auxiliary inputs of the ConstraintSystem.

impl<Scalar> Debug for WitnessCS<Scalar>

where Scalar: PrimeField + Debug,

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

Formats the value using the given formatter.

impl<Scalar> PartialEq for WitnessCS<Scalar>

where Scalar: PrimeField + PartialEq,

fn eq(&self, other: &WitnessCS<Scalar>) -> 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<Scalar> StructuralPartialEq for WitnessCS<Scalar>

where Scalar: PrimeField,