Struct CircuitBuilder 

pub struct CircuitBuilder<F>
where
    F: Field,
{ /* private fields */ }

Builder for constructing arithmetic circuits

Implementations

impl<F> CircuitBuilder<F>

where F: Field,

pub fn new(witness_size: usize, public_input_size: usize) -> CircuitBuilder<F>

Create a new circuit builder

Arguments

• witness_size - Number of witness wires (private inputs)
• public_input_size - Number of public input wires

Example

use lib_q_zkp::circuit::CircuitBuilder;
use lib_q_stark_field::extension::Complex;
use lib_q_stark_mersenne31::Mersenne31;

type Val = Complex<Mersenne31>;

let mut builder = CircuitBuilder::<Val>::new(2, 1);
let a = builder.wire(0);  // witness wire 0
let b = builder.wire(1);  // witness wire 1
let sum = builder.add(a, b);
builder.assert_zero(sum);
let circuit = builder.build();

pub fn alloc_wire(&mut self) -> Wire

Allocate a new intermediate wire

pub fn wire(&self, index: usize) -> Wire

Get a wire by index (for public inputs and witness)

pub fn assert_zero(&mut self, wire: Wire)

Assert that a wire equals zero

pub fn assert_eq(&mut self, left: Wire, right: Wire)

Assert that two wires are equal

pub fn assert_constant(&mut self, wire: Wire, constant: F)

Assert that a wire equals a constant

pub fn add(&mut self, left: Wire, right: Wire) -> Wire

Add two wires and return the result wire

pub fn mul(&mut self, left: Wire, right: Wire) -> Wire

Multiply two wires and return the result wire

pub fn build(self) -> ArithmeticCircuit<F>

Build the circuit