Struct MultiField32Challenger 

pub struct MultiField32Challenger<F, PF, P, const WIDTH: usize, const RATE: usize>
where
    F: PrimeField32,
    PF: Field,
    P: CryptographicPermutation<[PF; WIDTH]>,
{ /* private fields */ }

A challenger that operates natively on PF but produces challenges of F: PrimeField32.

Used for optimizing the cost of recursive proof verification of STARKs in SNARKs.

SAFETY: There are some bias complications with using this challenger. In particular, samples are actually random in [0, 2^64) and then reduced to be in F.

Implementations

impl<F, PF, P, const WIDTH: usize, const RATE: usize> MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: Field, P: CryptographicPermutation<[PF; WIDTH]>,

pub fn new(permutation: P) -> Result<Self, String>

Trait Implementations

impl<F, PF, const N: usize, P, const WIDTH: usize, const RATE: usize> CanObserve<[F; N]> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn observe(&mut self, values: [F; N])

Absorb a single value into the transcript.

fn observe_slice(&mut self, values: &[T])

where T: Clone,

Absorb a slice of values into the transcript.

impl<F, PF, P, const WIDTH: usize, const RATE: usize> CanObserve<F> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn observe(&mut self, value: F)

Absorb a single value into the transcript.

fn observe_slice(&mut self, values: &[T])

where T: Clone,

Absorb a slice of values into the transcript.

impl<F, PF, const N: usize, P, const WIDTH: usize, const RATE: usize> CanObserve<Hash<F, PF, N>> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn observe(&mut self, values: Hash<F, PF, N>)

Absorb a single value into the transcript.

fn observe_slice(&mut self, values: &[T])

where T: Clone,

Absorb a slice of values into the transcript.

impl<F, PF, P, const WIDTH: usize, const RATE: usize> CanObserve<Vec<Vec<F>>> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn observe(&mut self, valuess: Vec<Vec<F>>)

Absorb a single value into the transcript.

fn observe_slice(&mut self, values: &[T])

where T: Clone,

Absorb a slice of values into the transcript.

impl<F, EF, PF, P, const WIDTH: usize, const RATE: usize> CanSample<EF> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, EF: BasedVectorSpace<F>, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn sample(&mut self) -> EF

Sample a single challenge value from the transcript.

fn sample_array<const N: usize>(&mut self) -> [T; N]

Sample an array of N challenge values from the transcript.

fn sample_vec(&mut self, n: usize) -> Vec<T>

Sample a Vec of n challenge values from the transcript.

impl<F, PF, P, const WIDTH: usize, const RATE: usize> CanSampleBits<usize> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn sample_bits(&mut self, bits: usize) -> usize

The sampled bits are not perfectly uniform, but we can bound the error: every sequence appears with probability 1/p-close to uniform (1/2^b).

Proof: We denote p = F::ORDER_U32, and b = bits. If X follows a uniform distribution over F, if we consider the first b bits of X, each sequence appears either with probability P1 = ⌊p / 2^b⌋ / p or P2 = (1 + ⌊p / 2^b⌋) / p. We have 1/2^b - 1/p ≤ P1, P2 ≤ 1/2^b + 1/p

impl<F, PF, P, const WIDTH: usize, const RATE: usize> Clone for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32 + Clone, PF: Field + Clone, P: CryptographicPermutation<[PF; WIDTH]> + Clone,

fn clone(&self) -> MultiField32Challenger<F, PF, P, WIDTH, RATE>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F, PF, P, const WIDTH: usize, const RATE: usize> Debug for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32 + Debug, PF: Field + Debug, P: CryptographicPermutation<[PF; WIDTH]> + Debug,

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

Formats the value using the given formatter.

impl<F, PF, P, const WIDTH: usize, const RATE: usize> FieldChallenger<F> for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

fn observe_algebra_element<A: BasedVectorSpace<F>>(&mut self, alg_elem: A)

Absorb an element from a vector space over the base field.

fn observe_algebra_slice<A: BasedVectorSpace<F> + Clone>( &mut self, alg_elems: &[A], )

Absorb a slice of elements from a vector space over the base field.

fn sample_algebra_element<A: BasedVectorSpace<F>>(&mut self) -> A

Sample an element of a vector space over the base field.

fn observe_base_as_algebra_element<EF>(&mut self, val: F)

where EF: Algebra<F> + BasedVectorSpace<F>,

Observe base field elements as extension field elements for recursion-friendly transcripts.

impl<F, PF, P, const WIDTH: usize, const RATE: usize> GrindingChallenger for MultiField32Challenger<F, PF, P, WIDTH, RATE>

where F: PrimeField32, PF: PrimeField, P: CryptographicPermutation<[PF; WIDTH]>,

type Witness = F

The underlying field element type used as the witness.

fn grind(&mut self, bits: usize) -> Self::Witness

Perform a brute-force search to find a valid PoW witness.

fn check_witness(&mut self, bits: usize, witness: Self::Witness) -> bool

Check whether a given witness satisfies the PoW condition.