Struct BetaValues 

pub struct BetaValues<F: Field> {
    pub values: Vec<BetaValueType<F>>,
}

A struct that holds the claim and the relevant bound values for the beta equality MLE. Rather than storing the entire beta table, we simply store the points in the claim that are still “unbound”, and the points that have been bound using the [Thaler13] definition of a beta table.

Beta tables are used to “linearize” an expression that we wish to evaluate over a claimed point (g_0, ..., g_n). Therefore we create an MLE that evaluates to 1 at this point and 0 at every other point, which is a beta table. This would be a table of size 2^n.

Instead, we represent the beta MLE \beta(g_0, ..., g_{n-1}; x_0, ..., x_{n-1}) by mapping each index i that participates in this MLE to either g_i, if x_i has not yet been bound, or to (1 - r_i)*(1 - g_i) + r_i*g_i, if x_i has already been bound to r_i. Indices in the range {0, 1, ..., n-1} which are not part of this MLE are called “unassigned” and they don’t map to any value.

Fields

values: Vec<BetaValueType<F>>

Map from each index to a beta value type

Implementations

impl<F: Field> BetaValues<F>

pub fn new(layer_claim_vars_and_index: Vec<(usize, F)>) -> Self

Constructs a new beta table using a vector of the challenge points in a claim along with it’s corresponding round index as a tuple.

pub fn beta_update(&mut self, round_index: usize, challenge: F)

Updates the given value of beta using a new challenge point. Simply (1 - r_i)*(1 - g_i) + (r_i * g_i) for an index i, previous claim challenge point g_i and current challenge r_i.

We remove it from the unbound hashmap and add it to the bound hashmap.

pub fn get_updated_value(&self, index: usize) -> Option<F>

obtain the value at an index if it is updated do not check for out of bound

pub fn get_unbound_value(&self, index: usize) -> Option<F>

obtain the value at an index if it is unbounded

pub fn is_fully_bounded(&self) -> bool

determine if no entry is unbound

pub fn fold_updated_values(&self) -> F

obtain product of all updated values

pub fn get_relevant_beta_unbound_and_bound( &self, mle_indices: &[MleIndex<F>], round_index: usize, computes_evals: bool, ) -> (Vec<F>, Vec<F>)

Given a vector of mle indices, returns the relevant beta bound and unbound values we need. if the index is Indexed(usize), then we grab the unbound value and if it is Bound(usize, chal) we grab the bound value.

pub fn compute_beta_over_two_challenges( challenge_one: &[F], challenge_two: &[F], ) -> F

Takes two challenge points and computes the fully bound beta equality value.

pub fn compute_beta_over_challenge_and_index(challenge: &[F], idx: usize) -> F

Computes the value of \beta(challenge; b), where b is the binary representation of idx.

pub fn new_beta_equality_mle( layer_claim_vars: Vec<F>, ) -> MultilinearExtension<F>

Returns the full beta equality table as defined in [Thaler13], so over n challenge points it returns a table of size 2^n. This is when we do still need the entire beta table. Essentially this is an MLE whose coefficients represent whether the index is equal to the random challenge point.

Trait Implementations

impl<F: Clone + Field> Clone for BetaValues<F>

fn clone(&self) -> BetaValues<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for BetaValues<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for BetaValues<F>

where F: Field,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F> Serialize for BetaValues<F>

where F: Field,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.