Trait snarkvm_wasm::ConstraintSystem[−][src]

pub trait ConstraintSystem<F> where
    F: Field, {
    type Root: ConstraintSystem<F>;
    fn alloc<FN, A, AR>(
        &mut self, 
        annotation: A, 
        f: FN
    ) -> Result<Variable, SynthesisError>
    where
        A: FnOnce() -> AR,
        FN: FnOnce() -> Result<F, SynthesisError>,
        AR: AsRef<str>;

    fn alloc_input<FN, A, AR>(
        &mut self, 
        annotation: A, 
        f: FN
    ) -> Result<Variable, SynthesisError>
    where
        A: FnOnce() -> AR,
        FN: FnOnce() -> Result<F, SynthesisError>,
        AR: AsRef<str>;

    fn enforce<A, AR, LA, LB, LC>(&mut self, annotation: A, a: LA, b: LB, c: LC)
    where
        LC: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
        A: FnOnce() -> AR,
        AR: AsRef<str>,
        LA: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
        LB: FnOnce(LinearCombination<F>) -> LinearCombination<F>;

    fn push_namespace<NR, N>(&mut self, name_fn: N)
    where
        N: FnOnce() -> NR,
        NR: AsRef<str>;

    fn pop_namespace(&mut self);

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

    fn num_constraints(&self) -> usize;

    fn num_public_variables(&self) -> usize;

    fn num_private_variables(&self) -> usize;

    fn one() -> Variable { ... }

    fn ns<NR, N>(&mut self, name_fn: N) -> Namespace<'_, F, Self::Root>
    where
        N: FnOnce() -> NR,
        NR: AsRef<str>,
    { ... }
}
Expand description

Represents a constraint system which can have new variables allocated and constrains between them formed.

Associated Types

type Root: ConstraintSystem<F>[src]

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

Required methods

fn alloc<FN, A, AR>(
    &mut self,
    annotation: A,
    f: FN
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    FN: FnOnce() -> Result<F, SynthesisError>,
    AR: AsRef<str>, [src]

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<FN, A, AR>(
    &mut self,
    annotation: A,
    f: FN
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    FN: FnOnce() -> Result<F, SynthesisError>,
    AR: AsRef<str>, [src]

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
    LC: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    LB: FnOnce(LinearCombination<F>) -> LinearCombination<F>, [src]

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, name_fn: N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

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

fn pop_namespace(&mut self)[src]

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

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

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

fn num_constraints(&self) -> usize[src]

Output the number of constraints in the system.

fn num_public_variables(&self) -> usize[src]

Output the number of public input variables to the system.

fn num_private_variables(&self) -> usize[src]

Output the number of private input variables to the system.

Provided methods

fn one() -> Variable[src]

Return the “one” input variable

fn ns<NR, N>(&mut self, name_fn: N) -> Namespace<'_, F, Self::Root> where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

Begin a namespace for this constraint system.

Implementations on Foreign Types

impl<'_, F, CS> ConstraintSystem<F> for &'_ mut CS where
    CS: ConstraintSystem<F>,
    F: Field, [src]

Convenience implementation of ConstraintSystem for mutable references to constraint systems.

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

pub fn one() -> Variable[src]

pub fn alloc<FN, A, AR>(
    &mut self,
    annotation: A,
    f: FN
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    FN: FnOnce() -> Result<F, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<FN, A, AR>(
    &mut self,
    annotation: A,
    f: FN
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    FN: FnOnce() -> Result<F, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, annotation: A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    LB: FnOnce(LinearCombination<F>) -> LinearCombination<F>, [src]

pub fn push_namespace<NR, N>(&mut self, name_fn: N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(&mut self) -> &mut <&'_ mut CS as ConstraintSystem<F>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

Implementors

impl<'_, F, CS> ConstraintSystem<F> for Namespace<'_, F, CS> where
    CS: ConstraintSystem<F>,
    F: Field, [src]

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

pub fn one() -> Variable[src]

pub fn alloc<FN, A, AR>(
    &mut self,
    annotation: A,
    f: FN
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    FN: FnOnce() -> Result<F, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<FN, A, AR>(
    &mut self,
    annotation: A,
    f: FN
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    FN: FnOnce() -> Result<F, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, annotation: A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    LB: FnOnce(LinearCombination<F>) -> LinearCombination<F>, [src]

pub fn push_namespace<NR, N>(&mut self, N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <Namespace<'_, F, CS> as ConstraintSystem<F>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

impl<ConstraintF> ConstraintSystem<ConstraintF> for ConstraintCounter where
    ConstraintF: Field, [src]

type Root = ConstraintCounter

pub fn alloc<F, A, AR>(&mut self, A, F) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<ConstraintF, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<F, A, AR>(
    &mut self,
    A,
    F
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<ConstraintF, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, A, LA, LB, LC) where
    LC: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>,
    LB: FnOnce(LinearCombination<ConstraintF>) -> LinearCombination<ConstraintF>, [src]

pub fn push_namespace<NR, N>(&mut self, N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <ConstraintCounter as ConstraintSystem<ConstraintF>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

impl<E> ConstraintSystem<<E as PairingEngine>::Fr> for snarkvm_wasm::gm17::KeypairAssembly<E> where
    E: PairingEngine, [src]

type Root = KeypairAssembly<E>

pub fn alloc<F, A, AR>(&mut self, A, F) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<F, A, AR>(
    &mut self,
    A,
    F
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    LB: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>, [src]

pub fn push_namespace<NR, N>(&mut self, N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <KeypairAssembly<E> as ConstraintSystem<<E as PairingEngine>::Fr>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

impl<E> ConstraintSystem<<E as PairingEngine>::Fr> for snarkvm_wasm::gm17::ProvingAssignment<E> where
    E: PairingEngine, [src]

type Root = ProvingAssignment<E>

pub fn alloc<F, A, AR>(&mut self, A, f: F) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<F, A, AR>(
    &mut self,
    A,
    f: F
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    LB: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>, [src]

pub fn push_namespace<NR, N>(&mut self, N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <ProvingAssignment<E> as ConstraintSystem<<E as PairingEngine>::Fr>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

impl<E> ConstraintSystem<<E as PairingEngine>::Fr> for snarkvm_wasm::groth16::KeypairAssembly<E> where
    E: PairingEngine, [src]

type Root = KeypairAssembly<E>

pub fn alloc<F, A, AR>(&mut self, A, F) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<F, A, AR>(
    &mut self,
    A,
    F
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    LB: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>, [src]

pub fn push_namespace<NR, N>(&mut self, N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <KeypairAssembly<E> as ConstraintSystem<<E as PairingEngine>::Fr>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

impl<E> ConstraintSystem<<E as PairingEngine>::Fr> for snarkvm_wasm::groth16::ProvingAssignment<E> where
    E: PairingEngine, [src]

type Root = ProvingAssignment<E>

pub fn alloc<F, A, AR>(&mut self, A, f: F) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn alloc_input<F, A, AR>(
    &mut self,
    A,
    f: F
) -> Result<Variable, SynthesisError> where
    A: FnOnce() -> AR,
    F: FnOnce() -> Result<<E as PairingEngine>::Fr, SynthesisError>,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>,
    LB: FnOnce(LinearCombination<<E as PairingEngine>::Fr>) -> LinearCombination<<E as PairingEngine>::Fr>, [src]

pub fn push_namespace<NR, N>(&mut self, N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <ProvingAssignment<E> as ConstraintSystem<<E as PairingEngine>::Fr>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]

impl<F> ConstraintSystem<F> for TestConstraintSystem<F> where
    F: Field, [src]

type Root = TestConstraintSystem<F>

pub fn alloc<Fn, A, AR>(
    &mut self,
    annotation: A,
    f: Fn
) -> Result<Variable, SynthesisError> where
    Fn: FnOnce() -> Result<F, SynthesisError>,
    A: FnOnce() -> AR,
    AR: AsRef<str>, [src]

pub fn alloc_input<Fn, A, AR>(
    &mut self,
    annotation: A,
    f: Fn
) -> Result<Variable, SynthesisError> where
    Fn: FnOnce() -> Result<F, SynthesisError>,
    A: FnOnce() -> AR,
    AR: AsRef<str>, [src]

pub fn enforce<A, AR, LA, LB, LC>(&mut self, annotation: A, a: LA, b: LB, c: LC) where
    LC: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    A: FnOnce() -> AR,
    AR: AsRef<str>,
    LA: FnOnce(LinearCombination<F>) -> LinearCombination<F>,
    LB: FnOnce(LinearCombination<F>) -> LinearCombination<F>, [src]

pub fn push_namespace<NR, N>(&mut self, name_fn: N) where
    N: FnOnce() -> NR,
    NR: AsRef<str>, [src]

pub fn pop_namespace(&mut self)[src]

pub fn get_root(
    &mut self
) -> &mut <TestConstraintSystem<F> as ConstraintSystem<F>>::Root[src]

pub fn num_constraints(&self) -> usize[src]

pub fn num_public_variables(&self) -> usize[src]

pub fn num_private_variables(&self) -> usize[src]