Struct bellperson::Namespace

pub struct Namespace<'a, Scalar, CS>(_, _)
where
    Scalar: PrimeField,
    CS: ConstraintSystem<Scalar>;

This is a “namespaced” constraint system which borrows a constraint system (pushing a namespace context) and, when dropped, pops out of the namespace context.

Trait Implementations

impl<'cs, Scalar, CS> ConstraintSystem<Scalar> for Namespace<'cs, Scalar, CS>where Scalar: PrimeField, CS: ConstraintSystem<Scalar>,

type Root = <CS as ConstraintSystem<Scalar>>::Root

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

fn one() -> Variable

Return the “one” input variable

fn alloc<F, A, AR>( &mut self, annotation: 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, annotation: 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, annotation: 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 <Namespace<'cs, Scalar, CS> as ConstraintSystem<Scalar>>::Root

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

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

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 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 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<'a, Scalar, CS> Drop for Namespace<'a, Scalar, CS>where Scalar: PrimeField, CS: ConstraintSystem<Scalar>,

fn drop(&mut self)

Executes the destructor for this type.