fmt and inline doc

Author: roynalnaruto

aggregator/src/recursion.rs

@@ -44,65 +44,70 @@ pub trait StateTransition: Sized {
     type Input: Clone;
     type Circuit: CircuitExt<Fr>;
 
+    /// Initialise a new type that implements the state transition behaviour.
     fn new(state: Self::Input) -> Self;
 
+    /// Transition to the next state.
     fn state_transition(&self, round: usize) -> Self::Input;
 
-    // the number of fields should be used for state transition
-    // notice the pi take 2 times of the returned number (before -> after)
+    /// Returns the number of fields used to represent state. The public input consists of twice
+    /// this number as both the previous and current states are included in the public input.
     fn num_transition_instance() -> usize;
 
-    // in case the circuit still require more PI followed by
-    // state transition
+    /// Returns the number of fields required by the circuit in addition to the fields to represent
+    /// its state.
     fn num_additional_instance() -> usize {
         0
     }
 
+    /// The number of instance cells for the circuit.
     fn num_instance() -> usize {
-        Self::num_transition_instance() * 2 
-        + Self::num_additional_instance()
-        + Self::Circuit::accumulator_indices()
-            .map(|v|v.len()).unwrap_or_default()
+        Self::num_accumulator_instance()
+            + Self::num_transition_instance() * 2
+            + Self::num_additional_instance()
     }
 
+    /// Returns the number of instance cells used to hold the accumulator.
     fn num_accumulator_instance() -> usize {
         Self::Circuit::accumulator_indices()
-        .map(|v|v.len()).unwrap_or_default()
+            .map(|v| v.len())
+            .unwrap_or_default()
     }
 
     /// Following is the indices of the layout of instance
     /// for StateTransition circuit, the default suppose
-    /// single col of instance, and the layout is
-    /// accmulator | prev_state | state | additional
-    /// 
+    /// single col of instance, and the layout is:
+    /// accumulator | prev_state | state | additional
+    ///
     /// Notice we do not verify the layout of accumulator
     /// simply suppose they are put in the beginning
     fn accumulator_indices() -> Vec<usize> {
-        (0..Self::num_accumulator_instance()).collect()
+        let start = 0;
+        let end = Self::num_accumulator_instance();
+        (start..end).collect()
     }
 
-    fn state_indices() -> Vec<usize> {
-        (
-            Self::num_accumulator_instance() + Self::num_transition_instance()..
-            Self::num_accumulator_instance() + Self::num_transition_instance()*2
-        ).collect()
+    /// The accumulator is followed by the instance cells representing the previous state.
+    fn state_prev_indices() -> Vec<usize> {
+        let start = Self::num_accumulator_instance();
+        let end = start + Self::num_transition_instance();
+        (start..end).collect()
     }
 
-    fn state_prev_indices() -> Vec<usize> {
-        (
-            Self::num_accumulator_instance() ..
-            Self::num_accumulator_instance() + Self::num_transition_instance()
-        ).collect()
+    /// The previous state is followed by the instance cells representing the current state.
+    fn state_indices() -> Vec<usize> {
+        let start = Self::num_accumulator_instance() + Self::num_transition_instance();
+        let end = start + Self::num_transition_instance();
+        (start..end).collect()
     }
 
-    /// The indices of the accumulator
+    /// The indices of any other instances cells in addition to the accumulator and state
+    /// transition cells.
     fn additional_indices() -> Vec<usize> {
-        (
-            Self::num_accumulator_instance() + Self::num_transition_instance()*2..
-            Self::num_instance()
-        ).collect()
+        let start = Self::num_accumulator_instance() + 2 * Self::num_transition_instance();
+        let end = Self::num_instance();
+        (start..end).collect()
     }
-
 }
 
 pub use circuit::RecursionCircuit;

aggregator/src/recursion/circuit.rs

@@ -3,7 +3,7 @@
 use super::*;
 use crate::param::ConfigParams as BatchCircuitConfigParams;
 use halo2_proofs::{
-    circuit::{Layouter, SimpleFloorPlanner, Value},
+    circuit::{Cell, Layouter, SimpleFloorPlanner, Value},
     poly::{commitment::ParamsProver, kzg::commitment::ParamsKZG},
 };
 use snark_verifier::{
@@ -26,9 +26,9 @@ use sv_halo2_base::{
     gates::GateInstructions, halo2_proofs, AssignedValue, Context, ContextParams,
     QuantumCell::Existing,
 };
+
 type Svk = KzgSuccinctVerifyingKey<G1Affine>;
 type Pcs = Kzg<Bn256, Bdfg21>;
-
 type As = KzgAs<Pcs>;
 
 fn select_accumulator<'a>(
@@ -80,8 +80,6 @@ pub struct RecursionCircuit<ST> {
 impl<ST: StateTransition> RecursionCircuit<ST> {
     const PREPROCESSED_DIGEST_ROW: usize = 4 * LIMBS;
     const INITIAL_STATE_ROW: usize = Self::PREPROCESSED_DIGEST_ROW + 1;
-    //const STATE_ROW: usize = Self::INITIAL_STATE_ROW + ST;
-    //const ROUND_ROW: usize = Self::STATE_ROW + ST;
 
     pub fn new(
         params: &ParamsKZG<Bn256>,
@@ -90,7 +88,6 @@ impl<ST: StateTransition> RecursionCircuit<ST> {
         rng: impl Rng + Send,
         round: usize,
     ) -> Self {
-
         let svk = params.get_g()[0].into();
         let default_accumulator = KzgAccumulator::new(params.get_g()[1], params.get_g()[0]);
 
@@ -122,20 +119,26 @@ impl<ST: StateTransition> RecursionCircuit<ST> {
 
         let init_instances = if round > 0 {
             // pick from prev snark
-            Vec::from(&previous.instances[0][
-                Self::INITIAL_STATE_ROW..Self::INITIAL_STATE_ROW+ST::num_transition_instance()
-            ])
+            Vec::from(
+                &previous.instances[0][Self::INITIAL_STATE_ROW
+                    ..Self::INITIAL_STATE_ROW + ST::num_transition_instance()],
+            )
         } else {
             // pick from app
             ST::state_prev_indices()
-            .into_iter().map(|i|app.instances[0][i])
-            .collect::<Vec<_>>()
+                .into_iter()
+                .map(|i| app.instances[0][i])
+                .collect::<Vec<_>>()
         };
 
         let state_instances = ST::state_indices()
-            .into_iter().map(|i|&app.instances[0][i])
-            .chain(ST::additional_indices().into_iter()
-            .map(|i|&app.instances[0][i]));
+            .into_iter()
+            .map(|i| &app.instances[0][i])
+            .chain(
+                ST::additional_indices()
+                    .into_iter()
+                    .map(|i| &app.instances[0][i]),
+            );
 
         let preprocessed_digest = {
             let inputs = previous
@@ -150,6 +153,7 @@ impl<ST: StateTransition> RecursionCircuit<ST> {
             hasher.update(&inputs);
             hasher.squeeze()
         };
+
         let instances = [
             accumulator.lhs.x,
             accumulator.lhs.y,
@@ -179,17 +183,6 @@ impl<ST: StateTransition> RecursionCircuit<ST> {
         }
     }
 
-    // fn initial_snark(params: &ParamsKZG<Bn256>, vk: Option<&VerifyingKey<G1Affine>>) -> Snark {
-    //     let mut snark = gen_dummy_snark::<RecursionCircuit>(params, vk);
-    //     let g = params.get_g();
-    //     snark.instances = vec![[g[1].x, g[1].y, g[0].x, g[0].y]
-    //         .into_iter()
-    //         .flat_map(fe_to_limbs::<_, _, LIMBS, BITS>)
-    //         .chain([Fr::ZERO; 4])
-    //         .collect_vec()];
-    //     snark
-    // }
-
     fn as_proof(&self) -> Value<&[u8]> {
         self.as_proof.as_ref().map(Vec::as_slice)
     }
@@ -209,7 +202,7 @@ impl<ST: StateTransition> RecursionCircuit<ST> {
         Ok(KzgAccumulator::new(lhs, rhs))
     }
 
-    /// get the number of instance, help to refine the CircuitExt trait
+    /// Returns the number of instance cells in the Recursion Circuit, help to refine the CircuitExt trait
     pub fn num_instance_fixed() -> usize {
         // [..lhs, ..rhs, preprocessed_digest, initial_state, state, round]
         4 * LIMBS + 2 * ST::num_transition_instance() + ST::num_additional_instance() + 2
@@ -255,13 +248,12 @@ impl<ST: StateTransition> Circuit<Fr> for RecursionCircuit<ST> {
         let main_gate = config.gate();
 
         let mut first_pass = halo2_base::SKIP_FIRST_PASS; // assume using simple floor planner
-        let mut assigned_instances = Vec::new();
-        layouter.assign_region(
+        let assigned_instances = layouter.assign_region(
             || "",
-            |region| {
+            |region| -> Result<Vec<Cell>, Error> {
                 if first_pass {
                     first_pass = false;
-                    return Ok(());
+                    return Ok(vec![]);
                 }
                 let mut ctx = Context::new(
                     region,
@@ -324,14 +316,14 @@ impl<ST: StateTransition> Circuit<Fr> for RecursionCircuit<ST> {
                     Some(preprocessed_digest),
                 );
 
-                let default_accmulator = self.load_default_accumulator(&loader)?;
+                let default_accumulator = self.load_default_accumulator(&loader)?;
                 let previous_accumulators = previous_accumulators
                     .iter()
                     .map(|previous_accumulator| {
                         select_accumulator(
                             &loader,
                             &first_round,
-                            &default_accmulator,
+                            &default_accumulator,
                             previous_accumulator,
                         )
                     })
@@ -353,7 +345,9 @@ impl<ST: StateTransition> Circuit<Fr> for RecursionCircuit<ST> {
                     .iter()
                     .zip_eq(previous_instances[init_state_row_beg..state_row_beg].iter())
                     .zip_eq(
-                        ST::state_prev_indices().into_iter().map(|i|&app_instances[i])
+                        ST::state_prev_indices()
+                            .into_iter()
+                            .map(|i| &app_instances[i]),
                     )
                     .flat_map(|((&st, &previous_st), &app_inst)| {
                         [
@@ -375,10 +369,14 @@ impl<ST: StateTransition> Circuit<Fr> for RecursionCircuit<ST> {
                 let verify_app_state = state
                     .iter()
                     .zip_eq(
-                        ST::state_indices().into_iter().map(|i|&app_instances[i])
-                        .chain(
-                            ST::additional_indices().into_iter().map(|i|&app_instances[i])
-                        )
+                        ST::state_indices()
+                            .into_iter()
+                            .map(|i| &app_instances[i])
+                            .chain(
+                                ST::additional_indices()
+                                    .into_iter()
+                                    .map(|i| &app_instances[i]),
+                            ),
                     )
                     .map(|(&st, &app_inst)| (st, app_inst))
                     .collect::<Vec<_>>();
@@ -387,7 +385,9 @@ impl<ST: StateTransition> Circuit<Fr> for RecursionCircuit<ST> {
                 let verify_app_init_state = previous_instances[state_row_beg..addition_state_beg]
                     .iter()
                     .zip_eq(
-                        ST::state_prev_indices().into_iter().map(|i|&app_instances[i])
+                        ST::state_prev_indices()
+                            .into_iter()
+                            .map(|i| &app_instances[i]),
                     )
                     .map(|(&st, &app_inst)| {
                         (
@@ -432,17 +432,15 @@ impl<ST: StateTransition> Circuit<Fr> for RecursionCircuit<ST> {
                 #[cfg(feature = "display")]
                 println!("Advice columns used: {}", ctx.advice_alloc[0][0].0 + 1);
 
-                assigned_instances.extend(
-                    [lhs.x(), lhs.y(), rhs.x(), rhs.y()]
-                        .into_iter()
-                        .flat_map(|coordinate| coordinate.limbs())
-                        .chain(iter::once(&preprocessed_digest))
-                        .chain(initial_state.iter())
-                        .chain(state.iter())
-                        .chain(iter::once(&round))
-                        .map(|assigned| assigned.cell()),
-                );
-                Ok(())
+                Ok([lhs.x(), lhs.y(), rhs.x(), rhs.y()]
+                    .into_iter()
+                    .flat_map(|coordinate| coordinate.limbs())
+                    .chain(iter::once(&preprocessed_digest))
+                    .chain(initial_state.iter())
+                    .chain(state.iter())
+                    .chain(iter::once(&round))
+                    .map(|assigned| assigned.cell())
+                    .collect())
             },
         )?;
 

aggregator/src/recursion/util.rs

@@ -158,6 +158,7 @@ pub fn initial_recursion_snark<ST: StateTransition>(
         .chain(std::iter::repeat(Fr::ZERO))
         .take(RecursionCircuit::<ST>::num_instance_fixed())
         .collect_vec()];
+
     snark
 }
 
@@ -169,18 +170,12 @@ pub fn gen_recursion_pk<ST: StateTransition>(
     mut rng: impl Rng + Send,
     path: Option<&Path>,
 ) -> ProvingKey<G1Affine> {
-
     let app_snark =
         gen_dummy_snark::<ST::Circuit>(app_params, app_vk, &[ST::num_instance()], &mut rng);
 
     let recursive_snark = initial_recursion_snark::<ST>(recursion_params, None, &mut rng);
 
-    let recursion = RecursionCircuit::<ST>::new(
-        recursion_params,
-        app_snark,
-        recursive_snark,
-        &mut rng,
-        0,
-    );
+    let recursion =
+        RecursionCircuit::<ST>::new(recursion_params, app_snark, recursive_snark, &mut rng, 0);
     gen_pk(recursion_params, &recursion, path)
 }