Struct DenseMle 

pub struct DenseMle<F: Field> {
    pub layer_id: LayerId,
    pub mle: MultilinearExtension<F>,
    pub mle_indices: Vec<MleIndex<F>>,
}

An implementation of an Mle using a dense representation.

Fields

layer_id: LayerId

The ID of the layer this data belongs to.

mle: MultilinearExtension<F>

A representation of the MLE on its current state.

mle_indices: Vec<MleIndex<F>>

The MleIndices current_mle.

Implementations

impl<F: Field> DenseMle<F>

pub fn new_with_prefix_bits( data: MultilinearExtension<F>, layer_id: LayerId, prefix_bits: Vec<bool>, ) -> Self

Constructs a new DenseMle with specified prefix_bits todo: change this to create a DenseMle with already specified IndexedBits

pub fn new_with_indices( data: &[F], layer_id: LayerId, mle_indices: &[MleIndex<F>], ) -> Self

Constructs a new DenseMle with specified MLE indices, normally when we are trying to construct a new MLE based off of a previous MLE, such as in crate::layer::matmult::MatMult, but want to preserve the “prefix vars.”

The MLE should not have ever been mutated if this function is ever called, so none of the indices should ever be Indexed here.

pub fn new_from_iter(iter: impl Iterator<Item = F>, layer_id: LayerId) -> Self

Constructs a new DenseMle from a bookkeeping table represented by Iterator<Item = F> and LayerId.

Example

    use remainder::layer::LayerId;
    use shared_types::Fr;
    use remainder::mle::dense::DenseMle;

    DenseMle::<Fr>::new_from_iter(vec![Fr::one()].into_iter(), LayerId::Input(0));

pub fn new_from_raw(items: Vec<F>, layer_id: LayerId) -> Self

Constructs a new DenseMle from a bookkeeping table represented by Vec<F> and LayerId.

Example

    use remainder::layer::LayerId;
    use shared_types::Fr;
    use remainder::mle::dense::DenseMle;

    DenseMle::<Fr>::new_from_raw(vec![Fr::one()], LayerId::Input(0));

pub fn new_from_multilinear_extension( mle: MultilinearExtension<F>, layer_id: LayerId, prefix_vars: Option<Vec<bool>>, maybe_starting_var_index: Option<usize>, ) -> Self

Constructs a new DenseMle from a MultilinearExtension, additionally being able to specify the prefix vars and layer ID.

Optionally gives back an indexed DenseMle.

pub fn combine_mles(mles: Vec<DenseMle<F>>) -> DenseMle<F>

Merges the MLEs into a single MLE by simply concatenating them.

pub fn expression(self) -> Expression<F, ProverExpr>

Creates an expression from the current MLE.

pub fn get_bound_point(&self) -> Vec<F>

Returns the evaluation challenges for a fully-bound MLE.

Note that this function panics if a particular challenge is neither fixed nor bound!

Trait Implementations

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

fn clone(&self) -> DenseMle<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 DenseMle<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for DenseMle<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: Field> From<DenseMle<F>> for MleEnum<F>

fn from(value: DenseMle<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<DenseMle<F>> for OutputLayer<F>

Required for output layer shenanigans within layout

fn from(value: DenseMle<F>) -> Self

Converts to this type from the input type.

impl<F: Field> IntoIterator for DenseMle<F>

type Item = F

The type of the elements being iterated over.

type IntoIter = IntoIter<<DenseMle<F> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<F: Field> Mle<F> for DenseMle<F>

fn fix_variable(&mut self, index: usize, binding: F) -> Option<RawClaim<F>>

Bind the bit index to the value binding. If this was the last unbound variable, then return a Claim object giving the fully specified evaluation point and the (single) value of the bookkeeping table. Otherwise, return None.

fn num_free_vars(&self) -> usize

Returns the number of free variables this Mle is defined on. Equivalently, this is the log_2 of the size of the unpruned bookkeeping table.

fn get_padded_evaluations(&self) -> Vec<F>

Get the padded set of evaluations over the boolean hypercube; useful for constructing the input layer.

fn add_prefix_bits(&mut self, new_bits: Vec<MleIndex<F>>)

Mutates the MLE in order to set the prefix bits. This is needed when we are working with dataparallel circuits and new bits need to be added.

fn layer_id(&self) -> LayerId

Get the layer ID of the associated MLE.

fn len(&self) -> usize

Returns the length of the current bookkeeping table.

fn iter(&self) -> EvaluationsIterator<'_, F>

Returns an iterator over the evaluations of the current MLE.

fn mle_indices(&self) -> &[MleIndex<F>]

Get the indicies of the Mle that this MleRef represents.

fn fix_variable_at_index( &mut self, indexed_bit_index: usize, point: F, ) -> Option<RawClaim<F>>

Fix the (indexed) free variable at indexed_bit_index with a given challenge point. Mutates `self`` to be the bookeeping table for the new MLE. If the new MLE becomes fully bound, returns the evaluation of the fully bound MLE in the form of a crate::claims::RawClaim.

fn index_mle_indices(&mut self, curr_index: usize) -> usize

Mutates the MleIndexes stored in self that are MleIndex::Free and turns them into MleIndex::Indexed with the bit index being determined from curr_index. Returns the (curr_index + number of IndexedBits now in the MleIndices).

fn get_enum(self) -> MleEnum<F>

Get the associated enum that this MLE is a part of (MleEnum::Dense or MleEnum::Zero).

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

Returns the first element of the evaluations table (if any).

fn first(&self) -> F

Returns the first element in the bookkeeping table corresponding to the value of this Dense MLE when all free variables are set to zero. This operations never panics (see evals::MultilinearExtension::first)

fn value(&self) -> F

If this is a fully-bound Dense MLE, it returns its value. Otherwise panics.

fn is_fully_bounded(&self) -> bool

An MLE is fully bounded if it has no more free variables.

impl<F: PartialEq + Field> PartialEq for DenseMle<F>

fn eq(&self, other: &DenseMle<F>) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F> Serialize for DenseMle<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.

impl<F: Field> StructuralPartialEq for DenseMle<F>