Struct halo2_base::gates::range::RangeChip

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

A chip that implements RangeInstructions which provides methods to constrain a field element x is within a range of bits.

Fields

gate: GateChip<F>

Underlying GateChip for this chip.

lookup_bits: usize

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

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 new(strategy: RangeStrategy, lookup_bits: usize) -> Self

Creates a new RangeChip with the given strategy and lookup_bits.

• strategy: GateStrategy for advice values in this chip
• lookup_bits: number of bits represented in the lookup table [0,2^lookup_bits)

pub fn default(lookup_bits: usize) -> Self

Creates a new RangeChip with the default strategy and provided lookup_bits.

• lookup_bits: number of bits represented in the lookup table [0,2^lookup_bits)

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

Returns the GateStrategy for this range.

fn lookup_bits(&self) -> usize

Defines 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 k limbs, where k = 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.

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

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 bit_length(b) 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 bit_length(b) 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 constrains that 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 constrains that 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.