Struct GateChip

pub struct GateChip<F: ScalarField> {
    pub pow_of_two: Vec<F>,
    pub field_element_cache: Vec<F>,
}

A chip that implements the GateInstructions trait supporting basic arithmetic operations.

Fields

pow_of_two: Vec<F>

The field elements 2^i for i in 0..F::NUM_BITS.

field_element_cache: Vec<F>

To avoid Montgomery conversion in F::from for common small numbers, we keep a cache of field elements.

Implementations

impl<F: ScalarField> GateChip<F>

pub fn new() -> Self

Returns a new GateChip with some precomputed values. This can be called out of circuit and has no extra dependencies.

Trait Implementations

impl<F: Clone + ScalarField> Clone for GateChip<F>

fn clone(&self) -> GateChip<F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<F: Debug + ScalarField> Debug for GateChip<F>

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

Formats the value using the given formatter.

impl<F: ScalarField> Default for GateChip<F>

fn default() -> Self

Returns the “default value” for a type.

impl<F: ScalarField> GateInstructions<F> for GateChip<F>

fn pow_of_two(&self) -> &[F]

Returns a slice of the ScalarField elements 2ⁱ for i in 0..F::NUM_BITS.

fn inner_product<QA>( &self, ctx: &mut Context<F>, a: impl IntoIterator<Item = QA>, b: impl IntoIterator<Item = QuantumCell<F>>, ) -> AssignedValue<F>

where QA: Into<QuantumCell<F>>,

Constrains and returns the inner product of <a, b>. If the first element of b is Constant(F::ONE), then an optimization is performed to save 3 cells.

Assumes ‘a’ and ‘b’ are the same length.

• ctx: Context to add the constraints to
• a: Iterator of QuantumCell values
• b: Iterator of QuantumCell values to take inner product of a by

fn inner_product_left_last<QA>( &self, ctx: &mut Context<F>, a: impl IntoIterator<Item = QA>, b: impl IntoIterator<Item = QuantumCell<F>>, ) -> (AssignedValue<F>, AssignedValue<F>)

where QA: Into<QuantumCell<F>>,

Returns the inner product of <a, b> and the last element of a after it has been assigned.

NOT encouraged for general usage. This is a low-level function, where you want to avoid first assigning a and then copying the last element into the correct cell for this computation.

Assumes ‘a’ and ‘b’ are the same length.

• ctx: Context of the circuit
• a: Iterator of QuantumCells
• b: Iterator of QuantumCells to take inner product of a by

fn inner_product_left<QA>( &self, ctx: &mut Context<F>, a: impl IntoIterator<Item = QA>, b: impl IntoIterator<Item = QuantumCell<F>>, ) -> (AssignedValue<F>, Vec<AssignedValue<F>>)

where QA: Into<QuantumCell<F>>,

Returns (<a,b>, a_assigned). See inner_product for more details.

NOT encouraged for general usage. This is a low-level function, useful for when you want to simultaneously compute an inner product while assigning private witnesses for the first time. This avoids first assigning a and then copying into the correct cells for this computation. We do not return the assignments of a in inner_product as an optimization to avoid the memory allocation of having to collect the vectors.

We do not return b_assigned because if b starts with Constant(F::ONE), the first element of b is not assigned.

Assumes ‘a’ and ‘b’ are the same length.

fn inner_product_with_sums<'thread, QA>( &self, ctx: &'thread mut Context<F>, a: impl IntoIterator<Item = QA>, b: impl IntoIterator<Item = QuantumCell<F>>, ) -> Box<dyn Iterator<Item = AssignedValue<F>> + 'thread>

where QA: Into<QuantumCell<F>>,

Calculates and constrains the inner product.

Returns the assignment trace where output[i] has the running sum sum_{j=0..=i} a[j] * b[j].

Assumes ‘a’ and ‘b’ are the same length.

• ctx: Context to add the constraints to
• a: Iterator of QuantumCell values
• b: Iterator of QuantumCell values to calculate the partial sums of the inner product of a by

fn sum_products_with_coeff_and_var( &self, ctx: &mut Context<F>, values: impl IntoIterator<Item = (F, QuantumCell<F>, QuantumCell<F>)>, var: QuantumCell<F>, ) -> AssignedValue<F>

Constrains and returns the sum of products of coeff * (a * b) defined in values plus a variable var e.g. x = var + values[0].0 * (values[0].1 * values[0].2) + values[1].0 * (values[1].1 * values[1].2) + ... + values[n].0 * (values[n].1 * values[n].2).

• ctx: Context to add the constraints to
• values: Iterator of tuples (coeff, a, b) where coeff is a field element, a and b are QuantumCell’s
• var: QuantumCell that represents the value of a variable added to the sum

fn select( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, sel: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns sel ? a : b assuming sel is boolean.

Defines a vertical gate of form | 1 - sel | sel | 1 | a | 1 - sel | sel | 1 | b | out |, where out = sel * a + (1 - sel) * b.

• ctx: Context to add the constraints to
• a: QuantumCell that contains a boolean value
• b: QuantumCell that contains a boolean value
• sel: QuantumCell that contains a boolean value

fn or_and( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, c: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constains and returns a || (b && c), assuming a, b and c are boolean.

Defines a vertical gate of form | 1 - b c | b | c | 1 | a - 1 | 1 - b c | out | a - 1 | 1 | 1 | a |, where out = a + b * c - a * b * c.

• ctx: Context to add the constraints to
• a: QuantumCell that contains a boolean value
• b: QuantumCell that contains a boolean value
• c: QuantumCell that contains a boolean value

fn num_to_bits( &self, ctx: &mut Context<F>, a: AssignedValue<F>, range_bits: usize, ) -> Vec<AssignedValue<F>>

Constrains and returns little-endian bit vector representation of a.

Assumes range_bits >= number of bits in a.

• a: QuantumCell of the value to convert
• range_bits: range of bits needed to represent a. Assumes range_bits > 0.

fn pow_var( &self, ctx: &mut Context<F>, a: AssignedValue<F>, exp: AssignedValue<F>, max_bits: usize, ) -> AssignedValue<F>

Constrains and computes a^exp where both a, exp are witnesses. The exponent is computed in the native field F.

Constrains that exp has at most max_bits bits.

fn add( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a + b * 1 = out.

fn inc( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns out = a + 1.

fn sub( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a + b * (-1) = out.

fn dec( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns out = a - 1.

fn sub_mul( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, c: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a - b * c = out.

fn neg( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a * (-1) = out.

fn mul( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns 0 + a * b = out.

fn mul_add( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, c: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a * b + c = out.

fn mul_not( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns (1 - a) * b = b - a * b.

fn assert_bit(&self, ctx: &mut Context<F>, x: AssignedValue<F>)

Constrains that x is boolean (e.g. 0 or 1).

fn div_unsafe( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a / b = out.

fn assert_is_const( &self, ctx: &mut Context<F>, a: &AssignedValue<F>, constant: &F, )

Constrains that a is equal to constant value.

fn sum<Q>( &self, ctx: &mut Context<F>, a: impl IntoIterator<Item = Q>, ) -> AssignedValue<F>

where Q: Into<QuantumCell<F>>,

Constrains and returns the sum of QuantumCell’s in iterator a.

fn partial_sums<'thread, Q>( &self, ctx: &'thread mut Context<F>, a: impl IntoIterator<Item = Q>, ) -> Box<dyn Iterator<Item = AssignedValue<F>> + 'thread>

where Q: Into<QuantumCell<F>>,

Calculates and constrains the sum of the elements of a.

fn accumulated_product<QA, QB>( &self, ctx: &mut Context<F>, a: impl IntoIterator<Item = QA>, b: impl IntoIterator<Item = QB>, ) -> Vec<AssignedValue<F>>

where QA: Into<QuantumCell<F>>, QB: Into<QuantumCell<F>>,

Calculates and constrains the accumulated product of ‘a’ and ‘b’ i.e. x_i = b_1 * (a_1...a_{i - 1}) + b_2 * (a_2...a_{i - 1}) + ... + b_i

fn or( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a || b, assuming a and b are boolean.

fn and( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns a & b, assumeing a and b are boolean.

fn not( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains and returns !a assumeing a is boolean.

fn bits_to_indicator( &self, ctx: &mut Context<F>, bits: &[AssignedValue<F>], ) -> Vec<AssignedValue<F>>

Constrains and returns an indicator vector from a slice of boolean values, where output[idx] = 1 iff idx = (the number represented by bits in binary little endian), otherwise output[idx] = 0.

fn idx_to_indicator( &self, ctx: &mut Context<F>, idx: impl Into<QuantumCell<F>>, len: usize, ) -> Vec<AssignedValue<F>>

Constrains and returns a Vec indicator of length len, where indicator[i] == 1 if i == idx otherwise 0, if idx >= len then indicator is all zeros.

fn select_by_indicator<Q>( &self, ctx: &mut Context<F>, a: impl IntoIterator<Item = Q>, indicator: impl IntoIterator<Item = AssignedValue<F>>, ) -> AssignedValue<F>

where Q: Into<QuantumCell<F>>,

Constrains the inner product of a and indicator and returns a[idx] (e.g. the value of a at idx).

fn select_from_idx<Q>( &self, ctx: &mut Context<F>, cells: impl IntoIterator<Item = Q>, idx: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

where Q: Into<QuantumCell<F>>,

Constrains and returns cells[idx] if idx < cells.len(), otherwise return 0.

fn select_array_by_indicator<AR, AV>( &self, ctx: &mut Context<F>, array2d: &[AR], indicator: &[AssignedValue<F>], ) -> Vec<AssignedValue<F>>

where AR: AsRef<[AV]>, AV: AsRef<AssignedValue<F>>,

array2d is an array of fixed length arrays. Assumes:

fn is_zero(&self, ctx: &mut Context<F>, a: AssignedValue<F>) -> AssignedValue<F>

Constrains that a cell is equal to 0 and returns 1 if a = 0, otherwise 0.

fn is_equal( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, ) -> AssignedValue<F>

Constrains that the value of two cells are equal: b - a = 0, returns 1 if a = b, otherwise 0.

fn lagrange_and_eval( &self, ctx: &mut Context<F>, coords: &[(AssignedValue<F>, AssignedValue<F>)], x: AssignedValue<F>, ) -> (AssignedValue<F>, AssignedValue<F>)

Performs and constrains Lagrange interpolation on coords and evaluates the resulting polynomial at x.