Trait FieldChip

pub trait FieldChip<F: BigPrimeField>:
    Clone
    + Send
    + Sync {
    type UnsafeFieldPoint: Clone + Debug + Send + Sync + From<Self::FieldPoint> + for<'a> From<&'a Self::UnsafeFieldPoint> + for<'a> From<&'a Self::FieldPoint>;
    type FieldPoint: Clone + Debug + Send + Sync + From<Self::ReducedFieldPoint> + for<'a> From<&'a Self::FieldPoint>;
    type ReducedFieldPoint: Clone + Debug + Send + Sync;
    type FieldType: Field;
    type RangeChip: RangeInstructions<F>;

    const PRIME_FIELD_NUM_BITS: u32;

    // Required methods
    fn native_modulus(&self) -> &BigUint;
    fn range(&self) -> &Self::RangeChip;
    fn limb_bits(&self) -> usize;
    fn get_assigned_value(&self, x: &Self::UnsafeFieldPoint) -> Self::FieldType;
    fn load_private(
        &self,
        ctx: &mut Context<F>,
        fe: Self::FieldType,
    ) -> Self::FieldPoint;
    fn load_constant(
        &self,
        ctx: &mut Context<F>,
        fe: Self::FieldType,
    ) -> Self::FieldPoint;
    fn add_no_carry(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
    ) -> Self::UnsafeFieldPoint;
    fn add_constant_no_carry(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        c: Self::FieldType,
    ) -> Self::UnsafeFieldPoint;
    fn sub_no_carry(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
    ) -> Self::UnsafeFieldPoint;
    fn negate(
        &self,
        ctx: &mut Context<F>,
        a: Self::FieldPoint,
    ) -> Self::FieldPoint;
    fn scalar_mul_no_carry(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        c: i64,
    ) -> Self::UnsafeFieldPoint;
    fn scalar_mul_and_add_no_carry(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
        c: i64,
    ) -> Self::UnsafeFieldPoint;
    fn mul_no_carry(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
    ) -> Self::UnsafeFieldPoint;
    fn check_carry_mod_to_zero(
        &self,
        ctx: &mut Context<F>,
        a: Self::UnsafeFieldPoint,
    );
    fn carry_mod(
        &self,
        ctx: &mut Context<F>,
        a: Self::UnsafeFieldPoint,
    ) -> Self::FieldPoint;
    fn range_check(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
        max_bits: usize,
    );
    fn enforce_less_than(
        &self,
        ctx: &mut Context<F>,
        a: Self::FieldPoint,
    ) -> Self::ReducedFieldPoint;
    fn is_soft_zero(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
    ) -> AssignedValue<F>;
    fn is_soft_nonzero(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
    ) -> AssignedValue<F>;
    fn is_zero(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
    ) -> AssignedValue<F>;
    fn is_equal_unenforced(
        &self,
        ctx: &mut Context<F>,
        a: Self::ReducedFieldPoint,
        b: Self::ReducedFieldPoint,
    ) -> AssignedValue<F>;
    fn assert_equal(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
        b: impl Into<Self::FieldPoint>,
    );

    // Provided methods
    fn gate(&self) -> &<Self::RangeChip as RangeInstructions<F>>::Gate { ... }
    fn load_private_reduced(
        &self,
        ctx: &mut Context<F>,
        fe: Self::FieldType,
    ) -> Self::ReducedFieldPoint { ... }
    fn is_equal(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
        b: impl Into<Self::FieldPoint>,
    ) -> AssignedValue<F> { ... }
    fn mul(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
    ) -> Self::FieldPoint { ... }
    fn divide(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
        b: impl Into<Self::FieldPoint>,
    ) -> Self::FieldPoint { ... }
    fn divide_unsafe(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
    ) -> Self::FieldPoint { ... }
    fn neg_divide(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::FieldPoint>,
        b: impl Into<Self::FieldPoint>,
    ) -> Self::FieldPoint { ... }
    fn neg_divide_unsafe(
        &self,
        ctx: &mut Context<F>,
        a: impl Into<Self::UnsafeFieldPoint>,
        b: impl Into<Self::UnsafeFieldPoint>,
    ) -> Self::FieldPoint { ... }
}

Trait for common functionality for finite field chips. Primarily intended to emulate a “non-native” finite field using “native” values in a prime field F. Most functions are designed for the case when the non-native field is larger than the native field, but the trait can still be implemented and used in other cases.

Required Associated Constants

const PRIME_FIELD_NUM_BITS: u32

Required Associated Types

type UnsafeFieldPoint: Clone + Debug + Send + Sync + From<Self::FieldPoint> + for<'a> From<&'a Self::UnsafeFieldPoint> + for<'a> From<&'a Self::FieldPoint>

A representation of a field element that is used for intermediate computations. The representation can have “overflows” (e.g., overflow limbs or negative limbs).

type FieldPoint: Clone + Debug + Send + Sync + From<Self::ReducedFieldPoint> + for<'a> From<&'a Self::FieldPoint>

The “proper” representation of a field element. Allowed to be a non-unique representation of a field element (e.g., can be greater than modulus)

type ReducedFieldPoint: Clone + Debug + Send + Sync

A proper representation of field elements that guarantees a unique representation of each field element. Typically this means Uints that are less than the modulus.

type FieldType: Field

A type implementing Field trait to help with witness generation (for example with inverse)

type RangeChip: RangeInstructions<F>

Required Methods

fn native_modulus(&self) -> &BigUint

fn range(&self) -> &Self::RangeChip

fn limb_bits(&self) -> usize

fn get_assigned_value(&self, x: &Self::UnsafeFieldPoint) -> Self::FieldType

fn load_private( &self, ctx: &mut Context<F>, fe: Self::FieldType, ) -> Self::FieldPoint

Assigns fe as private witness. Note that the witness may not be constrained to be a unique representation of the field element fe.

fn load_constant( &self, ctx: &mut Context<F>, fe: Self::FieldType, ) -> Self::FieldPoint

Assigns fe as constant.

fn add_no_carry( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, ) -> Self::UnsafeFieldPoint

fn add_constant_no_carry( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, c: Self::FieldType, ) -> Self::UnsafeFieldPoint

output: a + c

fn sub_no_carry( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, ) -> Self::UnsafeFieldPoint

fn negate(&self, ctx: &mut Context<F>, a: Self::FieldPoint) -> Self::FieldPoint

fn scalar_mul_no_carry( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, c: i64, ) -> Self::UnsafeFieldPoint

a * c

fn scalar_mul_and_add_no_carry( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, c: i64, ) -> Self::UnsafeFieldPoint

a * c + b

fn mul_no_carry( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, ) -> Self::UnsafeFieldPoint

fn check_carry_mod_to_zero( &self, ctx: &mut Context<F>, a: Self::UnsafeFieldPoint, )

fn carry_mod( &self, ctx: &mut Context<F>, a: Self::UnsafeFieldPoint, ) -> Self::FieldPoint

fn range_check( &self, ctx: &mut Context<F>, a: impl Into<Self::FieldPoint>, max_bits: usize, )

fn enforce_less_than( &self, ctx: &mut Context<F>, a: Self::FieldPoint, ) -> Self::ReducedFieldPoint

Constrains that a is a reduced representation and returns the wrapped a.

fn is_soft_zero( &self, ctx: &mut Context<F>, a: impl Into<Self::FieldPoint>, ) -> AssignedValue<F>

fn is_soft_nonzero( &self, ctx: &mut Context<F>, a: impl Into<Self::FieldPoint>, ) -> AssignedValue<F>

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

fn is_equal_unenforced( &self, ctx: &mut Context<F>, a: Self::ReducedFieldPoint, b: Self::ReducedFieldPoint, ) -> AssignedValue<F>

fn assert_equal( &self, ctx: &mut Context<F>, a: impl Into<Self::FieldPoint>, b: impl Into<Self::FieldPoint>, )

Provided Methods

fn gate(&self) -> &<Self::RangeChip as RangeInstructions<F>>::Gate

fn load_private_reduced( &self, ctx: &mut Context<F>, fe: Self::FieldType, ) -> Self::ReducedFieldPoint

Assigns fe as private witness and contrains the witness to be in reduced form.

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

fn mul( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, ) -> Self::FieldPoint

If using UnsafeFieldPoint, make sure multiplication does not cause overflow.

fn divide( &self, ctx: &mut Context<F>, a: impl Into<Self::FieldPoint>, b: impl Into<Self::FieldPoint>, ) -> Self::FieldPoint

Constrains that b is nonzero as a field element and then returns a / b.

fn divide_unsafe( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, ) -> Self::FieldPoint

Returns a / b without constraining b to be nonzero.

Warning: undefined behavior when b is zero.

a, b must be such that quot * b - a without carry does not overflow, where quot is the output.

fn neg_divide( &self, ctx: &mut Context<F>, a: impl Into<Self::FieldPoint>, b: impl Into<Self::FieldPoint>, ) -> Self::FieldPoint

Constrains that b is nonzero as a field element and then returns -a / b.

fn neg_divide_unsafe( &self, ctx: &mut Context<F>, a: impl Into<Self::UnsafeFieldPoint>, b: impl Into<Self::UnsafeFieldPoint>, ) -> Self::FieldPoint

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<'a, F, FpChip, Fp2> FieldChip<F> for Fp2Chip<'a, F, FpChip, Fp2>

where F: BigPrimeField, FpChip::FieldType: BigPrimeField, FpChip: PrimeFieldChip<F>, Fp2: Field + FieldExtConstructor<FpChip::FieldType, 2>, FieldVector<FpChip::UnsafeFieldPoint>: From<FieldVector<FpChip::FieldPoint>>, FieldVector<FpChip::FieldPoint>: From<FieldVector<FpChip::ReducedFieldPoint>>,

const PRIME_FIELD_NUM_BITS: u32 = <FpChip::FieldType>::NUM_BITS

type UnsafeFieldPoint = FieldVector<<FpChip as FieldChip<F>>::UnsafeFieldPoint>

type FieldPoint = FieldVector<<FpChip as FieldChip<F>>::FieldPoint>

type ReducedFieldPoint = FieldVector<<FpChip as FieldChip<F>>::ReducedFieldPoint>

type FieldType = Fp2

type RangeChip = <FpChip as FieldChip<F>>::RangeChip

impl<'a, F, FpChip, Fp12, const XI_0: i64> FieldChip<F> for Fp12Chip<'a, F, FpChip, Fp12, XI_0>

where F: BigPrimeField, FpChip: PrimeFieldChip<F>, FpChip::FieldType: BigPrimeField, Fp12: Field + FieldExtConstructor<FpChip::FieldType, 12>, FieldVector<FpChip::UnsafeFieldPoint>: From<FieldVector<FpChip::FieldPoint>>, FieldVector<FpChip::FieldPoint>: From<FieldVector<FpChip::ReducedFieldPoint>>,

const PRIME_FIELD_NUM_BITS: u32 = <FpChip::FieldType>::NUM_BITS

type UnsafeFieldPoint = FieldVector<<FpChip as FieldChip<F>>::UnsafeFieldPoint>

type FieldPoint = FieldVector<<FpChip as FieldChip<F>>::FieldPoint>

type ReducedFieldPoint = FieldVector<<FpChip as FieldChip<F>>::ReducedFieldPoint>

type FieldType = Fp12

type RangeChip = <FpChip as FieldChip<F>>::RangeChip

impl<'range, F: BigPrimeField, Fp: BigPrimeField> FieldChip<F> for FpChip<'range, F, Fp>

const PRIME_FIELD_NUM_BITS: u32 = Fp::NUM_BITS

type UnsafeFieldPoint = CRTInteger<F>

type FieldPoint = ProperCrtUint<F>

type ReducedFieldPoint = Reduced<ProperCrtUint<F>, Fp>

type FieldType = Fp

type RangeChip = RangeChip<F>