Struct IdentityGate 

pub struct IdentityGate<F: Field> {
    layer_id: LayerId,
    wiring: Vec<(u32, u32)>,
    source_mle: DenseMle<F>,
    beta_g2_vec: Option<Vec<BetaValues<F>>>,
    g1_challenges_vec: Option<Vec<Vec<F>>>,
    challenges_vec: Option<Vec<Vec<F>>>,
    a_hg_mle_phase_1: Option<DenseMle<F>>,
    total_num_vars: usize,
    num_dataparallel_vars: usize,
}

The Identity Gate struct allows being able to select specific indices from the source_mle that are not necessarily regular.

Fields

layer_id: LayerId

Layer ID for this gate.

wiring: Vec<(u32, u32)>

Wiring tuples are of the form (dest_idx, src_idx), which specifies that we would like the value in the src_idx of the source_mle to be copied into dest_idx of the output MLE.

source_mle: DenseMle<F>

The MLE from which we are selecting the indices.

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

The BetaValues struct which enumerates the incoming claim’s challenge points on the dataparallel vars of the MLE.

g1_challenges_vec: Option<Vec<Vec<F>>>

The nondataparallel claim points in the layer.

challenges_vec: Option<Vec<Vec<F>>>

The claim points in the layer (both nondataparallel and dataparallel) challenges.

a_hg_mle_phase_1: Option<DenseMle<F>>

The MLE initialized in phase 1, which contains the beta values over g1_challenges folded into the wiring function.

total_num_vars: usize

The total number of variables in the layer.

num_dataparallel_vars: usize

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

Implementations

impl<F: Field> IdentityGate<F>

pub fn new( layer_id: LayerId, wiring: Vec<(u32, u32)>, mle: DenseMle<F>, total_num_vars: usize, num_dataparallel_vars: usize, ) -> IdentityGate<F>

Create a new IdentityGate struct.

fn append_leaf_mles_to_transcript( &self, transcript_writer: &mut impl ProverTranscript<F>, )

fn init_phase_1(&mut self, challenge: &[F], fully_bound_beta_g2: F)

Initialize the bookkeeping table necessary for phase 1, which is the binding of the non-dataparallel variables in the source MLE. This is the initialization function used when we are doing interpolative claim aggregation.

For the random coefficients, we simply use the fully bound value of beta_g2 since this is the value that scales all of the sumcheck evaluations.

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

Initialize the bookkeeping table necessary for phase 1, which is the binding of the non-dataparallel variables in the source MLE. This is the initialization function used when we are doing RLC claim aggregation.

Trait Implementations

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

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

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for IdentityGate<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> Error for IdentityGate<F>

where Self: Debug + Display,

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<F: Field> From<IdentityGate<F>> for LayerEnum<F>

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

Converts to this type from the input type.

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

The layer trait implementation for IdentityGate, which has the proving functionality as well as the modular functions for each round of sumcheck.

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 layer_id(&self) -> LayerId

Gets this layer’s ID.

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 IdentityGate<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.