Struct GateLayer 

pub struct GateLayer<F: Field> {
    pub layer_id: LayerId,
    pub num_dataparallel_vars: usize,
    pub nonzero_gates: Vec<(u32, u32, u32)>,
    pub lhs: DenseMle<F>,
    pub rhs: DenseMle<F>,
    pub phase_1_mles: Option<Vec<Vec<DenseMle<F>>>>,
    pub phase_2_mles: Option<Vec<Vec<DenseMle<F>>>>,
    pub gate_operation: BinaryOperation,
    beta_g2_vec: Option<Vec<BetaValues<F>>>,
    g_vec: Option<Vec<Vec<F>>>,
    num_rounds_phase1: usize,
}

Generic gate struct – the binary operation performed by the gate is specified by the gate_operation parameter. Additionally, the number of dataparallel variables is specified by num_dataparallel_vars in order to account for batched and un-batched gates.

Fields

layer_id: LayerId

The layer id associated with this gate layer.

num_dataparallel_vars: usize

The number of bits representing the number of “dataparallel” copies of the circuit.

nonzero_gates: Vec<(u32, u32, u32)>

A vector of tuples representing the “nonzero” gates, especially useful in the sparse case the format is (z, x, y) where the gate at label z is the output of performing an operation on gates with labels x and y.

lhs: DenseMle<F>

The left side of the expression, i.e. the mle that makes up the “x” variables.

rhs: DenseMle<F>

The right side of the expression, i.e. the mle that makes up the “y” variables.

phase_1_mles: Option<Vec<Vec<DenseMle<F>>>>

The mles that are constructed when initializing phase 1 (binding the x variables).

phase_2_mles: Option<Vec<Vec<DenseMle<F>>>>

The mles that are constructed when initializing phase 2 (binding the y variables).

gate_operation: BinaryOperation

The gate operation representing the fan-in-two relationship.

beta_g2_vec: Option<Vec<BetaValues<F>>>

the beta table which enumerates the incoming claim’s challenge points on the dataparallel vars of the MLE

g_vec: Option<Vec<Vec<F>>>

The incoming claim’s challenge points.

num_rounds_phase1: usize

the number of rounds in phase 1

Implementations

impl<F: Field> GateLayer<F>

pub fn new( num_dataparallel_vars: Option<usize>, nonzero_gates: Vec<(u32, u32, u32)>, lhs: DenseMle<F>, rhs: DenseMle<F>, gate_operation: BinaryOperation, layer_id: LayerId, ) -> Self

Construct a new gate layer

Arguments

• num_dataparallel_vars: an optional representing the number of bits representing the circuit copy we are looking at.

None if this is not dataparallel, otherwise specify the number of bits

• nonzero_gates: the gate wiring between single-copy circuit (as the wiring for each circuit remains the same)

x is the label on the batched mle lhs, y is the label on the batched mle rhs, and z is the label on the next layer, batched

• lhs: the flattened mle representing the left side of the summation
• rhs: the flattened mle representing the right side of the summation
• gate_operation: which operation the gate is performing. right now, can either be an ‘add’ or ‘mul’ gate
• layer_id: the id representing which current layer this is

Returns

A Gate struct that can now prove and verify rounds

fn init_phase_1(&mut self, challenges: Vec<F>)

Initialize phase 1, or the necessary mles in order to bind the variables in the lhs of the expression. Once this phase is initialized, the sumcheck rounds binding the “x” variables can be performed.

fn init_phase_1_rlc(&mut self, challenges: &[&[F]], random_coefficients: &[F])

fn init_phase_2(&mut self, u_claim: &[F], f_at_u: F, g1_claim_points: &[F])

Initialize phase 2, or the necessary mles in order to bind the variables in the rhs of the expression. Once this phase is initialized, the sumcheck rounds binding the “y” variables can be performed.

fn init_phase_2_rlc( &mut self, u_claim: &[F], f_at_u: F, g1_claim_points: &[&[F]], random_coefficients: &[F], )

Trait Implementations

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

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

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for GateLayer<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<GateLayer<F>> for LayerEnum<F>

fn from(var: GateLayer<F>) -> LayerEnum<F>

Converts to this type from the input type.

impl<F: Field> Layer<F> for GateLayer<F>

fn layer_id(&self) -> LayerId

Gets this layer’s id.

fn prove( &mut self, claims: &[&RawClaim<F>], transcript_writer: &mut impl ProverTranscript<F>, ) -> Result<()>

Tries to prove claims for this layer. There is only a single aggregated claim if our [shared_types::config::ClaimAggregationStrategy] is [shared_types::config::ClaimAggregationStrategy::Interpolative], otherwise we have several claims we take the random linear combination over.

fn initialize(&mut self, claim_point: &[F]) -> Result<()>

Initialize this layer and perform any necessary pre-computation: beta table, number of rounds, etc.

fn initialize_rlc( &mut self, _random_coefficients: &[F], claims: &[&RawClaim<F>], )

Transforms the underlying expression in the layer to the expression that must be sumchecked over to verify claims combined using the RLC claim aggregation method presented in Libra (2019).

fn compute_round_sumcheck_message( &mut self, round_index: usize, random_coefficients: &[F], ) -> Result<Vec<F>>

Return the evaluations of the univariate polynomial generated during this round of sumcheck.

fn bind_round_variable( &mut self, round_index: usize, challenge: F, ) -> Result<()>

Mutate the underlying bookkeeping tables to “bind” the given challenge to the bit. labeled with that round_index.

fn sumcheck_round_indices(&self) -> Vec<usize>

The list of sumcheck rounds this layer will prove, by index.

fn max_degree(&self) -> usize

The maximum degree for any univariate in the sumcheck protocol.

fn get_post_sumcheck_layer( &self, round_challenges: &[F], claim_challenges: &[&[F]], random_coefficients: &[F], ) -> PostSumcheckLayer<F, F>

Get the PostSumcheckLayer for a certain layer, which is a struct which represents the fully bound layer. Relevant for the Hyrax IP, where we need commitments to fully bound MLEs as well as their intermediate products.

fn get_claims(&self) -> Result<Vec<Claim<F>>>

Generates and returns all claims that this layer makes onto previous layers.

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