Adapt type simplifications

benches/common/fib.rs

@@ -68,7 +68,7 @@ fn compute_coeffs<F: LurkField>(store: &Store<F>) -> (usize, usize) {
         store.intern_empty_env(),
         store.cont_outermost(),
     ];
-    let lang: Lang<F, Coproc<F>> = Lang::new();
+    let lang: Lang<F> = Lang::new();
     let mut coef_lin = 0;
     let coef_ang;
     let step_func = eval_step();

benches/end2end.rs

@@ -59,7 +59,7 @@ fn end2end_benchmark(c: &mut Criterion) {
     let reduction_count = DEFAULT_REDUCTION_COUNT;
 
     // setup
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     let store = Store::default();
@@ -234,7 +234,7 @@ fn prove_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
@@ -282,7 +282,7 @@ fn prove_compressed_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
@@ -324,7 +324,7 @@ fn verify_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params
@@ -377,7 +377,7 @@ fn verify_compressed_benchmark(c: &mut Criterion) {
 
     let state = State::init_lurk_state().rccell();
 
-    let lang_pallas = Lang::<Fq, Coproc<Fq>>::new();
+    let lang_pallas = Lang::<Fq>::new();
     let lang_pallas_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params

benches/fibonacci.rs

@@ -80,7 +80,7 @@ fn fibonacci_prove<M: measurement::Measurement>(
     c: &mut BenchmarkGroup<'_, M>,
 ) {
     let limit = fib_limit(prove_params.fib_n, prove_params.reduction_count);
-    let lang_pallas = Lang::<pallas::Scalar, Coproc<pallas::Scalar>>::new();
+    let lang_pallas = Lang::<pallas::Scalar>::new();
     let lang_rc = Arc::new(lang_pallas.clone());
 
     // use cached public params

benches/public_params.rs

@@ -1,8 +1,5 @@
 use criterion::{black_box, criterion_group, criterion_main, Criterion, SamplingMode};
-use lurk::{
-    eval::lang::{Coproc, Lang},
-    proof::nova,
-};
+use lurk::{eval::lang::Lang, proof::nova};
 use std::sync::Arc;
 use std::time::Duration;
 
@@ -14,8 +11,7 @@ const DEFAULT_REDUCTION_COUNT: usize = 10;
 fn public_params_benchmark(c: &mut Criterion) {
     let mut group = c.benchmark_group("public_params_benchmark");
     group.sampling_mode(SamplingMode::Flat);
-    let lang_pallas =
-        Lang::<pasta_curves::pallas::Scalar, Coproc<pasta_curves::pallas::Scalar>>::new();
+    let lang_pallas = Lang::<pasta_curves::pallas::Scalar>::new();
     let lang_pallas_rc = Arc::new(lang_pallas);
 
     let reduction_count = DEFAULT_REDUCTION_COUNT;

benches/sha256.rs

@@ -38,7 +38,7 @@ fn sha256_ivc<F: LurkField>(
     state: Rc<RefCell<State>>,
     arity: usize,
     n: usize,
-    input: &Vec<usize>,
+    input: &[usize],
 ) -> Ptr {
     assert_eq!(n, input.len());
     let input = input
@@ -128,7 +128,7 @@ fn sha256_ivc_prove<M: measurement::Measurement>(
                 state.clone(),
                 black_box(prove_params.arity),
                 black_box(prove_params.n),
-                &(0..prove_params.n).collect(),
+                &(0..prove_params.n).collect::<Vec<_>>(),
             );
 
             let prover = NovaProver::new(prove_params.reduction_count, lang_rc.clone());
@@ -209,7 +209,7 @@ fn sha256_ivc_prove_compressed<M: measurement::Measurement>(
                 state.clone(),
                 black_box(prove_params.arity),
                 black_box(prove_params.n),
-                &(0..prove_params.n).collect(),
+                &(0..prove_params.n).collect::<Vec<_>>(),
             );
 
             let prover = NovaProver::new(prove_params.reduction_count, lang_rc.clone());
@@ -293,7 +293,7 @@ fn sha256_nivc_prove<M: measurement::Measurement>(
                 state.clone(),
                 black_box(prove_params.arity),
                 black_box(prove_params.n),
-                &(0..prove_params.n).collect(),
+                &(0..prove_params.n).collect::<Vec<_>>(),
             );
 
             let prover = SuperNovaProver::new(prove_params.reduction_count, lang_rc.clone());

benches/synthesis.rs

@@ -40,7 +40,7 @@ fn synthesize<M: measurement::Measurement>(
     c: &mut BenchmarkGroup<'_, M>,
 ) {
     let limit = 1_000_000;
-    let lang_rc = Arc::new(Lang::<Fq, Coproc<Fq>>::new());
+    let lang_rc = Arc::new(Lang::<Fq>::new());
     let state = State::init_lurk_state().rccell();
 
     c.bench_with_input(

examples/tp_table.rs

@@ -3,7 +3,7 @@ use ascii_table::{Align, AsciiTable};
 use criterion::black_box;
 use lurk::{
     eval::lang::{Coproc, Lang},
-    lem::{eval::evaluate, multiframe::MultiFrame, store::Store},
+    lem::{eval::evaluate, store::Store},
     proof::nova::{public_params, NovaProver, PublicParams},
 };
 use num_traits::ToPrimitive;
@@ -157,7 +157,7 @@ fn main() {
 
     let frames = evaluate::<Fr, Coproc<Fr>>(None, program, &store, limit).unwrap();
 
-    let lang = Lang::<Fr, Coproc<Fr>>::new();
+    let lang = Lang::<Fr>::new();
     let lang_arc = Arc::new(lang.clone());
 
     let mut data = Vec::with_capacity(rc_vec.len());
@@ -166,8 +166,7 @@ fn main() {
         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>>> =
-            public_params(rc, lang_arc.clone());
+        let pp: PublicParams<_> = public_params(rc, lang_arc.clone());
         let n_folds_data = (0..=max_n_folds)
             .map(|n_folds| {
                 let n_frames = n_iters(n_folds, rc);

src/cli/lurk_proof.rs

@@ -1,6 +1,6 @@
-use ::nova::traits::Engine;
 use abomonation::Abomonation;
 use anyhow::{bail, Result};
+use ff::PrimeField;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::HashMap, sync::Arc};
 
@@ -10,7 +10,7 @@ use crate::{
     field::LurkField,
     lem::{pointers::ZPtr, store::Store},
     proof::{
-        nova::{self, CurveCycleEquipped, C1LEM, E1, E2},
+        nova::{self, CurveCycleEquipped, Dual, C1LEM},
         RecursiveSNARKTrait,
     },
     public_parameters::{
@@ -154,9 +154,10 @@ impl<'a, F: CurveCycleEquipped + Serialize, C: Coprocessor<F> + Serialize + Dese
 }
 
 impl<
+        'a,
         F: CurveCycleEquipped + DeserializeOwned,
-        C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
-    > LurkProof<'static, F, C>
+        C: Coprocessor<F> + Serialize + DeserializeOwned + 'a,
+    > LurkProof<'a, F, C>
 {
     #[inline]
     pub(crate) fn is_cached(proof_key: &str) -> bool {
@@ -165,12 +166,13 @@ impl<
 }
 
 impl<
+        'a,
         F: CurveCycleEquipped + DeserializeOwned,
-        C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
-    > LurkProof<'static, F, C>
+        C: Coprocessor<F> + Serialize + DeserializeOwned + 'a,
+    > 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,
+    F::Repr: Abomonation,
+    <Dual<F> as PrimeField>::Repr: Abomonation,
 {
     pub(crate) fn verify_proof(proof_key: &str) -> Result<()> {
         let lurk_proof = load::<Self>(&proof_path(proof_key))?;

src/cli/repl/meta_cmd.rs

@@ -1,7 +1,8 @@
-use ::nova::traits::Engine;
+use ::nova::supernova::StepCircuit;
 use abomonation::Abomonation;
 use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
+use ff::PrimeField;
 use serde::{de::DeserializeOwned, Deserialize, Serialize};
 use std::{collections::HashMap, process};
 
@@ -22,7 +23,7 @@ use crate::{
     },
     package::{Package, SymbolRef},
     proof::{
-        nova::{self, CurveCycleEquipped, C1LEM, E1, E2},
+        nova::{self, CurveCycleEquipped, Dual, C1LEM},
         RecursiveSNARKTrait,
     },
     public_parameters::{
@@ -44,12 +45,13 @@ pub(super) struct MetaCmd<F: LurkField, C: Coprocessor<F> + Serialize + Deserial
 }
 
 impl<
+        'a,
         F: CurveCycleEquipped + Serialize + DeserializeOwned,
         C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
     > MetaCmd<F, C>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    F::Repr: Abomonation,
+    <Dual<F> as PrimeField>::Repr: Abomonation,
 {
     const LOAD: MetaCmd<F, C> = MetaCmd {
         name: "load",
@@ -992,7 +994,7 @@ where
 
             let (fun, proto_rc) = Self::get_fun_and_rc(repl, ptcl)?;
 
-            match load::<ProtocolProof<'_, _, C>>(&path)? {
+            match load::<ProtocolProof<F, C1LEM<'a, F, C>>>(&path)? {
                 ProtocolProof::Nova {
                     args: LurkData { z_ptr, z_dag },
                     proof,
@@ -1096,23 +1098,14 @@ fn get_path<F: LurkField, C: Coprocessor<F> + Serialize + DeserializeOwned>(
 #[non_exhaustive]
 #[derive(Serialize, Deserialize)]
 #[serde(bound(serialize = "F: Serialize", deserialize = "F: DeserializeOwned"))]
-enum ProtocolProof<'a, F: CurveCycleEquipped, C: Coprocessor<F> + Serialize + DeserializeOwned>
-where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-{
+enum ProtocolProof<F: CurveCycleEquipped, S> {
     Nova {
         args: LurkData<F>,
-        proof: nova::Proof<F, C1LEM<'a, F, C>>,
+        proof: nova::Proof<F, S>,
     },
 }
 
-impl<'a, F: CurveCycleEquipped, C: Coprocessor<F> + 'a + Serialize + DeserializeOwned>
-    HasFieldModulus for ProtocolProof<'a, F, C>
-where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-{
+impl<F: CurveCycleEquipped, S: StepCircuit<F>> HasFieldModulus for ProtocolProof<F, S> {
     fn field_modulus() -> String {
         F::MODULUS.to_owned()
     }

src/cli/repl/mod.rs

@@ -3,7 +3,7 @@ mod meta_cmd;
 use abomonation::Abomonation;
 use anyhow::{anyhow, bail, Context, Result};
 use camino::{Utf8Path, Utf8PathBuf};
-use nova::traits::Engine;
+use ff::PrimeField;
 use rustyline::{
     error::ReadlineError,
     history::DefaultHistory,
@@ -39,7 +39,7 @@ use crate::{
     },
     parser,
     proof::{
-        nova::{CurveCycleEquipped, NovaProver, E1, E2},
+        nova::{CurveCycleEquipped, Dual, NovaProver},
         RecursiveSNARKTrait,
     },
     public_parameters::{
@@ -166,8 +166,8 @@ impl<
         C: Coprocessor<F> + Serialize + DeserializeOwned + 'static,
     > Repl<F, C>
 where
-    <<E1<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
-    <<E2<F> as Engine>::Scalar as ff::PrimeField>::Repr: Abomonation,
+    F::Repr: Abomonation,
+    <Dual<F> as PrimeField>::Repr: Abomonation,
 {
     pub(crate) fn new(
         store: Store<F>,

src/eval/lang.rs

@@ -73,7 +73,7 @@ pub enum Coproc<F: LurkField> {
 ///
 // TODO: Define a trait for the Hash and parameterize on that also.
 #[derive(Debug, Default, Clone, Deserialize, Serialize)]
-pub struct Lang<F, C> {
+pub struct Lang<F, C = Coproc<F>> {
     /// An IndexMap that stores coprocessors with their associated `Sym` keys.
     coprocessors: IndexMap<Symbol, C>,
     _p: PhantomData<F>,
@@ -185,12 +185,12 @@ pub(crate) mod test {
 
     #[test]
     fn lang() {
-        Lang::<Fr, Coproc<Fr>>::new();
+        Lang::<Fr>::new();
     }
 
     #[test]
     fn dummy_lang() {
-        let _lang = Lang::<Fr, Coproc<Fr>>::new_with_bindings(vec![(
+        let _lang = Lang::<Fr>::new_with_bindings(vec![(
             sym!("coproc", "dummy"),
             DummyCoprocessor::new().into(),
         )]);

src/lem/eval.rs

@@ -1720,10 +1720,7 @@ fn make_thunk() -> Func {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        eval::lang::{Coproc, Lang},
-        lem::store::Store,
-    };
+    use crate::{eval::lang::Lang, lem::store::Store};
     use bellpepper_core::{test_cs::TestConstraintSystem, Comparable};
     use expect_test::{expect, Expect};
     use halo2curves::bn256::Fr;
@@ -1734,7 +1731,7 @@ mod tests {
         let func = eval_step();
         let frame = Frame::blank(func, 0, &store);
         let mut cs = TestConstraintSystem::<Fr>::new();
-        let lang: Lang<Fr, Coproc<Fr>> = Lang::new();
+        let lang: Lang<Fr> = Lang::new();
         let _ = func.synthesize_frame_aux(&mut cs, &store, &frame, &lang);
         let expect_eq = |computed: usize, expected: Expect| {
             expected.assert_eq(&computed.to_string());

src/lem/multiframe.rs

@@ -15,7 +15,7 @@ use crate::{
     eval::lang::Lang,
     field::{LanguageField, LurkField},
     proof::{
-        nova::{CurveCycleEquipped, E1, E2},
+        nova::{CurveCycleEquipped, E1},
         supernova::{FoldingConfig, C2},
         CEKState, EvaluationStore, FrameLike, Provable,
     },
@@ -898,11 +898,14 @@ impl<'a, F: LurkField, C: Coprocessor<F>> nova::supernova::StepCircuit<F> for Mu
     }
 }
 
-impl<'a, F, C> NonUniformCircuit<E1<F>, E2<F>, MultiFrame<'a, F, C>, C2<F>> for MultiFrame<'a, F, C>
+impl<'a, F, C> NonUniformCircuit<E1<F>> for MultiFrame<'a, F, C>
 where
     F: CurveCycleEquipped + LurkField,
     C: Coprocessor<F> + 'a,
 {
+    type C1 = MultiFrame<'a, F, C>;
+    type C2 = C2<F>;
+
     fn num_circuits(&self) -> usize {
         assert_eq!(self.pc, 0);
         self.get_lang().coprocessor_count() + 1
@@ -1042,7 +1045,7 @@ mod tests {
 
         let mut cs_clone = cs.clone();
 
-        let lang = Lang::<Bn, Coproc<Bn>>::new();
+        let lang = Lang::<Bn>::new();
 
         let output_sequential = synthesize_frames_sequential(
             &mut cs,
@@ -1083,7 +1086,7 @@ mod tests {
         // not self-evaluating
         let expr = store.read_with_default_state("(+ 1 2)").unwrap();
 
-        let lang = Arc::new(Lang::<Bn, Coproc<Bn>>::new());
+        let lang = Arc::new(Lang::<Bn>::new());
         let mut frames = evaluate::<Bn, Coproc<Bn>>(None, expr, &store, 1).unwrap();
         assert_eq!(frames.len(), 1);