Enum snarkvm_gadgets::bits::boolean::Boolean

pub enum Boolean {
    Is(AllocatedBit),
    Not(AllocatedBit),
    Constant(bool),
}

This is a boolean value which may be either a constant or an interpretation of an AllocatedBit.

Variants

Is(AllocatedBit)

Existential view of the boolean variable

Not(AllocatedBit)

Negated view of the boolean variable

Constant(bool)

Constant (not an allocated variable)

Implementations

impl Boolean

pub fn get_value(&self) -> Option<bool>

pub fn lc<F: Field>(&self, one: Variable, coeff: F) -> LinearCombination<F>

pub fn constant_u8_vec<F: Field, CS: ConstraintSystem<F>>(
    cs: &mut CS,
    values: &[u8]
) -> Vec<Self>

Construct a boolean vector from a vector of u8

pub fn constant(b: bool) -> Self

Construct a boolean from a known constant.

pub fn not(&self) -> Self

Return a negated interpretation of this boolean.

pub fn or<'a, F, CS>(
    cs: CS,
    a: &'a Self,
    b: &'a Self
) -> Result<Self, SynthesisError> where
    F: Field,
    CS: ConstraintSystem<F>, 

Perform OR over two boolean operands.

pub fn and<'a, F: Field, CS: ConstraintSystem<F>>(
    cs: CS,
    a: &'a Self,
    b: &'a Self
) -> Result<Self, SynthesisError>

Perform AND over two boolean operands.

pub fn kary_and<F, CS>(cs: CS, bits: &[Self]) -> Result<Self, SynthesisError> where
    F: Field,
    CS: ConstraintSystem<F>, 

Perform AND over all the given boolean operands.

pub fn enforce_nand<F, CS>(cs: CS, bits: &[Self]) -> Result<(), SynthesisError> where
    F: Field,
    CS: ConstraintSystem<F>, 

Asserts that at least one operand is false.

pub fn enforce_in_field<F, CS, NativeF: PrimeField>(
    cs: CS,
    bits: &[Self]
) -> Result<(), SynthesisError> where
    F: Field,
    CS: ConstraintSystem<F>, 

Asserts that this bit_gadget representation is “in the field” when interpreted in big endian.

pub fn enforce_in_field_le<F: Field, CS: ConstraintSystem<F>>(
    cs: CS,
    bits: &[Self]
) -> Result<(), SynthesisError>

Enforces that bits, when interpreted as a integer, is less than F::characteristic(), That is, interpret bits as a little-endian integer, and enforce that this integer is “in the field Z_p”, where p = F::characteristic() .

pub fn kary_nand<F: Field, CS: ConstraintSystem<F>>(
    cs: CS,
    bits: &[Self]
) -> Result<Self, SynthesisError>

pub fn enforce_smaller_or_equal_than_le<F: Field, CS: ConstraintSystem<F>>(
    cs: CS,
    bits: &[Self],
    element: impl AsRef<[u64]>
) -> Result<Vec<Self>, SynthesisError>

pub fn enforce_smaller_or_equal_than_be<F: Field, CS: ConstraintSystem<F>>(
    cs: CS,
    bits: &[Self],
    element: impl AsRef<[u64]>
) -> Result<Vec<Self>, SynthesisError>

pub fn le_bits_to_fp_var<CS: ConstraintSystem<F>, F: PrimeField>(
    cs: CS,
    bits: &[Self]
) -> Result<FpGadget<F>, SynthesisError>

Convert a little-endian bitwise representation of a field element to FpGadget<F>

Trait Implementations

impl<F: Field> AllocGadget<bool, F> for Boolean

fn alloc_constant<Fn, T, CS: ConstraintSystem<F>>(
    _cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

fn alloc<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

fn alloc_input<Fn, T, CS: ConstraintSystem<F>>(
    cs: CS,
    value_gen: Fn
) -> Result<Self, SynthesisError> where
    Fn: FnOnce() -> Result<T, SynthesisError>,
    T: Borrow<bool>, 

fn alloc_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

fn alloc_input_checked<Fn: FnOnce() -> Result<T, SynthesisError>, T: Borrow<V>, CS: ConstraintSystem<F>>(
    cs: CS,
    f: Fn
) -> Result<Self, SynthesisError>

impl Clone for Boolean

fn clone(&self) -> Boolean

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<F: PrimeField> CondSelectGadget<F> for Boolean

fn conditionally_select<CS>(
    cs: CS,
    cond: &Self,
    first: &Self,
    second: &Self
) -> Result<Self, SynthesisError> where
    CS: ConstraintSystem<F>, 

fn cost() -> usize

impl<F: Field> ConditionalEqGadget<F> for Boolean

fn conditional_enforce_equal<CS: ConstraintSystem<F>>(
    &self,
    cs: CS,
    other: &Self,
    condition: &Boolean
) -> Result<(), SynthesisError>

fn cost() -> usize

impl Debug for Boolean

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<F: Field> EqGadget<F> for Boolean

fn is_eq<CS: ConstraintSystem<F>>(
    &self,
    cs: CS,
    other: &Self
) -> Result<Boolean, SynthesisError>

Output a Boolean value representing whether self.value() == other.value().

fn enforce_equal<CS: ConstraintSystem<F>>(
    &self,
    cs: CS,
    other: &Self
) -> Result<(), SynthesisError>

fn cost() -> usize

impl<F: PrimeField> EvaluateEqGadget<F> for Boolean

a == b = !(a XOR b)

fn evaluate_equal<CS: ConstraintSystem<F>>(
    &self,
    cs: CS,
    other: &Self
) -> Result<Boolean, SynthesisError>

impl From<AllocatedBit> for Boolean

fn from(b: AllocatedBit) -> Boolean

Performs the conversion.

impl<'a, F: Field> FullAdder<'a, F> for Boolean

fn add<CS: ConstraintSystem<F>>(
    cs: CS,
    a: &'a Self,
    b: &'a Self,
    carry: &'a Self
) -> Result<(Self, Self), SynthesisError>

impl PartialEq<Boolean> for Boolean

fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl SignExtend for Boolean

fn sign_extend(bits: &[Boolean], length: usize) -> Vec<Boolean>

impl<F: Field> ToBitsBEGadget<F> for Boolean

fn to_bits_be<CS: ConstraintSystem<F>>(
    &self,
    _: CS
) -> Result<Vec<Boolean>, SynthesisError>

fn to_bits_be_strict<CS: ConstraintSystem<F>>(
    &self,
    _: CS
) -> Result<Vec<Boolean>, SynthesisError>

Additionally checks if the produced list of booleans is ‘valid’.

impl<F: Field> ToBitsLEGadget<F> for Boolean

fn to_bits_le<CS: ConstraintSystem<F>>(
    &self,
    _: CS
) -> Result<Vec<Boolean>, SynthesisError>

fn to_bits_le_strict<CS: ConstraintSystem<F>>(
    &self,
    _: CS
) -> Result<Vec<Boolean>, SynthesisError>

Additionally checks if the produced list of booleans is ‘valid’.

impl<F: Field> ToBytesGadget<F> for Boolean

fn to_bytes_strict<CS: ConstraintSystem<F>>(
    &self,
    cs: CS
) -> Result<Vec<UInt8>, SynthesisError>

Additionally checks if the produced list of booleans is ‘valid’.

fn to_bytes<CS: ConstraintSystem<F>>(
    &self,
    _cs: CS
) -> Result<Vec<UInt8>, SynthesisError>

impl<F: PrimeField> ToConstraintFieldGadget<F> for Boolean

fn to_constraint_field<CS: ConstraintSystem<F>>(
    &self,
    cs: CS
) -> Result<Vec<FpGadget<F>>, SynthesisError>

Converts self to FpGadget<F> variables.

impl<F: Field> Xor<F, Boolean> for Boolean

fn xor<CS: ConstraintSystem<F>>(
    &self,
    cs: CS,
    other: &Self
) -> Result<Self, SynthesisError>

impl Copy for Boolean

impl Eq for Boolean