Trait halo2_ecc::fields::FieldChip

source · [−]
pub trait FieldChip<F: PrimeField>: 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;

Show 30 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::UnsafeFieldPoint>,
        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>
    );

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

}
Expand description

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 Types

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

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)

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.

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

Required Associated Constants

Required Methods

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

Assigns fe as constant.

output: a + c

a * c

a * c + b

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

Provided Methods

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

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

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

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.

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

Implementors