Struct halo2_base::gates::flex_gate::GateChip

pub struct GateChip<F: ScalarField> {
    pub pow_of_two: Vec<F>,
    pub field_element_cache: Vec<F>,
    /* private fields */
}

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(strategy: GateStrategy) -> Self

Returns a new GateChip with the given GateStrategy.

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 strategy(&self) -> GateStrategy

Returns the GateStrategy the GateChip.

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

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

fn get_field_element(&self, n: u64) -> F

Returns the the value of n as a ScalarField element.

• n: the u64 value to convert

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>.

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 returns a tuple of the last item of a after it is assigned and the item to its left (left_a, last_a).

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_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 const_right_rotate_unsafe<const BIT: usize, const NUM_BITS: usize>(
    &self,
    ctx: &mut Context<F>,
    a: AssignedValue<F>
) -> AssignedValue<F>

Bitwise right rotate a by BIT bits. BIT and NUM_BITS must be determined at compile time.

fn const_left_rotate_unsafe<const BIT: usize, const NUM_BITS: usize>(
    &self,
    ctx: &mut Context<F>,
    a: AssignedValue<F>
) -> AssignedValue<F>

Bitwise left rotate a by BIT bits. BIT and NUM_BITS must be determined at compile time.

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 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 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 = 0.

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 xor(
    &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 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 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.