refactor: Remove MultiFrameTrait

benches/end2end.rs

@@ -9,7 +9,6 @@ use lurk::{
     field::LurkField,
     lem::{
         eval::{evaluate, evaluate_simple},
-        multiframe::MultiFrame,
         pointers::Ptr,
         store::Store,
     },
@@ -64,7 +63,7 @@ fn end2end_benchmark(c: &mut Criterion) {
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     let store = Store::default();
-    let prover: NovaProver<'_, Fq, Coproc<Fq>, MultiFrame<'_, Fq, Coproc<Fq>>> =
+    let prover: NovaProver<'_, Fq, Coproc<Fq>> =
         NovaProver::new(reduction_count, lang_pallas_rc.clone());
 
     // use cached public params
@@ -74,7 +73,7 @@ fn end2end_benchmark(c: &mut Criterion) {
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_parameters::public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_parameters::public_params(&instance).unwrap();
 
     let size = (10, 0);
     let benchmark_id = BenchmarkId::new("end2end_go_base_nova", format!("_{}_{}", size.0, size.1));
@@ -245,11 +244,11 @@ fn prove_benchmark(c: &mut Criterion) {
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_parameters::public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_parameters::public_params(&instance).unwrap();
 
     group.bench_with_input(benchmark_id, &size, |b, &s| {
         let ptr = go_base::<Fq>(&store, state.clone(), s.0, s.1);
-        let prover: NovaProver<'_, Fq, Coproc<Fq>, MultiFrame<'_, Fq, Coproc<Fq>>> =
+        let prover: NovaProver<'_, Fq, Coproc<Fq>> =
             NovaProver::new(reduction_count, lang_pallas_rc.clone());
         let frames = evaluate::<Fq, Coproc<Fq>>(None, ptr, &store, limit).unwrap();
 
@@ -293,7 +292,7 @@ fn prove_compressed_benchmark(c: &mut Criterion) {
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_parameters::public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_parameters::public_params(&instance).unwrap();
 
     group.bench_with_input(benchmark_id, &size, |b, &s| {
         let ptr = go_base::<Fq>(&store, state.clone(), s.0, s.1);
@@ -335,7 +334,7 @@ fn verify_benchmark(c: &mut Criterion) {
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_parameters::public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_parameters::public_params(&instance).unwrap();
 
     let sizes = [(10, 0)];
     for size in sizes {
@@ -387,7 +386,7 @@ fn verify_compressed_benchmark(c: &mut Criterion) {
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_parameters::public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_parameters::public_params(&instance).unwrap();
 
     let sizes = [(10, 0)];
     for size in sizes {

benches/fibonacci.rs

@@ -8,7 +8,7 @@ use std::{sync::Arc, time::Duration};
 
 use lurk::{
     eval::lang::{Coproc, Lang},
-    lem::{eval::evaluate, multiframe::MultiFrame, store::Store},
+    lem::{eval::evaluate, store::Store},
     proof::nova::NovaProver,
     proof::Prover,
     public_parameters::{
@@ -95,7 +95,7 @@ fn fibonacci_prove<M: measurement::Measurement>(
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_params(&instance).unwrap();
 
     // Track the number of `Lurk frames / sec`
     let rc = prove_params.reduction_count as u64;

benches/public_params.rs

@@ -1,7 +1,6 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion, SamplingMode};
 use lurk::{
     eval::lang::{Coproc, Lang},
-    lem::multiframe::MultiFrame,
     proof::nova,
 };
 use std::sync::Arc;
@@ -23,10 +22,7 @@ fn public_params_benchmark(c: &mut Criterion) {
 
     group.bench_function("public_params_nova", |b| {
         b.iter(|| {
-            let result = nova::public_params::<_, _, MultiFrame<'_, _, _>>(
-                reduction_count,
-                lang_pallas_rc.clone(),
-            );
+            let result = nova::public_params(reduction_count, lang_pallas_rc.clone());
             black_box(result)
         })
     });

benches/sha256.rs

@@ -19,7 +19,6 @@ use lurk::{
     field::LurkField,
     lem::{
         eval::{evaluate, make_cprocs_funcs_from_lang, make_eval_step_from_config, EvalConfig},
-        multiframe::MultiFrame,
         pointers::Ptr,
         store::Store,
     },
@@ -112,13 +111,13 @@ fn sha256_ivc_prove<M: measurement::Measurement>(
     let lurk_step = make_eval_step_from_config(&EvalConfig::new_ivc(&lang));
 
     // use cached public params
-    let instance: Instance<'_, Fr, Sha256Coproc<Fr>, MultiFrame<'_, _, _>> = Instance::new(
+    let instance: Instance<'_, Fr, Sha256Coproc<Fr>> = Instance::new(
         reduction_count,
         lang_rc.clone(),
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_params(&instance).unwrap();
 
     c.bench_with_input(
         BenchmarkId::new(prove_params.name(), arity),
@@ -199,7 +198,7 @@ fn sha256_ivc_prove_compressed<M: measurement::Measurement>(
         true,
         Kind::NovaPublicParams,
     );
-    let pp = public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_params(&instance).unwrap();
 
     c.bench_with_input(
         BenchmarkId::new(prove_params.name(), arity),
@@ -283,7 +282,7 @@ fn sha256_nivc_prove<M: measurement::Measurement>(
         true,
         Kind::SuperNovaAuxParams,
     );
-    let pp = supernova_public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = supernova_public_params(&instance).unwrap();
 
     c.bench_with_input(
         BenchmarkId::new(prove_params.name(), arity),

benches/synthesis.rs

@@ -12,7 +12,7 @@ use lurk::{
     eval::lang::{Coproc, Lang},
     field::LurkField,
     lem::{eval::evaluate, multiframe::MultiFrame, pointers::Ptr, store::Store},
-    proof::{supernova::FoldingConfig, MultiFrameTrait},
+    proof::supernova::FoldingConfig,
     state::State,
 };
 
@@ -55,8 +55,7 @@ fn synthesize<M: measurement::Measurement>(
             let folding_config =
                 Arc::new(FoldingConfig::new_ivc(lang_rc.clone(), *reduction_count));
 
-            let multiframe =
-                MultiFrame::from_frames(&frames, &store, folding_config.clone())[0].clone();
+            let multiframe = MultiFrame::from_frames(&frames, &store, &folding_config)[0].clone();
 
             b.iter_batched(
                 || (multiframe.clone()), // avoid cloning the frames in the benchmark

examples/circom.rs

@@ -34,7 +34,6 @@ use std::time::Instant;
 
 use lurk::circuit::gadgets::circom::CircomGadget;
 use lurk::circuit::gadgets::pointer::AllocatedPtr;
-use lurk::lem::multiframe::MultiFrame;
 
 #[cfg(not(target_arch = "wasm32"))]
 use lurk::coprocessor::circom::non_wasm::CircomCoprocessor;
@@ -110,16 +109,13 @@ fn main() {
     let expr = "(.circom_sha256_2)".to_string();
     let ptr = store.read_with_default_state(&expr).unwrap();
 
-    let nova_prover = NovaProver::<Fr, Sha256Coproc<Fr>, MultiFrame<'_, _, _>>::new(
-        REDUCTION_COUNT,
-        lang_rc.clone(),
-    );
+    let nova_prover = NovaProver::<Fr, Sha256Coproc<Fr>>::new(REDUCTION_COUNT, lang_rc.clone());
 
     println!("Setting up public parameters...");
 
     let pp_start = Instant::now();
     let instance = Instance::new(REDUCTION_COUNT, lang_rc, true, Kind::NovaPublicParams);
-    let pp = public_params::<_, _, MultiFrame<'_, _, _>>(&instance).unwrap();
+    let pp = public_params(&instance).unwrap();
     let pp_end = pp_start.elapsed();
 
     println!("Public parameters took {pp_end:?}");

examples/sha256_ivc.rs

@@ -7,7 +7,7 @@ use lurk::{
     coprocessor::sha256::{Sha256Coproc, Sha256Coprocessor},
     eval::lang::Lang,
     field::LurkField,
-    lem::{multiframe::MultiFrame, pointers::Ptr, store::Store},
+    lem::{pointers::Ptr, store::Store},
     proof::{nova::NovaProver, Prover, RecursiveSNARKTrait},
     public_parameters::{
         instance::{Instance, Kind},
@@ -71,10 +71,7 @@ fn main() {
     lang.add_coprocessor(cproc_sym, Sha256Coprocessor::new(n));
     let lang_rc = Arc::new(lang.clone());
 
-    let nova_prover = NovaProver::<Fr, Sha256Coproc<Fr>, MultiFrame<'_, _, _>>::new(
-        REDUCTION_COUNT,
-        lang_rc.clone(),
-    );
+    let nova_prover = NovaProver::<Fr, Sha256Coproc<Fr>>::new(REDUCTION_COUNT, lang_rc.clone());
 
     println!("Setting up public parameters (rc = {REDUCTION_COUNT})...");
 

examples/sha256_nivc.rs

@@ -9,7 +9,6 @@ use lurk::{
     field::LurkField,
     lem::{
         eval::{evaluate, make_cprocs_funcs_from_lang, make_eval_step_from_config, EvalConfig},
-        multiframe::MultiFrame,
         pointers::Ptr,
         store::Store,
     },
@@ -80,16 +79,14 @@ fn main() {
     let cprocs = make_cprocs_funcs_from_lang(&lang);
     let frames = evaluate(Some((&lurk_step, &cprocs, &lang)), call, store, 1000).unwrap();
 
-    let supernova_prover = SuperNovaProver::<Fr, Sha256Coproc<Fr>, MultiFrame<'_, _, _>>::new(
-        REDUCTION_COUNT,
-        lang_rc.clone(),
-    );
+    let supernova_prover =
+        SuperNovaProver::<Fr, Sha256Coproc<Fr>>::new(REDUCTION_COUNT, lang_rc.clone());
 
     println!("Setting up running claim parameters (rc = {REDUCTION_COUNT})...");
     let pp_start = Instant::now();
 
     let instance_primary = Instance::new(REDUCTION_COUNT, lang_rc, true, Kind::SuperNovaAuxParams);
-    let pp = supernova_public_params::<_, _, MultiFrame<'_, _, _>>(&instance_primary).unwrap();
+    let pp = supernova_public_params(&instance_primary).unwrap();
 
     let pp_end = pp_start.elapsed();
     println!("Running claim parameters took {:?}", pp_end);

examples/tp_table.rs

@@ -166,8 +166,7 @@ fn main() {
     let mut data = Vec::with_capacity(rc_vec.len());
 
     for rc in rc_vec.clone() {
-        let prover: NovaProver<'_, _, _, MultiFrame<'_, _, Coproc<Fr>>> =
-            NovaProver::new(rc, lang_arc.clone());
+        let prover: NovaProver<'_, _, _> = NovaProver::new(rc, lang_arc.clone());
         println!("Getting public params for rc={rc}");
         // TODO: use cache once it's fixed
         let pp: PublicParams<_, MultiFrame<'_, _, Coproc<Fr>>> =

src/cli/lurk_proof.rs

@@ -1,7 +1,4 @@
-use ::nova::{
-    supernova::{NonUniformCircuit, StepCircuit as SuperStepCircuit},
-    traits::Engine,
-};
+use ::nova::traits::Engine;
 use abomonation::Abomonation;
 use anyhow::{bail, Result};
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
@@ -14,8 +11,7 @@ use crate::{
     lem::{pointers::ZPtr, store::Store},
     proof::{
         nova::{self, CurveCycleEquipped, E1, E2},
-        supernova::C2,
-        MultiFrameTrait, RecursiveSNARKTrait,
+        RecursiveSNARKTrait,
     },
     public_parameters::{
         instance::{Instance, Kind},
@@ -130,26 +126,21 @@ pub(crate) enum LurkProof<
     'a,
     F: CurveCycleEquipped,
     C: Coprocessor<F> + Serialize + DeserializeOwned,
-    M: MultiFrameTrait<'a, F, C>,
 > where
     <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
     <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
 {
     Nova {
-        proof: nova::Proof<'a, F, C, M>,
+        proof: nova::Proof<'a, F, C>,
         public_inputs: Vec<F>,
         public_outputs: Vec<F>,
         rc: usize,
         lang: Lang<F, C>,
     },
 }
 
-impl<
-        'a,
-        F: CurveCycleEquipped,
-        C: Coprocessor<F> + 'a + Serialize + DeserializeOwned,
-        M: MultiFrameTrait<'a, F, C>,
-    > HasFieldModulus for LurkProof<'a, F, C, M>
+impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a + Serialize + DeserializeOwned>
+    HasFieldModulus for LurkProof<'a, F, C>
 where
     <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
     <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
@@ -159,12 +150,8 @@ where
     }
 }
 
-impl<
-        'a,
-        F: CurveCycleEquipped + Serialize,
-        C: Coprocessor<F> + Serialize + DeserializeOwned,
-        M: MultiFrameTrait<'a, F, C>,
-    > LurkProof<'a, F, C, M>
+impl<'a, F: CurveCycleEquipped + Serialize, C: Coprocessor<F> + Serialize + DeserializeOwned>
+    LurkProof<'a, F, C>
 where
     <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
     <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
@@ -178,11 +165,7 @@ where
 impl<
         F: CurveCycleEquipped + DeserializeOwned,
         C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
-        M: MultiFrameTrait<'static, F, C>
-            + SuperStepCircuit<F>
-            + NonUniformCircuit<E1<F>, E2<F>, M, C2<F>>
-            + 'static,
-    > LurkProof<'static, F, C, M>
+    > LurkProof<'static, F, C>
 where
     <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
     <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,

src/cli/mod.rs

@@ -24,7 +24,7 @@ use std::{
 use crate::{
     eval::lang::{Coproc, Lang},
     field::{LanguageField, LurkField},
-    lem::{multiframe::MultiFrame, store::Store},
+    lem::store::Store,
     public_parameters::disk_cache::public_params_dir,
     public_parameters::instance::Metadata,
 };
@@ -606,14 +606,10 @@ impl Cli {
                 // TODO: pick a predefined `Lang` according to a CLI parameter
                 match verify_args.field.unwrap_or_default() {
                     LanguageField::BN256 => {
-                        LurkProof::<_, _, MultiFrame<'_, _, Coproc<bn256::Fr>>>::verify_proof(
-                            &verify_args.proof_key,
-                        )
+                        LurkProof::<_, Coproc<bn256::Fr>>::verify_proof(&verify_args.proof_key)
                     }
                     LanguageField::Pallas => {
-                        LurkProof::<_, _, MultiFrame<'_, _, Coproc<pallas::Scalar>>>::verify_proof(
-                            &verify_args.proof_key,
-                        )
+                        LurkProof::<_, Coproc<pallas::Scalar>>::verify_proof(&verify_args.proof_key)
                     }
                     _ => unreachable!(),
                 }