Struct RangeChip

pub struct RangeChip<F: ScalarField> {
    pub gate: GateChip<F>,
    pub limb_bases: Vec<QuantumCell<F>>,
    /* private fields */
}

RangeChip

This chip provides methods that rely on “range checking” that a field element x is within a range of bits. Range checks are done using a lookup table with the numbers [0, 2^lookup_bits).

Fields

gate: GateChip<F>

Underlying GateChip for this chip.

limb_bases: Vec<QuantumCell<F>>

Vec of powers of 2 ** lookup_bits represented as QuantumCell::Constant. These are precomputed and cached as a performance optimization for later limb decompositions. We precompute up to the higher power that fits in F, which is 2 ** ((F::CAPACITY / lookup_bits) * lookup_bits).

Implementations

impl<F: ScalarField> RangeChip<F>

pub fn lookup_manager(&self) -> &[LookupAnyManager<F, 1>; 3]

Lookup manager for each phase, lazily initiated using the SharedCopyConstraintManager from the Context that first calls it.

The lookup manager is used to store the cells that need to be looked up in the range check lookup table.

impl<F: ScalarField> RangeChip<F>

pub fn new( lookup_bits: usize, lookup_manager: [LookupAnyManager<F, 1>; 3], ) -> Self

Creates a new RangeChip with the given strategy and lookup_bits.

• lookup_bits: number of bits represented in the lookup table [0,2^lookup_bits)
• lookup_manager: a LookupAnyManager for each phase.

IMPORTANT: It is critical that all LookupAnyManagers use the same SharedCopyConstraintManager as in your primary circuit builder.

It is not advised to call this function directly. Instead you should call BaseCircuitBuilder::range_chip.

Trait Implementations

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

fn clone(&self) -> RangeChip<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 RangeChip<F>

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

Formats the value using the given formatter.

impl<F: ScalarField> RangeInstructions<F> for RangeChip<F>

fn gate(&self) -> &Self::Gate

The type of Gate used in this chip.

fn lookup_bits(&self) -> usize

Returns the number of bits represented in the lookup table [0,2^lookup_bits).

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

Checks and constrains that a lies in the range [0, 2^range_bits).

This is done by decomposing a into num_limbs limbs, where num_limbs = ceil(range_bits / lookup_bits). Each limb is constrained to be within the range [0, 2^lookup_bits). The limbs are then combined to form a again with the last limb having rem_bits number of bits.

Inputs:

• a: AssignedValue value to be range checked
• range_bits: number of bits in the range

Assumptions

• ceil(range_bits / lookup_bits) * lookup_bits <= F::CAPACITY

fn check_less_than( &self, ctx: &mut Context<F>, a: impl Into<QuantumCell<F>>, b: impl Into<QuantumCell<F>>, num_bits: usize, )

Constrains that ‘a’ is less than ‘b’.

Assumes thata and b are known to have <= num_bits bits.

Note: This may fail silently if a or b have more than num_bits

• a: QuantumCell value to check
• b: upper bound expressed as a QuantumCell
• num_bits: number of bits to represent the values

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

Constrains whether a is in [0, b), and returns 1 if a < b, otherwise 0.

• a: first QuantumCell to compare
• b: second QuantumCell to compare
• num_bits: number of bits to represent the values

Assumptions

• a and b are known to have <= num_bits bits.
• (ceil(num_bits / lookup_bits) + 1) * lookup_bits <= F::CAPACITY

type Gate = GateChip<F>

The type of Gate used within the instructions.

fn check_less_than_safe( &self, ctx: &mut Context<F>, a: AssignedValue<F>, b: u64, )

Performs a range check that a has at most ceil(b.bits() / lookup_bits) * lookup_bits bits and then constrains that a is less than b.

fn check_big_less_than_safe( &self, ctx: &mut Context<F>, a: AssignedValue<F>, b: BigUint, )

where F: BigPrimeField,

Performs a range check that a has at most ceil(b.bits() / lookup_bits) * lookup_bits bits and then constrains that a is less than b.

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

Performs a range check that a has at most ceil(bit_length(b) / lookup_bits) * lookup_bits and then returns whether a is in [0,b).

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

where F: BigPrimeField,

Performs a range check that a has at most ceil(b.bits() / lookup_bits) * lookup_bits bits and then returns whether a is in [0,b).

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

where F: BigPrimeField,

Constrains and returns (c, r) such that a = b * c + r.

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

where F: BigPrimeField,

Constrains and returns (c, r) such that a = b * c + r.

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

Constrains and returns the last bit of the value of a.