Trait FieldVar

pub trait FieldVar<F: Field, ConstraintF: PrimeField>:
    'static
    + Clone
    + From<Boolean<ConstraintF>>
    + R1CSVar<ConstraintF, Value = F>
    + EqGadget<ConstraintF>
    + ToBitsGadget<ConstraintF>
    + AllocVar<F, ConstraintF>
    + ToBytesGadget<ConstraintF>
    + CondSelectGadget<ConstraintF>
    + ToConstraintFieldGadget<ConstraintF>
    + for<'a> FieldOpsBounds<'a, F, Self>
    + for<'a> AddAssign<&'a Self>
    + for<'a> SubAssign<&'a Self>
    + for<'a> MulAssign<&'a Self>
    + AddAssign<Self>
    + SubAssign<Self>
    + MulAssign<Self>
    + AddAssign<F>
    + SubAssign<F>
    + MulAssign<F>
    + Debug {
    // Required methods
    fn zero() -> Self;
    fn one() -> Self;
    fn constant(v: F) -> Self;
    fn negate(&self) -> Result<Self, SynthesisError>;
    fn inverse(&self) -> Result<Self, SynthesisError>;
    fn frobenius_map(&self, power: usize) -> Result<Self, SynthesisError>;

    // Provided methods
    fn is_zero(&self) -> Result<Boolean<ConstraintF>, SynthesisError> { ... }
    fn is_one(&self) -> Result<Boolean<ConstraintF>, SynthesisError> { ... }
    fn double(&self) -> Result<Self, SynthesisError> { ... }
    fn double_in_place(&mut self) -> Result<&mut Self, SynthesisError> { ... }
    fn negate_in_place(&mut self) -> Result<&mut Self, SynthesisError> { ... }
    fn square(&self) -> Result<Self, SynthesisError> { ... }
    fn square_in_place(&mut self) -> Result<&mut Self, SynthesisError> { ... }
    fn mul_equals(
        &self,
        other: &Self,
        result: &Self,
    ) -> Result<(), SynthesisError> { ... }
    fn square_equals(&self, result: &Self) -> Result<(), SynthesisError> { ... }
    fn mul_by_inverse(&self, d: &Self) -> Result<Self, SynthesisError> { ... }
    fn mul_by_inverse_unchecked(&self, d: &Self) -> Result<Self, SynthesisError> { ... }
    fn frobenius_map_in_place(
        &mut self,
        power: usize,
    ) -> Result<&mut Self, SynthesisError> { ... }
    fn pow_le(
        &self,
        bits: &[Boolean<ConstraintF>],
    ) -> Result<Self, SynthesisError> { ... }
    fn pow_by_constant<S: AsRef<[u64]>>(
        &self,
        exp: S,
    ) -> Result<Self, SynthesisError> { ... }
}

A variable representing a field. Corresponds to the native type F.

Required Methods

fn zero() -> Self

Returns the constant F::zero().

fn one() -> Self

Returns the constant F::one().

fn constant(v: F) -> Self

Returns a constant with value v.

This should not allocate any variables.

fn negate(&self) -> Result<Self, SynthesisError>

Coputes -self.

fn inverse(&self) -> Result<Self, SynthesisError>

Computes result such that self * result == Self::one().

fn frobenius_map(&self, power: usize) -> Result<Self, SynthesisError>

Computes the frobenius map over self.

Provided Methods

fn is_zero(&self) -> Result<Boolean<ConstraintF>, SynthesisError>

Returns a Boolean representing whether self == Self::zero().

fn is_one(&self) -> Result<Boolean<ConstraintF>, SynthesisError>

Returns a Boolean representing whether self == Self::one().

fn double(&self) -> Result<Self, SynthesisError>

Computes self + self.

fn double_in_place(&mut self) -> Result<&mut Self, SynthesisError>

Sets self = self + self.

fn negate_in_place(&mut self) -> Result<&mut Self, SynthesisError>

Sets self = -self.

fn square(&self) -> Result<Self, SynthesisError>

Computes self * self.

A default implementation is provided which just invokes the underlying multiplication routine. However, this method should be specialized for extension fields, where faster algorithms exist for squaring.

fn square_in_place(&mut self) -> Result<&mut Self, SynthesisError>

Sets self = self.square().

fn mul_equals(&self, other: &Self, result: &Self) -> Result<(), SynthesisError>

Enforces that self * other == result.

fn square_equals(&self, result: &Self) -> Result<(), SynthesisError>

Enforces that self * self == result.

fn mul_by_inverse(&self, d: &Self) -> Result<Self, SynthesisError>

Returns (self / d). The constraint system will be unsatisfiable when d = 0.

fn mul_by_inverse_unchecked(&self, d: &Self) -> Result<Self, SynthesisError>

Returns (self / d).

The precondition for this method is that d != 0. If d == 0, this method offers no guarantees about the soundness of the resulting constraint system. For example, if self == d == 0, the current implementation allows the constraint system to be trivially satisfiable.

fn frobenius_map_in_place( &mut self, power: usize, ) -> Result<&mut Self, SynthesisError>

Sets self = self.frobenius_map().

fn pow_le(&self, bits: &[Boolean<ConstraintF>]) -> Result<Self, SynthesisError>

Comptues self^bits, where bits is a little-endian bit-wise decomposition of the exponent.

fn pow_by_constant<S: AsRef<[u64]>>( &self, exp: S, ) -> Result<Self, SynthesisError>

Computes self^S, where S is interpreted as an little-endian u64-decomposition of an integer.

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<BF, P> FieldVar<CubicExtField<P>, <P as CubicExtConfig>::BasePrimeField> for CubicExtVar<BF, P>

where BF: FieldVar<P::BaseField, P::BasePrimeField>, for<'a> &'a BF: FieldOpsBounds<'a, P::BaseField, BF>, P: CubicExtVarConfig<BF>,

impl<BF, P> FieldVar<QuadExtField<P>, <P as QuadExtConfig>::BasePrimeField> for QuadExtVar<BF, P>

where BF: FieldVar<P::BaseField, P::BasePrimeField>, for<'a> &'a BF: FieldOpsBounds<'a, P::BaseField, BF>, P: QuadExtVarConfig<BF>,

impl<F: PrimeField> FieldVar<F, F> for FpVar<F>

impl<TargetF: PrimeField, BaseF: PrimeField> FieldVar<TargetF, BaseF> for EmulatedFpVar<TargetF, BaseF>