Struct BinaryChallenger 

pub struct BinaryChallenger<F, Inner> { /* private fields */ }

A challenger for a binary tower field, driven by a challenger over bytes.

A tower level is a whole number of bytes wide, and every bit pattern is an element.

A transcript over the field is therefore a transcript over its bytes. Nothing is encoded, decoded or rejection-sampled in either direction.

Observing: absorbs the little-endian bytes of the element into the inner challenger.

Sampling: reads the little-endian bytes of the element from the inner challenger. Since the field has exactly 2^(8·NUM_BYTES) elements, uniform bytes give a uniform field element.

Proof of work: unlike the field and bit sampling above, which work at every level, grinding is only viable in the wider ones. GrindingChallenger::grind enumerates candidates with a 64-bit counter and demands GRIND_MARGIN_BITS of headroom below that space, which puts a ceiling of min(F::bits(), 64) − GRIND_MARGIN_BITS on the width of a single request:

witness field	largest supported bits
BinaryField2, BinaryField4, BinaryField8	none: every nonzero request panics
BinaryField16	8
BinaryField32	24
BinaryField64	56
BinaryField128	56, bounded by the counter rather than the field

So the levels below GF(2^32) implement GrindingChallenger without being usable proof-of-work witness types, and a 128-bit witness buys no more width than a 64-bit one.

Implementations

impl<F, Inner> BinaryChallenger<F, Inner>

pub const fn new(inner: Inner) -> Self

Wrap a challenger over bytes.

impl<F, H> BinaryChallenger<F, HashChallenger<u8, H, 32>>

where H: CryptographicHasher<u8, [u8; 32]>,

pub const fn from_hasher(initial_state: Vec<u8>, hasher: H) -> Self

Wrap a fresh HashChallenger over the given hasher and initial transcript.

Trait Implementations

impl<F, G, const N: usize, Inner: CanObserve<u8>> CanObserve<&MerkleCap<G, [u8; N]>> for BinaryChallenger<F, Inner>

fn observe(&mut self, cap: &MerkleCap<G, [u8; 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, G, const N: usize, Inner: CanObserve<u8>> CanObserve<&MerkleCap<G, [u64; N]>> for BinaryChallenger<F, Inner>

fn observe(&mut self, cap: &MerkleCap<G, [u64; 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: TowerLevel, Inner: CanObserve<u8>> CanObserve<F> for BinaryChallenger<F, Inner>

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, G, const N: usize, Inner: CanObserve<u8>> CanObserve<Hash<G, u8, N>> for BinaryChallenger<F, Inner>

fn observe(&mut self, values: Hash<G, u8, 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, G, const N: usize, Inner: CanObserve<u8>> CanObserve<Hash<G, u64, N>> for BinaryChallenger<F, Inner>

Word digests are absorbed as the little-endian bytes of each word, in order.

The digest’s own field is free of this challenger’s, as it is for a byte digest. A commitment over one level can then be bound into a transcript over another.

fn observe(&mut self, values: Hash<G, u64, 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, G, const N: usize, Inner: CanObserve<u8>> CanObserve<MerkleCap<G, [u8; N]>> for BinaryChallenger<F, Inner>

fn observe(&mut self, cap: MerkleCap<G, [u8; 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, G, const N: usize, Inner: CanObserve<u8>> CanObserve<MerkleCap<G, [u64; N]>> for BinaryChallenger<F, Inner>

fn observe(&mut self, cap: MerkleCap<G, [u64; 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, EF, Inner> CanSample<EF> for BinaryChallenger<F, Inner>

where F: TowerLevel, EF: BasedVectorSpace<F>, Inner: CanSample<u8>,

fn sample(&mut self) -> EF

Sample a single challenge value from the transcript.

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

Fill an existing buffer with consecutive samples.

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, Inner> CanSampleBits<usize> for BinaryChallenger<F, Inner>

where F: TowerLevel, Inner: CanSample<u8>,

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

Sample a bitstring by masking bytes taken from the inner stream.

A challenger that bit-decomposes a sampled field element can only extract as many bits as that element carries, and so has to bound the request by the field order. This one instead reads its entropy straight off the inner byte stream, so how many bits are available per call does not depend on F’s width at all: a challenger over a narrow level can still draw a query index far wider than one of its own elements.

The one real bound is that the result must fit in a usize, which also keeps it within the u64 the bytes are read into.

impl<F, Inner> CanSampleUniformBits<F> for BinaryChallenger<F, Inner>

where F: TowerLevel, Inner: CanSample<u8>,

fn sample_uniform_bits<const RESAMPLE: bool>( &mut self, bits: usize, ) -> Result<usize, ResamplingError>

Sample uniform bits by masking bytes from the inner stream.

Overview

The inner stream emits cryptographic-hash bytes uniform on [0, 2^8).

Reading 8 bytes as a 64-bit integer and masking the low bits is exactly uniform on [0, 2^bits).

No field-element decomposition occurs, so no rejection band exists. The const generic is therefore inert: this function never errors and never resamples.

impl<F: Clone, Inner: Clone> Clone for BinaryChallenger<F, Inner>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug, Inner: Debug> Debug for BinaryChallenger<F, Inner>

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

Formats the value using the given formatter.

impl<F, Inner> FieldChallenger<F> for BinaryChallenger<F, Inner>

where F: TowerLevel, Inner: CanSample<u8> + CanObserve<u8> + Clone + Send + Sync,

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

where A: BasedVectorSpace<F>,

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

fn observe_algebra_slice<A>(&mut self, alg_elems: &[A])

where A: BasedVectorSpace<F> + Clone,

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

fn sample_algebra_element<A>(&mut self) -> A

where A: BasedVectorSpace<F>,

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, Inner> GrindingChallenger for BinaryChallenger<F, Inner>

where F: TowerLevel, Inner: CanSample<u8> + CanObserve<u8> + Clone + Send + Sync,

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

Panics

Panics unless bits + GRIND_MARGIN_BITS <= min(F::bits(), 64). See the per-level ceiling tabulated on BinaryChallenger.

type Witness = F

The underlying field element type used as the witness.

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

Check whether a given witness satisfies the PoW condition.