Trait ark_r1cs_std::fields::FieldVar

pub trait FieldVar<F: Field, ConstraintF: Field>: 'static + Clone + From<Boolean<ConstraintF>> + R1CSVar<ConstraintF, Value = F> + EqGadget<ConstraintF> + ToBitsGadget<ConstraintF> + AllocVar<F, ConstraintF> + ToBytesGadget<ConstraintF> + CondSelectGadget<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 {
    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>;

    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.

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<TargetField: PrimeField, BaseField: PrimeField> FieldVar<TargetField, BaseField> for NonNativeFieldVar<TargetField, BaseField>