diff --git a/benches/common/supernova/mod.rs b/benches/common/supernova/mod.rs
index 27e9155cc..6deee3622 100644
--- a/benches/common/supernova/mod.rs
+++ b/benches/common/supernova/mod.rs
@@ -7,7 +7,7 @@ pub mod targets;
 use anyhow::anyhow;
 use arecibo::{
   supernova::{NonUniformCircuit, StepCircuit, TrivialTestCircuit},
-  traits::{CurveCycleEquipped, Engine, SecEng},
+  traits::{CurveCycleEquipped, Engine, Dual},
 };
 use bellpepper_core::{num::AllocatedNum, ConstraintSystem, SynthesisError};
 use core::marker::PhantomData;
@@ -94,7 +94,7 @@ where
   E1: CurveCycleEquipped,
 {
   type C1 = NonTrivialTestCircuit<E1::Scalar>;
-  type C2 = TrivialTestCircuit<<SecEng<E1> as Engine>::Scalar>;
+  type C2 = TrivialTestCircuit<<Dual<E1> as Engine>::Scalar>;
 
   fn num_circuits(&self) -> usize {
     self.num_circuits
diff --git a/src/circuit.rs b/src/circuit.rs
index b51445fc2..7a051a763 100644
--- a/src/circuit.rs
+++ b/src/circuit.rs
@@ -375,7 +375,7 @@ mod tests {
       poseidon::PoseidonConstantsCircuit, Bn256Engine, GrumpkinEngine, PallasEngine,
       Secp256k1Engine, Secq256k1Engine, VestaEngine,
     },
-    traits::{circuit::TrivialCircuit, snark::default_ck_hint, CurveCycleEquipped, SecEng},
+    traits::{circuit::TrivialCircuit, snark::default_ck_hint, CurveCycleEquipped, Dual},
   };
   use expect_test::{expect, Expect};
 
@@ -383,7 +383,7 @@ mod tests {
   fn test_recursive_circuit_with<E1>(
     primary_params: &NovaAugmentedCircuitParams,
     secondary_params: &NovaAugmentedCircuitParams,
-    ro_consts1: ROConstantsCircuit<SecEng<E1>>,
+    ro_consts1: ROConstantsCircuit<Dual<E1>>,
     ro_consts2: ROConstantsCircuit<E1>,
     expected_num_constraints_primary: &Expect,
     expected_num_constraints_secondary: &Expect,
@@ -394,8 +394,8 @@ mod tests {
     // Initialize the shape and ck for the primary
     let circuit1: NovaAugmentedCircuit<
       '_,
-      SecEng<E1>,
-      TrivialCircuit<<SecEng<E1> as Engine>::Base>,
+      Dual<E1>,
+      TrivialCircuit<<Dual<E1> as Engine>::Base>,
     > = NovaAugmentedCircuit::new(primary_params, None, &tc1, ro_consts1.clone());
     let mut cs: TestShapeCS<E1> = TestShapeCS::new();
     let _ = circuit1.synthesize(&mut cs);
@@ -407,16 +407,16 @@ mod tests {
     // Initialize the shape and ck for the secondary
     let circuit2: NovaAugmentedCircuit<'_, E1, TrivialCircuit<<E1 as Engine>::Base>> =
       NovaAugmentedCircuit::new(secondary_params, None, &tc2, ro_consts2.clone());
-    let mut cs: TestShapeCS<SecEng<E1>> = TestShapeCS::new();
+    let mut cs: TestShapeCS<Dual<E1>> = TestShapeCS::new();
     let _ = circuit2.synthesize(&mut cs);
     let (shape2, ck2) = cs.r1cs_shape_and_key(&*default_ck_hint());
 
     expected_num_constraints_secondary.assert_eq(&cs.num_constraints().to_string());
 
     // Execute the base case for the primary
-    let zero1 = <<SecEng<E1> as Engine>::Base as Field>::ZERO;
+    let zero1 = <<Dual<E1> as Engine>::Base as Field>::ZERO;
     let mut cs1 = SatisfyingAssignment::<E1>::new();
-    let inputs1: NovaAugmentedCircuitInputs<SecEng<E1>> = NovaAugmentedCircuitInputs::new(
+    let inputs1: NovaAugmentedCircuitInputs<Dual<E1>> = NovaAugmentedCircuitInputs::new(
       scalar_as_base::<E1>(zero1), // pass zero for testing
       zero1,
       vec![zero1],
@@ -427,8 +427,8 @@ mod tests {
     );
     let circuit1: NovaAugmentedCircuit<
       '_,
-      SecEng<E1>,
-      TrivialCircuit<<SecEng<E1> as Engine>::Base>,
+      Dual<E1>,
+      TrivialCircuit<<Dual<E1> as Engine>::Base>,
     > = NovaAugmentedCircuit::new(primary_params, Some(inputs1), &tc1, ro_consts1);
     let _ = circuit1.synthesize(&mut cs1);
     let (inst1, witness1) = cs1.r1cs_instance_and_witness(&shape1, &ck1).unwrap();
@@ -437,9 +437,9 @@ mod tests {
 
     // Execute the base case for the secondary
     let zero2 = <<E1 as Engine>::Base as Field>::ZERO;
-    let mut cs2 = SatisfyingAssignment::<SecEng<E1>>::new();
+    let mut cs2 = SatisfyingAssignment::<Dual<E1>>::new();
     let inputs2: NovaAugmentedCircuitInputs<E1> = NovaAugmentedCircuitInputs::new(
-      scalar_as_base::<SecEng<E1>>(zero2), // pass zero for testing
+      scalar_as_base::<Dual<E1>>(zero2), // pass zero for testing
       zero2,
       vec![zero2],
       None,
diff --git a/src/lib.rs b/src/lib.rs
index fc67a0c2e..94abee6d3 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -28,7 +28,7 @@ pub mod traits;
 pub mod supernova;
 
 use once_cell::sync::OnceCell;
-use traits::{CurveCycleEquipped, SecEng};
+use traits::{CurveCycleEquipped, Dual};
 
 use crate::digest::{DigestComputer, SimpleDigestible};
 use crate::{
@@ -97,13 +97,13 @@ where
   F_arity_primary: usize,
   F_arity_secondary: usize,
   ro_consts_primary: ROConstants<E>,
-  ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E>>,
+  ro_consts_circuit_primary: ROConstantsCircuit<Dual<E>>,
   ck_primary: Arc<CommitmentKey<E>>,
   circuit_shape_primary: R1CSWithArity<E>,
-  ro_consts_secondary: ROConstants<SecEng<E>>,
+  ro_consts_secondary: ROConstants<Dual<E>>,
   ro_consts_circuit_secondary: ROConstantsCircuit<E>,
-  ck_secondary: Arc<CommitmentKey<SecEng<E>>>,
-  circuit_shape_secondary: R1CSWithArity<SecEng<E>>,
+  ck_secondary: Arc<CommitmentKey<Dual<E>>>,
+  circuit_shape_secondary: R1CSWithArity<Dual<E>>,
   augmented_circuit_params_primary: NovaAugmentedCircuitParams,
   augmented_circuit_params_secondary: NovaAugmentedCircuitParams,
   #[serde(skip, default = "OnceCell::new")]
@@ -121,7 +121,7 @@ where
 where
   E1: CurveCycleEquipped,
   <E1::Scalar as PrimeField>::Repr: Abomonation,
-  <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+  <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
 )]
 pub struct FlatPublicParams<E1>
 where
@@ -130,13 +130,13 @@ where
   F_arity_primary: usize,
   F_arity_secondary: usize,
   ro_consts_primary: ROConstants<E1>,
-  ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E1>>,
+  ro_consts_circuit_primary: ROConstantsCircuit<Dual<E1>>,
   ck_primary: CommitmentKey<E1>,
   circuit_shape_primary: R1CSWithArity<E1>,
-  ro_consts_secondary: ROConstants<SecEng<E1>>,
+  ro_consts_secondary: ROConstants<Dual<E1>>,
   ro_consts_circuit_secondary: ROConstantsCircuit<E1>,
-  ck_secondary: CommitmentKey<SecEng<E1>>,
-  circuit_shape_secondary: R1CSWithArity<SecEng<E1>>,
+  ck_secondary: CommitmentKey<Dual<E1>>,
+  circuit_shape_secondary: R1CSWithArity<Dual<E1>>,
   augmented_circuit_params_primary: NovaAugmentedCircuitParams,
   augmented_circuit_params_secondary: NovaAugmentedCircuitParams,
 }
@@ -243,11 +243,11 @@ where
   ///
   /// let pp = PublicParams::setup(&circuit1, &circuit2, ck_hint1, ck_hint2);
   /// ```
-  pub fn setup<C1: StepCircuit<E1::Scalar>, C2: StepCircuit<<SecEng<E1> as Engine>::Scalar>>(
+  pub fn setup<C1: StepCircuit<E1::Scalar>, C2: StepCircuit<<Dual<E1> as Engine>::Scalar>>(
     c_primary: &C1,
     c_secondary: &C2,
     ck_hint1: &CommitmentKeyHint<E1>,
-    ck_hint2: &CommitmentKeyHint<SecEng<E1>>,
+    ck_hint2: &CommitmentKeyHint<Dual<E1>>,
   ) -> Self {
     let augmented_circuit_params_primary =
       NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
@@ -255,18 +255,18 @@ where
       NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, false);
 
     let ro_consts_primary: ROConstants<E1> = ROConstants::<E1>::default();
-    let ro_consts_secondary: ROConstants<SecEng<E1>> = ROConstants::<SecEng<E1>>::default();
+    let ro_consts_secondary: ROConstants<Dual<E1>> = ROConstants::<Dual<E1>>::default();
 
     let F_arity_primary = c_primary.arity();
     let F_arity_secondary = c_secondary.arity();
 
     // ro_consts_circuit_primary are parameterized by E2 because the type alias uses E2::Base = E1::Scalar
-    let ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E1>> =
-      ROConstantsCircuit::<SecEng<E1>>::default();
+    let ro_consts_circuit_primary: ROConstantsCircuit<Dual<E1>> =
+      ROConstantsCircuit::<Dual<E1>>::default();
     let ro_consts_circuit_secondary: ROConstantsCircuit<E1> = ROConstantsCircuit::<E1>::default();
 
     // Initialize ck for the primary
-    let circuit_primary: NovaAugmentedCircuit<'_, SecEng<E1>, C1> = NovaAugmentedCircuit::new(
+    let circuit_primary: NovaAugmentedCircuit<'_, Dual<E1>, C1> = NovaAugmentedCircuit::new(
       &augmented_circuit_params_primary,
       None,
       c_primary,
@@ -285,7 +285,7 @@ where
       c_secondary,
       ro_consts_circuit_secondary.clone(),
     );
-    let mut cs: ShapeCS<SecEng<E1>> = ShapeCS::new();
+    let mut cs: ShapeCS<Dual<E1>> = ShapeCS::new();
     let _ = circuit_secondary.synthesize(&mut cs);
     let (r1cs_shape_secondary, ck_secondary) = cs.r1cs_shape_and_key(ck_hint2);
     let ck_secondary = Arc::new(ck_secondary);
@@ -357,22 +357,22 @@ where
   E1: CurveCycleEquipped,
 {
   z0_primary: Vec<E1::Scalar>,
-  z0_secondary: Vec<<SecEng<E1> as Engine>::Scalar>,
+  z0_secondary: Vec<<Dual<E1> as Engine>::Scalar>,
   r_W_primary: RelaxedR1CSWitness<E1>,
   r_U_primary: RelaxedR1CSInstance<E1>,
-  r_W_secondary: RelaxedR1CSWitness<SecEng<E1>>,
-  r_U_secondary: RelaxedR1CSInstance<SecEng<E1>>,
-  l_w_secondary: R1CSWitness<SecEng<E1>>,
-  l_u_secondary: R1CSInstance<SecEng<E1>>,
+  r_W_secondary: RelaxedR1CSWitness<Dual<E1>>,
+  r_U_secondary: RelaxedR1CSInstance<Dual<E1>>,
+  l_w_secondary: R1CSWitness<Dual<E1>>,
+  l_u_secondary: R1CSInstance<Dual<E1>>,
 
   /// Buffer for memory needed by the primary fold-step
   buffer_primary: ResourceBuffer<E1>,
   /// Buffer for memory needed by the secondary fold-step
-  buffer_secondary: ResourceBuffer<SecEng<E1>>,
+  buffer_secondary: ResourceBuffer<Dual<E1>>,
 
   i: usize,
   zi_primary: Vec<E1::Scalar>,
-  zi_secondary: Vec<<SecEng<E1> as Engine>::Scalar>,
+  zi_secondary: Vec<<Dual<E1> as Engine>::Scalar>,
 }
 
 impl<E1> RecursiveSNARK<E1>
@@ -380,12 +380,12 @@ where
   E1: CurveCycleEquipped,
 {
   /// Create new instance of recursive SNARK
-  pub fn new<C1: StepCircuit<E1::Scalar>, C2: StepCircuit<<SecEng<E1> as Engine>::Scalar>>(
+  pub fn new<C1: StepCircuit<E1::Scalar>, C2: StepCircuit<<Dual<E1> as Engine>::Scalar>>(
     pp: &PublicParams<E1>,
     c_primary: &C1,
     c_secondary: &C2,
     z0_primary: &[E1::Scalar],
-    z0_secondary: &[<SecEng<E1> as Engine>::Scalar],
+    z0_secondary: &[<Dual<E1> as Engine>::Scalar],
   ) -> Result<Self, NovaError> {
     if z0_primary.len() != pp.F_arity_primary || z0_secondary.len() != pp.F_arity_secondary {
       return Err(NovaError::InvalidInitialInputLength);
@@ -396,7 +396,7 @@ where
 
     // base case for the primary
     let mut cs_primary = SatisfyingAssignment::<E1>::new();
-    let inputs_primary: NovaAugmentedCircuitInputs<SecEng<E1>> = NovaAugmentedCircuitInputs::new(
+    let inputs_primary: NovaAugmentedCircuitInputs<Dual<E1>> = NovaAugmentedCircuitInputs::new(
       scalar_as_base::<E1>(pp.digest()),
       E1::Scalar::ZERO,
       z0_primary.to_vec(),
@@ -406,7 +406,7 @@ where
       None,
     );
 
-    let circuit_primary: NovaAugmentedCircuit<'_, SecEng<E1>, C1> = NovaAugmentedCircuit::new(
+    let circuit_primary: NovaAugmentedCircuit<'_, Dual<E1>, C1> = NovaAugmentedCircuit::new(
       &pp.augmented_circuit_params_primary,
       Some(inputs_primary),
       c_primary,
@@ -417,10 +417,10 @@ where
       cs_primary.r1cs_instance_and_witness(r1cs_primary, &pp.ck_primary)?;
 
     // base case for the secondary
-    let mut cs_secondary = SatisfyingAssignment::<SecEng<E1>>::new();
+    let mut cs_secondary = SatisfyingAssignment::<Dual<E1>>::new();
     let inputs_secondary: NovaAugmentedCircuitInputs<E1> = NovaAugmentedCircuitInputs::new(
       pp.digest(),
-      <SecEng<E1> as Engine>::Scalar::ZERO,
+      <Dual<E1> as Engine>::Scalar::ZERO,
       z0_secondary.to_vec(),
       None,
       None,
@@ -450,9 +450,9 @@ where
     // IVC proof for the secondary circuit
     let l_w_secondary = w_secondary;
     let l_u_secondary = u_secondary;
-    let r_W_secondary = RelaxedR1CSWitness::<SecEng<E1>>::default(r1cs_secondary);
+    let r_W_secondary = RelaxedR1CSWitness::<Dual<E1>>::default(r1cs_secondary);
     let r_U_secondary =
-      RelaxedR1CSInstance::<SecEng<E1>>::default(&pp.ck_secondary, r1cs_secondary);
+      RelaxedR1CSInstance::<Dual<E1>>::default(&pp.ck_secondary, r1cs_secondary);
 
     assert!(
       !(zi_primary.len() != pp.F_arity_primary || zi_secondary.len() != pp.F_arity_secondary),
@@ -467,7 +467,7 @@ where
     let zi_secondary = zi_secondary
       .iter()
       .map(|v| v.get_value().ok_or(SynthesisError::AssignmentMissing))
-      .collect::<Result<Vec<<SecEng<E1> as Engine>::Scalar>, _>>()?;
+      .collect::<Result<Vec<<Dual<E1> as Engine>::Scalar>, _>>()?;
 
     let buffer_primary = ResourceBuffer {
       l_w: None,
@@ -482,7 +482,7 @@ where
       l_u: None,
       ABC_Z_1: R1CSResult::default(r1cs_secondary.num_cons),
       ABC_Z_2: R1CSResult::default(r1cs_secondary.num_cons),
-      T: r1cs::default_T::<SecEng<E1>>(r1cs_secondary.num_cons),
+      T: r1cs::default_T::<Dual<E1>>(r1cs_secondary.num_cons),
     };
 
     Ok(Self {
@@ -508,7 +508,7 @@ where
   #[tracing::instrument(skip_all, name = "nova::RecursiveSNARK::prove_step")]
   pub fn prove_step<
     C1: StepCircuit<E1::Scalar>,
-    C2: StepCircuit<<SecEng<E1> as Engine>::Scalar>,
+    C2: StepCircuit<<Dual<E1> as Engine>::Scalar>,
   >(
     &mut self,
     pp: &PublicParams<E1>,
@@ -545,19 +545,19 @@ where
       pp.circuit_shape_primary.r1cs_shape.num_io + 1,
       pp.circuit_shape_primary.r1cs_shape.num_vars,
     );
-    let inputs_primary: NovaAugmentedCircuitInputs<SecEng<E1>> = NovaAugmentedCircuitInputs::new(
+    let inputs_primary: NovaAugmentedCircuitInputs<Dual<E1>> = NovaAugmentedCircuitInputs::new(
       scalar_as_base::<E1>(pp.digest()),
       E1::Scalar::from(self.i as u64),
       self.z0_primary.to_vec(),
       Some(self.zi_primary.clone()),
       Some(r_U_secondary_i),
       Some(l_u_secondary_i),
-      Some(Commitment::<SecEng<E1>>::decompress(
+      Some(Commitment::<Dual<E1>>::decompress(
         &nifs_secondary.comm_T,
       )?),
     );
 
-    let circuit_primary: NovaAugmentedCircuit<'_, SecEng<E1>, C1> = NovaAugmentedCircuit::new(
+    let circuit_primary: NovaAugmentedCircuit<'_, Dual<E1>, C1> = NovaAugmentedCircuit::new(
       &pp.augmented_circuit_params_primary,
       Some(inputs_primary),
       c_primary,
@@ -584,13 +584,13 @@ where
       &mut self.buffer_primary.ABC_Z_2,
     )?;
 
-    let mut cs_secondary = SatisfyingAssignment::<SecEng<E1>>::with_capacity(
+    let mut cs_secondary = SatisfyingAssignment::<Dual<E1>>::with_capacity(
       pp.circuit_shape_secondary.r1cs_shape.num_io + 1,
       pp.circuit_shape_secondary.r1cs_shape.num_vars,
     );
     let inputs_secondary: NovaAugmentedCircuitInputs<E1> = NovaAugmentedCircuitInputs::new(
       pp.digest(),
-      <SecEng<E1> as Engine>::Scalar::from(self.i as u64),
+      <Dual<E1> as Engine>::Scalar::from(self.i as u64),
       self.z0_secondary.to_vec(),
       Some(self.zi_secondary.clone()),
       Some(r_U_primary_i),
@@ -618,7 +618,7 @@ where
     self.zi_secondary = zi_secondary
       .iter()
       .map(|v| v.get_value().ok_or(SynthesisError::AssignmentMissing))
-      .collect::<Result<Vec<<SecEng<E1> as Engine>::Scalar>, _>>()?;
+      .collect::<Result<Vec<<Dual<E1> as Engine>::Scalar>, _>>()?;
 
     self.l_u_secondary = l_u_secondary;
     self.l_w_secondary = l_w_secondary;
@@ -634,8 +634,8 @@ where
     pp: &PublicParams<E1>,
     num_steps: usize,
     z0_primary: &[E1::Scalar],
-    z0_secondary: &[<SecEng<E1> as Engine>::Scalar],
-  ) -> Result<(Vec<E1::Scalar>, Vec<<SecEng<E1> as Engine>::Scalar>), NovaError> {
+    z0_secondary: &[<Dual<E1> as Engine>::Scalar],
+  ) -> Result<(Vec<E1::Scalar>, Vec<<Dual<E1> as Engine>::Scalar>), NovaError> {
     // number of steps cannot be zero
     let is_num_steps_zero = num_steps == 0;
 
@@ -660,7 +660,7 @@ where
 
     // check if the output hashes in R1CS instances point to the right running instances
     let (hash_primary, hash_secondary) = {
-      let mut hasher = <SecEng<E1> as Engine>::RO::new(
+      let mut hasher = <Dual<E1> as Engine>::RO::new(
         pp.ro_consts_secondary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * pp.F_arity_primary,
       );
@@ -679,7 +679,7 @@ where
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * pp.F_arity_secondary,
       );
       hasher2.absorb(scalar_as_base::<E1>(pp.digest()));
-      hasher2.absorb(<SecEng<E1> as Engine>::Scalar::from(num_steps as u64));
+      hasher2.absorb(<Dual<E1> as Engine>::Scalar::from(num_steps as u64));
       for e in z0_secondary {
         hasher2.absorb(*e);
       }
@@ -695,7 +695,7 @@ where
     };
 
     if hash_primary != self.l_u_secondary.X[0]
-      || hash_secondary != scalar_as_base::<SecEng<E1>>(self.l_u_secondary.X[1])
+      || hash_secondary != scalar_as_base::<Dual<E1>>(self.l_u_secondary.X[1])
     {
       return Err(NovaError::ProofVerifyError);
     }
@@ -738,7 +738,7 @@ where
   }
 
   /// Get the outputs after the last step of computation.
-  pub fn outputs(&self) -> (&[E1::Scalar], &[<SecEng<E1> as Engine>::Scalar]) {
+  pub fn outputs(&self) -> (&[E1::Scalar], &[<Dual<E1> as Engine>::Scalar]) {
     (&self.zi_primary, &self.zi_secondary)
   }
 
@@ -754,7 +754,7 @@ pub struct ProverKey<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: RelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   pk_primary: S1::ProverKey,
   pk_secondary: S2::ProverKey,
@@ -767,12 +767,12 @@ pub struct VerifierKey<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: RelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   F_arity_primary: usize,
   F_arity_secondary: usize,
   ro_consts_primary: ROConstants<E1>,
-  ro_consts_secondary: ROConstants<SecEng<E1>>,
+  ro_consts_secondary: ROConstants<Dual<E1>>,
   pp_digest: E1::Scalar,
   vk_primary: S1::VerifierKey,
   vk_secondary: S2::VerifierKey,
@@ -785,25 +785,25 @@ pub struct CompressedSNARK<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: RelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   r_U_primary: RelaxedR1CSInstance<E1>,
   r_W_snark_primary: S1,
 
-  r_U_secondary: RelaxedR1CSInstance<SecEng<E1>>,
-  l_u_secondary: R1CSInstance<SecEng<E1>>,
-  nifs_secondary: NIFS<SecEng<E1>>,
+  r_U_secondary: RelaxedR1CSInstance<Dual<E1>>,
+  l_u_secondary: R1CSInstance<Dual<E1>>,
+  nifs_secondary: NIFS<Dual<E1>>,
   f_W_snark_secondary: S2,
 
   zn_primary: Vec<E1::Scalar>,
-  zn_secondary: Vec<<SecEng<E1> as Engine>::Scalar>,
+  zn_secondary: Vec<<Dual<E1> as Engine>::Scalar>,
 }
 
 impl<E1, S1, S2> CompressedSNARK<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: RelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   /// Creates prover and verifier keys for `CompressedSNARK`
   pub fn setup(
@@ -894,8 +894,8 @@ where
     vk: &VerifierKey<E1, S1, S2>,
     num_steps: usize,
     z0_primary: &[E1::Scalar],
-    z0_secondary: &[<SecEng<E1> as Engine>::Scalar],
-  ) -> Result<(Vec<E1::Scalar>, Vec<<SecEng<E1> as Engine>::Scalar>), NovaError> {
+    z0_secondary: &[<Dual<E1> as Engine>::Scalar],
+  ) -> Result<(Vec<E1::Scalar>, Vec<<Dual<E1> as Engine>::Scalar>), NovaError> {
     // the number of steps cannot be zero
     if num_steps == 0 {
       return Err(NovaError::ProofVerifyError);
@@ -911,7 +911,7 @@ where
 
     // check if the output hashes in R1CS instances point to the right running instances
     let (hash_primary, hash_secondary) = {
-      let mut hasher = <SecEng<E1> as Engine>::RO::new(
+      let mut hasher = <Dual<E1> as Engine>::RO::new(
         vk.ro_consts_secondary.clone(),
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * vk.F_arity_primary,
       );
@@ -930,7 +930,7 @@ where
         NUM_FE_WITHOUT_IO_FOR_CRHF + 2 * vk.F_arity_secondary,
       );
       hasher2.absorb(scalar_as_base::<E1>(vk.pp_digest));
-      hasher2.absorb(<SecEng<E1> as Engine>::Scalar::from(num_steps as u64));
+      hasher2.absorb(<Dual<E1> as Engine>::Scalar::from(num_steps as u64));
       for e in z0_secondary {
         hasher2.absorb(*e);
       }
@@ -946,7 +946,7 @@ where
     };
 
     if hash_primary != self.l_u_secondary.X[0]
-      || hash_secondary != scalar_as_base::<SecEng<E1>>(self.l_u_secondary.X[1])
+      || hash_secondary != scalar_as_base::<Dual<E1>>(self.l_u_secondary.X[1])
     {
       return Err(NovaError::ProofVerifyError);
     }
@@ -991,11 +991,11 @@ pub fn circuit_digest<E1: CurveCycleEquipped, C: StepCircuit<E1::Scalar>>(
   let augmented_circuit_params = NovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
 
   // ro_consts_circuit are parameterized by G2 because the type alias uses G2::Base = G1::Scalar
-  let ro_consts_circuit: ROConstantsCircuit<SecEng<E1>> =
-    ROConstantsCircuit::<SecEng<E1>>::default();
+  let ro_consts_circuit: ROConstantsCircuit<Dual<E1>> =
+    ROConstantsCircuit::<Dual<E1>>::default();
 
   // Initialize ck for the primary
-  let augmented_circuit: NovaAugmentedCircuit<'_, SecEng<E1>, C> =
+  let augmented_circuit: NovaAugmentedCircuit<'_, Dual<E1>, C> =
     NovaAugmentedCircuit::new(&augmented_circuit_params, None, circuit, ro_consts_circuit);
   let mut cs: ShapeCS<E1> = ShapeCS::new();
   let _ = augmented_circuit.synthesize(&mut cs);
@@ -1080,18 +1080,18 @@ mod tests {
   where
     E1: CurveCycleEquipped,
     E1::GE: DlogGroup,
-    <SecEng<E1> as Engine>::GE: DlogGroup,
+    <Dual<E1> as Engine>::GE: DlogGroup,
     T1: StepCircuit<E1::Scalar>,
-    T2: StepCircuit<<SecEng<E1> as Engine>::Scalar>,
+    T2: StepCircuit<<Dual<E1> as Engine>::Scalar>,
     EE1: EvaluationEngineTrait<E1>,
-    EE2: EvaluationEngineTrait<SecEng<E1>>,
+    EE2: EvaluationEngineTrait<Dual<E1>>,
     // this is due to the reliance on Abomonation
     <E1::Scalar as PrimeField>::Repr: Abomonation,
-    <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+    <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
   {
     // this tests public parameters with a size specifically intended for a spark-compressed SNARK
     let ck_hint1 = &*SPrime::<E1, EE1>::ck_floor();
-    let ck_hint2 = &*SPrime::<SecEng<E1>, EE2>::ck_floor();
+    let ck_hint2 = &*SPrime::<Dual<E1>, EE2>::ck_floor();
     let pp = PublicParams::<E1>::setup(circuit1, circuit2, ck_hint1, ck_hint2);
 
     let digest_str = pp
@@ -1174,7 +1174,7 @@ mod tests {
     E1: CurveCycleEquipped,
   {
     let test_circuit1 = TrivialCircuit::<<E1 as Engine>::Scalar>::default();
-    let test_circuit2 = TrivialCircuit::<<SecEng<E1> as Engine>::Scalar>::default();
+    let test_circuit2 = TrivialCircuit::<<Dual<E1> as Engine>::Scalar>::default();
 
     // produce public parameters
     let pp = PublicParams::<E1>::setup(
@@ -1191,7 +1191,7 @@ mod tests {
       &test_circuit1,
       &test_circuit2,
       &[<E1 as Engine>::Scalar::ZERO],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1204,7 +1204,7 @@ mod tests {
       &pp,
       num_steps,
       &[<E1 as Engine>::Scalar::ZERO],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
@@ -1239,7 +1239,7 @@ mod tests {
       &circuit_primary,
       &circuit_secondary,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1252,7 +1252,7 @@ mod tests {
         &pp,
         i + 1,
         &[<E1 as Engine>::Scalar::ONE],
-        &[<SecEng<E1> as Engine>::Scalar::ZERO],
+        &[<Dual<E1> as Engine>::Scalar::ZERO],
       );
       assert!(res.is_ok());
     }
@@ -1262,7 +1262,7 @@ mod tests {
       &pp,
       num_steps,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1270,14 +1270,14 @@ mod tests {
 
     // sanity: check the claimed output with a direct computation of the same
     assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
-    let mut zn_secondary_direct = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+    let mut zn_secondary_direct = vec![<Dual<E1> as Engine>::Scalar::ZERO];
     for _i in 0..num_steps {
       zn_secondary_direct = circuit_secondary.clone().output(&zn_secondary_direct);
     }
     assert_eq!(zn_secondary, zn_secondary_direct);
     assert_eq!(
       zn_secondary,
-      vec![<SecEng<E1> as Engine>::Scalar::from(2460515u64)]
+      vec![<Dual<E1> as Engine>::Scalar::from(2460515u64)]
     );
   }
 
@@ -1292,10 +1292,10 @@ mod tests {
   where
     E1: CurveCycleEquipped,
     EE1: EvaluationEngineTrait<E1>,
-    EE2: EvaluationEngineTrait<SecEng<E1>>,
+    EE2: EvaluationEngineTrait<Dual<E1>>,
     // this is due to the reliance on Abomonation
     <E1::Scalar as PrimeField>::Repr: Abomonation,
-    <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+    <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
   {
     let circuit_primary = TrivialCircuit::default();
     let circuit_secondary = CubicCircuit::default();
@@ -1316,7 +1316,7 @@ mod tests {
       &circuit_primary,
       &circuit_secondary,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1330,7 +1330,7 @@ mod tests {
       &pp,
       num_steps,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1338,14 +1338,14 @@ mod tests {
 
     // sanity: check the claimed output with a direct computation of the same
     assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
-    let mut zn_secondary_direct = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+    let mut zn_secondary_direct = vec![<Dual<E1> as Engine>::Scalar::ZERO];
     for _i in 0..num_steps {
       zn_secondary_direct = circuit_secondary.clone().output(&zn_secondary_direct);
     }
     assert_eq!(zn_secondary, zn_secondary_direct);
     assert_eq!(
       zn_secondary,
-      vec![<SecEng<E1> as Engine>::Scalar::from(2460515u64)]
+      vec![<Dual<E1> as Engine>::Scalar::from(2460515u64)]
     );
 
     // produce the prover and verifier keys for compressed snark
@@ -1361,7 +1361,7 @@ mod tests {
       &vk,
       num_steps,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
@@ -1384,10 +1384,10 @@ mod tests {
   where
     E1: CurveCycleEquipped,
     EE1: EvaluationEngineTrait<E1>,
-    EE2: EvaluationEngineTrait<SecEng<E1>>,
+    EE2: EvaluationEngineTrait<Dual<E1>>,
     // this is due to the reliance on Abomonation
     <E1::Scalar as PrimeField>::Repr: Abomonation,
-    <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+    <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
   {
     let circuit_primary = TrivialCircuit::default();
     let circuit_secondary = CubicCircuit::default();
@@ -1408,7 +1408,7 @@ mod tests {
       &circuit_primary,
       &circuit_secondary,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1422,7 +1422,7 @@ mod tests {
       &pp,
       num_steps,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1430,14 +1430,14 @@ mod tests {
 
     // sanity: check the claimed output with a direct computation of the same
     assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
-    let mut zn_secondary_direct = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+    let mut zn_secondary_direct = vec![<Dual<E1> as Engine>::Scalar::ZERO];
     for _i in 0..num_steps {
       zn_secondary_direct = CubicCircuit::default().output(&zn_secondary_direct);
     }
     assert_eq!(zn_secondary, zn_secondary_direct);
     assert_eq!(
       zn_secondary,
-      vec![<SecEng<E1> as Engine>::Scalar::from(2460515u64)]
+      vec![<Dual<E1> as Engine>::Scalar::from(2460515u64)]
     );
 
     // run the compressed snark with Spark compiler
@@ -1455,7 +1455,7 @@ mod tests {
       &vk,
       num_steps,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
   }
@@ -1472,10 +1472,10 @@ mod tests {
   where
     E1: CurveCycleEquipped,
     EE1: EvaluationEngineTrait<E1>,
-    EE2: EvaluationEngineTrait<SecEng<E1>>,
+    EE2: EvaluationEngineTrait<Dual<E1>>,
     // this is due to the reliance on Abomonation
     <E1::Scalar as PrimeField>::Repr: Abomonation,
-    <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+    <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
   {
     // y is a non-deterministic advice representing the fifth root of the input at a step.
     #[derive(Clone, Debug)]
@@ -1552,7 +1552,7 @@ mod tests {
 
     // produce non-deterministic advice
     let (z0_primary, roots) = FifthRootCheckingCircuit::new(num_steps);
-    let z0_secondary = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+    let z0_secondary = vec![<Dual<E1> as Engine>::Scalar::ZERO];
 
     // produce a recursive SNARK
     let mut recursive_snark = RecursiveSNARK::<E1>::new(
@@ -1599,7 +1599,7 @@ mod tests {
     E1: CurveCycleEquipped,
   {
     let test_circuit1 = TrivialCircuit::<<E1 as Engine>::Scalar>::default();
-    let test_circuit2 = CubicCircuit::<<SecEng<E1> as Engine>::Scalar>::default();
+    let test_circuit2 = CubicCircuit::<<Dual<E1> as Engine>::Scalar>::default();
 
     // produce public parameters
     let pp = PublicParams::<E1>::setup(
@@ -1617,7 +1617,7 @@ mod tests {
       &test_circuit1,
       &test_circuit2,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     )
     .unwrap();
 
@@ -1631,7 +1631,7 @@ mod tests {
       &pp,
       num_steps,
       &[<E1 as Engine>::Scalar::ONE],
-      &[<SecEng<E1> as Engine>::Scalar::ZERO],
+      &[<Dual<E1> as Engine>::Scalar::ZERO],
     );
     assert!(res.is_ok());
 
@@ -1640,7 +1640,7 @@ mod tests {
     assert_eq!(zn_primary, vec![<E1 as Engine>::Scalar::ONE]);
     assert_eq!(
       zn_secondary,
-      vec![<SecEng<E1> as Engine>::Scalar::from(5u64)]
+      vec![<Dual<E1> as Engine>::Scalar::from(5u64)]
     );
   }
 
diff --git a/src/supernova/circuit.rs b/src/supernova/circuit.rs
index b1e062342..f9f27c934 100644
--- a/src/supernova/circuit.rs
+++ b/src/supernova/circuit.rs
@@ -713,7 +713,7 @@ mod tests {
       Secp256k1Engine, Secq256k1Engine, VestaEngine,
     },
     supernova::circuit::TrivialTestCircuit,
-    traits::{snark::default_ck_hint, CurveCycleEquipped, SecEng},
+    traits::{snark::default_ck_hint, CurveCycleEquipped, Dual},
   };
   use expect_test::{expect, Expect};
 
@@ -721,7 +721,7 @@ mod tests {
   fn test_supernova_recursive_circuit_with<E1>(
     primary_params: &SuperNovaAugmentedCircuitParams,
     secondary_params: &SuperNovaAugmentedCircuitParams,
-    ro_consts1: ROConstantsCircuit<SecEng<E1>>,
+    ro_consts1: ROConstantsCircuit<Dual<E1>>,
     ro_consts2: ROConstantsCircuit<E1>,
     num_constraints_primary: &Expect,
     num_constraints_secondary: &Expect,
@@ -733,8 +733,8 @@ mod tests {
     // Initialize the shape and ck for the primary
     let circuit1: SuperNovaAugmentedCircuit<
       '_,
-      SecEng<E1>,
-      TrivialTestCircuit<<SecEng<E1> as Engine>::Base>,
+      Dual<E1>,
+      TrivialTestCircuit<<Dual<E1> as Engine>::Base>,
     > = SuperNovaAugmentedCircuit::new(
       primary_params,
       None,
@@ -758,17 +758,17 @@ mod tests {
         ro_consts2.clone(),
         num_augmented_circuits,
       );
-    let mut cs: TestShapeCS<SecEng<E1>> = TestShapeCS::new();
+    let mut cs: TestShapeCS<Dual<E1>> = TestShapeCS::new();
     let _ = circuit2.synthesize(&mut cs);
     let (shape2, ck2) = cs.r1cs_shape_and_key(&*default_ck_hint());
 
     num_constraints_secondary.assert_eq(&cs.num_constraints().to_string());
 
     // Execute the base case for the primary
-    let zero1 = <<SecEng<E1> as Engine>::Base as Field>::ZERO;
+    let zero1 = <<Dual<E1> as Engine>::Base as Field>::ZERO;
     let mut cs1 = SatisfyingAssignment::<E1>::new();
     let vzero1 = vec![zero1];
-    let inputs1: SuperNovaAugmentedCircuitInputs<'_, SecEng<E1>> =
+    let inputs1: SuperNovaAugmentedCircuitInputs<'_, Dual<E1>> =
       SuperNovaAugmentedCircuitInputs::new(
         scalar_as_base::<E1>(zero1), // pass zero for testing
         zero1,
@@ -782,8 +782,8 @@ mod tests {
       );
     let circuit1: SuperNovaAugmentedCircuit<
       '_,
-      SecEng<E1>,
-      TrivialTestCircuit<<SecEng<E1> as Engine>::Base>,
+      Dual<E1>,
+      TrivialTestCircuit<<Dual<E1> as Engine>::Base>,
     > = SuperNovaAugmentedCircuit::new(
       primary_params,
       Some(inputs1),
@@ -798,10 +798,10 @@ mod tests {
 
     // Execute the base case for the secondary
     let zero2 = <<E1 as Engine>::Base as Field>::ZERO;
-    let mut cs2 = SatisfyingAssignment::<SecEng<E1>>::new();
+    let mut cs2 = SatisfyingAssignment::<Dual<E1>>::new();
     let vzero2 = vec![zero2];
     let inputs2: SuperNovaAugmentedCircuitInputs<'_, E1> = SuperNovaAugmentedCircuitInputs::new(
-      scalar_as_base::<SecEng<E1>>(zero2), // pass zero for testing
+      scalar_as_base::<Dual<E1>>(zero2), // pass zero for testing
       zero2,
       &vzero2,
       None,
diff --git a/src/supernova/mod.rs b/src/supernova/mod.rs
index 9343acb67..c2d702656 100644
--- a/src/supernova/mod.rs
+++ b/src/supernova/mod.rs
@@ -14,7 +14,7 @@ use crate::{
   scalar_as_base,
   traits::{
     commitment::{CommitmentEngineTrait, CommitmentTrait},
-    AbsorbInROTrait, CurveCycleEquipped, Engine, ROConstants, ROConstantsCircuit, ROTrait, SecEng,
+    AbsorbInROTrait, CurveCycleEquipped, Engine, ROConstants, ROConstantsCircuit, ROTrait, Dual,
   },
   Commitment, CommitmentKey, R1CSWithArity,
 };
@@ -89,14 +89,14 @@ where
   circuit_shapes: Vec<R1CSWithArity<E1>>,
 
   ro_consts_primary: ROConstants<E1>,
-  ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E1>>,
+  ro_consts_circuit_primary: ROConstantsCircuit<Dual<E1>>,
   ck_primary: Arc<CommitmentKey<E1>>, // This is shared between all circuit params
   augmented_circuit_params_primary: SuperNovaAugmentedCircuitParams,
 
-  ro_consts_secondary: ROConstants<SecEng<E1>>,
+  ro_consts_secondary: ROConstants<Dual<E1>>,
   ro_consts_circuit_secondary: ROConstantsCircuit<E1>,
-  ck_secondary: Arc<CommitmentKey<SecEng<E1>>>,
-  circuit_shape_secondary: R1CSWithArity<SecEng<E1>>,
+  ck_secondary: Arc<CommitmentKey<Dual<E1>>>,
+  circuit_shape_secondary: R1CSWithArity<Dual<E1>>,
   augmented_circuit_params_secondary: SuperNovaAugmentedCircuitParams,
 
   /// Digest constructed from this `PublicParams`' parameters
@@ -114,14 +114,14 @@ where
   E1: CurveCycleEquipped,
 {
   ro_consts_primary: ROConstants<E1>,
-  ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E1>>,
+  ro_consts_circuit_primary: ROConstantsCircuit<Dual<E1>>,
   ck_primary: Arc<CommitmentKey<E1>>, // This is shared between all circuit params
   augmented_circuit_params_primary: SuperNovaAugmentedCircuitParams,
 
-  ro_consts_secondary: ROConstants<SecEng<E1>>,
+  ro_consts_secondary: ROConstants<Dual<E1>>,
   ro_consts_circuit_secondary: ROConstantsCircuit<E1>,
-  ck_secondary: Arc<CommitmentKey<SecEng<E1>>>,
-  circuit_shape_secondary: R1CSWithArity<SecEng<E1>>,
+  ck_secondary: Arc<CommitmentKey<Dual<E1>>>,
+  circuit_shape_secondary: R1CSWithArity<Dual<E1>>,
   augmented_circuit_params_secondary: SuperNovaAugmentedCircuitParams,
 
   digest: E1::Scalar,
@@ -134,21 +134,21 @@ where
 where
   E1: CurveCycleEquipped,
   <E1::Scalar as PrimeField>::Repr: Abomonation,
-  <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+  <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
 )]
 pub struct FlatAuxParams<E1>
 where
   E1: CurveCycleEquipped,
 {
   ro_consts_primary: ROConstants<E1>,
-  ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E1>>,
+  ro_consts_circuit_primary: ROConstantsCircuit<Dual<E1>>,
   ck_primary: CommitmentKey<E1>, // This is shared between all circuit params
   augmented_circuit_params_primary: SuperNovaAugmentedCircuitParams,
 
-  ro_consts_secondary: ROConstants<SecEng<E1>>,
+  ro_consts_secondary: ROConstants<Dual<E1>>,
   ro_consts_circuit_secondary: ROConstantsCircuit<E1>,
-  ck_secondary: CommitmentKey<SecEng<E1>>,
-  circuit_shape_secondary: R1CSWithArity<SecEng<E1>>,
+  ck_secondary: CommitmentKey<Dual<E1>>,
+  circuit_shape_secondary: R1CSWithArity<Dual<E1>>,
   augmented_circuit_params_secondary: SuperNovaAugmentedCircuitParams,
 
   #[abomonate_with(<E1::Scalar as PrimeField>::Repr)]
@@ -241,7 +241,7 @@ where
   pub fn setup<NC: NonUniformCircuit<E1>>(
     non_uniform_circuit: &NC,
     ck_hint1: &CommitmentKeyHint<E1>,
-    ck_hint2: &CommitmentKeyHint<SecEng<E1>>,
+    ck_hint2: &CommitmentKeyHint<Dual<E1>>,
   ) -> Self {
     let num_circuits = non_uniform_circuit.num_circuits();
 
@@ -249,15 +249,15 @@ where
       SuperNovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
     let ro_consts_primary: ROConstants<E1> = ROConstants::<E1>::default();
     // ro_consts_circuit_primary are parameterized by E2 because the type alias uses E2::Base = E1::Scalar
-    let ro_consts_circuit_primary: ROConstantsCircuit<SecEng<E1>> =
-      ROConstantsCircuit::<SecEng<E1>>::default();
+    let ro_consts_circuit_primary: ROConstantsCircuit<Dual<E1>> =
+      ROConstantsCircuit::<Dual<E1>>::default();
 
     let circuit_shapes = (0..num_circuits)
       .map(|i| {
         let c_primary = non_uniform_circuit.primary_circuit(i);
         let F_arity = c_primary.arity();
         // Initialize ck for the primary
-        let circuit_primary: SuperNovaAugmentedCircuit<'_, SecEng<E1>, NC::C1> =
+        let circuit_primary: SuperNovaAugmentedCircuit<'_, Dual<E1>, NC::C1> =
           SuperNovaAugmentedCircuit::new(
             &augmented_circuit_params_primary,
             None,
@@ -281,7 +281,7 @@ where
 
     let augmented_circuit_params_secondary =
       SuperNovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, false);
-    let ro_consts_secondary = ROConstants::<SecEng<E1>>::default();
+    let ro_consts_secondary = ROConstants::<Dual<E1>>::default();
     let c_secondary = non_uniform_circuit.secondary_circuit();
     let F_arity_secondary = c_secondary.arity();
     let ro_consts_circuit_secondary: ROConstantsCircuit<E1> = ROConstantsCircuit::<E1>::default();
@@ -294,7 +294,7 @@ where
         ro_consts_circuit_secondary.clone(),
         num_circuits,
       );
-    let mut cs: ShapeCS<SecEng<E1>> = ShapeCS::new();
+    let mut cs: ShapeCS<Dual<E1>> = ShapeCS::new();
     circuit_secondary
       .synthesize(&mut cs)
       .expect("circuit synthesis failed");
@@ -487,7 +487,7 @@ where
   /// Buffer for memory needed by the primary fold-step
   buffer_primary: ResourceBuffer<E1>,
   /// Buffer for memory needed by the secondary fold-step
-  buffer_secondary: ResourceBuffer<SecEng<E1>>,
+  buffer_secondary: ResourceBuffer<Dual<E1>>,
 
   // Relaxed instances for the primary circuits
   // Entries are `None` if the circuit has not been executed yet
@@ -495,14 +495,14 @@ where
   r_U_primary: Vec<Option<RelaxedR1CSInstance<E1>>>,
 
   // Inputs and outputs of the secondary circuit
-  z0_secondary: Vec<<SecEng<E1> as Engine>::Scalar>,
-  zi_secondary: Vec<<SecEng<E1> as Engine>::Scalar>,
+  z0_secondary: Vec<<Dual<E1> as Engine>::Scalar>,
+  zi_secondary: Vec<<Dual<E1> as Engine>::Scalar>,
   // Relaxed instance for the secondary circuit
-  r_W_secondary: RelaxedR1CSWitness<SecEng<E1>>,
-  r_U_secondary: RelaxedR1CSInstance<SecEng<E1>>,
+  r_W_secondary: RelaxedR1CSWitness<Dual<E1>>,
+  r_U_secondary: RelaxedR1CSInstance<Dual<E1>>,
   // Proof for the secondary circuit to be accumulated into r_secondary in the next iteration
-  l_w_secondary: R1CSWitness<SecEng<E1>>,
-  l_u_secondary: R1CSInstance<SecEng<E1>>,
+  l_w_secondary: R1CSWitness<Dual<E1>>,
+  l_u_secondary: R1CSInstance<Dual<E1>>,
 }
 
 impl<E1> RecursiveSNARK<E1>
@@ -517,7 +517,7 @@ where
     c_primary: &C0::C1,
     c_secondary: &C0::C2,
     z0_primary: &[E1::Scalar],
-    z0_secondary: &[<SecEng<E1> as Engine>::Scalar],
+    z0_secondary: &[<Dual<E1> as Engine>::Scalar],
   ) -> Result<Self, SuperNovaError> {
     let num_augmented_circuits = non_uniform_circuit.num_circuits();
     let circuit_index = non_uniform_circuit.initial_circuit_index();
@@ -544,7 +544,7 @@ where
     // base case for the primary
     let mut cs_primary = SatisfyingAssignment::<E1>::new();
     let program_counter = E1::Scalar::from(circuit_index as u64);
-    let inputs_primary: SuperNovaAugmentedCircuitInputs<'_, SecEng<E1>> =
+    let inputs_primary: SuperNovaAugmentedCircuitInputs<'_, Dual<E1>> =
       SuperNovaAugmentedCircuitInputs::new(
         scalar_as_base::<E1>(pp.digest()),
         E1::Scalar::ZERO,
@@ -557,7 +557,7 @@ where
         E1::Scalar::ZERO,      // u_index is always zero for the primary circuit
       );
 
-    let circuit_primary: SuperNovaAugmentedCircuit<'_, SecEng<E1>, C0::C1> =
+    let circuit_primary: SuperNovaAugmentedCircuit<'_, Dual<E1>, C0::C1> =
       SuperNovaAugmentedCircuit::new(
         &pp.augmented_circuit_params_primary,
         Some(inputs_primary),
@@ -584,12 +584,12 @@ where
       })?;
 
     // base case for the secondary
-    let mut cs_secondary = SatisfyingAssignment::<SecEng<E1>>::new();
-    let u_primary_index = <SecEng<E1> as Engine>::Scalar::from(circuit_index as u64);
+    let mut cs_secondary = SatisfyingAssignment::<Dual<E1>>::new();
+    let u_primary_index = <Dual<E1> as Engine>::Scalar::from(circuit_index as u64);
     let inputs_secondary: SuperNovaAugmentedCircuitInputs<'_, E1> =
       SuperNovaAugmentedCircuitInputs::new(
         pp.digest(),
-        <SecEng<E1> as Engine>::Scalar::ZERO,
+        <Dual<E1> as Engine>::Scalar::ZERO,
         z0_secondary,
         None,             // zi = None for basecase
         None,             // U = Empty list of accumulators for the primary circuits
@@ -634,7 +634,7 @@ where
     let l_u_secondary = u_secondary;
 
     // Initialize relaxed instance/witness pair for the secondary circuit proofs
-    let r_W_secondary = RelaxedR1CSWitness::<SecEng<E1>>::default(r1cs_secondary);
+    let r_W_secondary = RelaxedR1CSWitness::<Dual<E1>>::default(r1cs_secondary);
     let r_U_secondary = RelaxedR1CSInstance::default(&*pp.ck_secondary, r1cs_secondary);
 
     // Outputs of the two circuits and next program counter thus far.
@@ -655,7 +655,7 @@ where
         v.get_value()
           .ok_or(NovaError::from(SynthesisError::AssignmentMissing).into())
       })
-      .collect::<Result<Vec<<SecEng<E1> as Engine>::Scalar>, SuperNovaError>>()?;
+      .collect::<Result<Vec<<Dual<E1> as Engine>::Scalar>, SuperNovaError>>()?;
 
     // handle the base case by initialize U_next in next round
     let r_W_primary_initial_list = (0..num_augmented_circuits)
@@ -687,7 +687,7 @@ where
       l_u: None,
       ABC_Z_1: R1CSResult::default(r1cs_secondary.num_cons),
       ABC_Z_2: R1CSResult::default(r1cs_secondary.num_cons),
-      T: r1cs::default_T::<SecEng<E1>>(r1cs_secondary.num_cons),
+      T: r1cs::default_T::<Dual<E1>>(r1cs_secondary.num_cons),
     };
 
     Ok(Self {
@@ -719,7 +719,7 @@ where
   #[tracing::instrument(skip_all, name = "supernova::RecursiveSNARK::prove_step")]
   pub fn prove_step<
     C1: StepCircuit<E1::Scalar>,
-    C2: StepCircuit<<SecEng<E1> as Engine>::Scalar>,
+    C2: StepCircuit<<Dual<E1> as Engine>::Scalar>,
   >(
     &mut self,
     pp: &PublicParams<E1>,
@@ -761,9 +761,9 @@ where
       pp[circuit_index].r1cs_shape.num_io + 1,
       pp[circuit_index].r1cs_shape.num_vars,
     );
-    let T = Commitment::<SecEng<E1>>::decompress(&nifs_secondary.comm_T)
+    let T = Commitment::<Dual<E1>>::decompress(&nifs_secondary.comm_T)
       .map_err(SuperNovaError::NovaError)?;
-    let inputs_primary: SuperNovaAugmentedCircuitInputs<'_, SecEng<E1>> =
+    let inputs_primary: SuperNovaAugmentedCircuitInputs<'_, Dual<E1>> =
       SuperNovaAugmentedCircuitInputs::new(
         scalar_as_base::<E1>(self.pp_digest),
         E1::Scalar::from(self.i as u64),
@@ -776,7 +776,7 @@ where
         E1::Scalar::ZERO,
       );
 
-    let circuit_primary: SuperNovaAugmentedCircuit<'_, SecEng<E1>, C1> =
+    let circuit_primary: SuperNovaAugmentedCircuit<'_, Dual<E1>, C1> =
       SuperNovaAugmentedCircuit::new(
         &pp.augmented_circuit_params_primary,
         Some(inputs_primary),
@@ -831,7 +831,7 @@ where
     )
     .map_err(SuperNovaError::NovaError)?;
 
-    let mut cs_secondary = SatisfyingAssignment::<SecEng<E1>>::with_capacity(
+    let mut cs_secondary = SatisfyingAssignment::<Dual<E1>>::with_capacity(
       pp.circuit_shape_secondary.r1cs_shape.num_io + 1,
       pp.circuit_shape_secondary.r1cs_shape.num_vars,
     );
@@ -840,14 +840,14 @@ where
     let inputs_secondary: SuperNovaAugmentedCircuitInputs<'_, E1> =
       SuperNovaAugmentedCircuitInputs::new(
         self.pp_digest,
-        <SecEng<E1> as Engine>::Scalar::from(self.i as u64),
+        <Dual<E1> as Engine>::Scalar::from(self.i as u64),
         &self.z0_secondary,
         Some(&self.zi_secondary),
         Some(&r_U_primary_i),
         Some(&l_u_primary),
         Some(&binding),
         None, // pc is always None for secondary circuit
-        <SecEng<E1> as Engine>::Scalar::from(circuit_index as u64),
+        <Dual<E1> as Engine>::Scalar::from(circuit_index as u64),
       );
 
     let circuit_secondary: SuperNovaAugmentedCircuit<'_, E1, C2> = SuperNovaAugmentedCircuit::new(
@@ -887,7 +887,7 @@ where
         v.get_value()
           .ok_or(NovaError::from(SynthesisError::AssignmentMissing).into())
       })
-      .collect::<Result<Vec<<SecEng<E1> as Engine>::Scalar>, SuperNovaError>>()?;
+      .collect::<Result<Vec<<Dual<E1> as Engine>::Scalar>, SuperNovaError>>()?;
 
     if zi_primary.len() != pp[circuit_index].F_arity
       || zi_secondary.len() != pp.circuit_shape_secondary.F_arity
@@ -912,8 +912,8 @@ where
     &self,
     pp: &PublicParams<E1>,
     z0_primary: &[E1::Scalar],
-    z0_secondary: &[<SecEng<E1> as Engine>::Scalar],
-  ) -> Result<(Vec<E1::Scalar>, Vec<<SecEng<E1> as Engine>::Scalar>), SuperNovaError> {
+    z0_secondary: &[<Dual<E1> as Engine>::Scalar],
+  ) -> Result<(Vec<E1::Scalar>, Vec<<Dual<E1> as Engine>::Scalar>), SuperNovaError> {
     // number of steps cannot be zero
     if self.i == 0 {
       debug!("must verify on valid RecursiveSNARK where i > 0");
@@ -993,7 +993,7 @@ where
         true, // is_primary
       );
 
-      let mut hasher = <SecEng<E1> as Engine>::RO::new(pp.ro_consts_secondary.clone(), num_absorbs);
+      let mut hasher = <Dual<E1> as Engine>::RO::new(pp.ro_consts_secondary.clone(), num_absorbs);
       hasher.absorb(self.pp_digest);
       hasher.absorb(E1::Scalar::from(self.i as u64));
       hasher.absorb(self.program_counter);
@@ -1018,7 +1018,7 @@ where
       );
       let mut hasher = <E1 as Engine>::RO::new(pp.ro_consts_primary.clone(), num_absorbs);
       hasher.absorb(scalar_as_base::<E1>(self.pp_digest));
-      hasher.absorb(<SecEng<E1> as Engine>::Scalar::from(self.i as u64));
+      hasher.absorb(<Dual<E1> as Engine>::Scalar::from(self.i as u64));
 
       for e in z0_secondary {
         hasher.absorb(*e);
@@ -1045,7 +1045,7 @@ where
       );
       return Err(SuperNovaError::NovaError(NovaError::ProofVerifyError));
     }
-    if hash_secondary != scalar_as_base::<SecEng<E1>>(self.l_u_secondary.X[1]) {
+    if hash_secondary != scalar_as_base::<Dual<E1>>(self.l_u_secondary.X[1]) {
       debug!(
         "hash_secondary {:?} not equal l_u_secondary.X[1] {:?}",
         hash_secondary, self.l_u_secondary.X[1]
@@ -1115,7 +1115,7 @@ where
   /// The type of the step-circuits on the primary
   type C1: StepCircuit<E1::Scalar>;
   /// The type of the step-circuits on the secondary
-  type C2: StepCircuit<<SecEng<E1> as Engine>::Scalar>;
+  type C2: StepCircuit<<Dual<E1> as Engine>::Scalar>;
 
   /// Initial circuit index, defaults to zero.
   fn initial_circuit_index(&self) -> usize {
@@ -1157,10 +1157,10 @@ pub fn circuit_digest<E1: CurveCycleEquipped, C: StepCircuit<E1::Scalar>>(
     SuperNovaAugmentedCircuitParams::new(BN_LIMB_WIDTH, BN_N_LIMBS, true);
 
   // ro_consts_circuit are parameterized by E2 because the type alias uses E2::Base = E1::Scalar
-  let ro_consts_circuit = ROConstantsCircuit::<SecEng<E1>>::default();
+  let ro_consts_circuit = ROConstantsCircuit::<Dual<E1>>::default();
 
   // Initialize ck for the primary
-  let augmented_circuit: SuperNovaAugmentedCircuit<'_, SecEng<E1>, C> =
+  let augmented_circuit: SuperNovaAugmentedCircuit<'_, Dual<E1>, C> =
     SuperNovaAugmentedCircuit::new(
       &augmented_circuit_params,
       None,
diff --git a/src/supernova/snark.rs b/src/supernova/snark.rs
index f681e16d5..c32babe0f 100644
--- a/src/supernova/snark.rs
+++ b/src/supernova/snark.rs
@@ -6,7 +6,7 @@ use crate::{
   r1cs::{R1CSInstance, RelaxedR1CSWitness},
   traits::{
     snark::{BatchedRelaxedR1CSSNARKTrait, RelaxedR1CSSNARKTrait},
-    AbsorbInROTrait, CurveCycleEquipped, Engine, ROTrait, SecEng,
+    AbsorbInROTrait, CurveCycleEquipped, Engine, ROTrait, Dual,
   },
 };
 use crate::{errors::NovaError, scalar_as_base, RelaxedR1CSInstance, NIFS};
@@ -20,7 +20,7 @@ pub struct ProverKey<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: BatchedRelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   pk_primary: S1::ProverKey,
   pk_secondary: S2::ProverKey,
@@ -32,7 +32,7 @@ pub struct VerifierKey<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: BatchedRelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   vk_primary: S1::VerifierKey,
   vk_secondary: S2::VerifierKey,
@@ -45,28 +45,28 @@ pub struct CompressedSNARK<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: BatchedRelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   r_U_primary: Vec<RelaxedR1CSInstance<E1>>,
   r_W_snark_primary: S1,
 
-  r_U_secondary: RelaxedR1CSInstance<SecEng<E1>>,
-  l_u_secondary: R1CSInstance<SecEng<E1>>,
-  nifs_secondary: NIFS<SecEng<E1>>,
+  r_U_secondary: RelaxedR1CSInstance<Dual<E1>>,
+  l_u_secondary: R1CSInstance<Dual<E1>>,
+  nifs_secondary: NIFS<Dual<E1>>,
   f_W_snark_secondary: S2,
 
   num_steps: usize,
   program_counter: E1::Scalar,
 
   zn_primary: Vec<E1::Scalar>,
-  zn_secondary: Vec<<SecEng<E1> as Engine>::Scalar>,
+  zn_secondary: Vec<<Dual<E1> as Engine>::Scalar>,
 }
 
 impl<E1, S1, S2> CompressedSNARK<E1, S1, S2>
 where
   E1: CurveCycleEquipped,
   S1: BatchedRelaxedR1CSSNARKTrait<E1>,
-  S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+  S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
 {
   /// Creates prover and verifier keys for `CompressedSNARK`
   pub fn setup(
@@ -180,8 +180,8 @@ where
     pp: &PublicParams<E1>,
     vk: &VerifierKey<E1, S1, S2>,
     z0_primary: &[E1::Scalar],
-    z0_secondary: &[<SecEng<E1> as Engine>::Scalar],
-  ) -> Result<(Vec<E1::Scalar>, Vec<<SecEng<E1> as Engine>::Scalar>), SuperNovaError> {
+    z0_secondary: &[<Dual<E1> as Engine>::Scalar],
+  ) -> Result<(Vec<E1::Scalar>, Vec<<Dual<E1> as Engine>::Scalar>), SuperNovaError> {
     let last_circuit_idx = field_as_usize(self.program_counter);
 
     let num_field_primary_ro = 3 // params_next, i_new, program_counter_new
@@ -199,7 +199,7 @@ where
     // witnesses provided by the prover
     let (hash_primary, hash_secondary) = {
       let mut hasher =
-        <SecEng<E1> as Engine>::RO::new(pp.ro_consts_secondary.clone(), num_field_primary_ro);
+        <Dual<E1> as Engine>::RO::new(pp.ro_consts_secondary.clone(), num_field_primary_ro);
 
       hasher.absorb(pp.digest());
       hasher.absorb(E1::Scalar::from(self.num_steps as u64));
@@ -219,7 +219,7 @@ where
         <E1 as Engine>::RO::new(pp.ro_consts_primary.clone(), num_field_secondary_ro);
 
       hasher2.absorb(scalar_as_base::<E1>(pp.digest()));
-      hasher2.absorb(<SecEng<E1> as Engine>::Scalar::from(self.num_steps as u64));
+      hasher2.absorb(<Dual<E1> as Engine>::Scalar::from(self.num_steps as u64));
 
       for e in z0_secondary {
         hasher2.absorb(*e);
@@ -244,7 +244,7 @@ where
       return Err(NovaError::ProofVerifyError.into());
     }
 
-    if hash_secondary != scalar_as_base::<SecEng<E1>>(self.l_u_secondary.X[1]) {
+    if hash_secondary != scalar_as_base::<Dual<E1>>(self.l_u_secondary.X[1]) {
       return Err(NovaError::ProofVerifyError.into());
     }
 
@@ -439,7 +439,7 @@ mod test {
 
   impl<E1: CurveCycleEquipped> NonUniformCircuit<E1> for TestCircuit<E1> {
     type C1 = Self;
-    type C2 = TrivialSecondaryCircuit<<SecEng<E1> as Engine>::Scalar>;
+    type C2 = TrivialSecondaryCircuit<<Dual<E1> as Engine>::Scalar>;
 
     fn num_circuits(&self) -> usize {
       2
@@ -462,9 +462,9 @@ mod test {
   where
     E1: CurveCycleEquipped,
     S1: BatchedRelaxedR1CSSNARKTrait<E1>,
-    S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+    S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
     <E1::Scalar as PrimeField>::Repr: Abomonation,
-    <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+    <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
   {
     const NUM_STEPS: usize = 6;
 
@@ -474,7 +474,7 @@ mod test {
     let pp = PublicParams::setup(&test_circuits[0], &*S1::ck_floor(), &*S2::ck_floor());
 
     let z0_primary = vec![E1::Scalar::from(17u64)];
-    let z0_secondary = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+    let z0_secondary = vec![<Dual<E1> as Engine>::Scalar::ZERO];
 
     let mut recursive_snark = RecursiveSNARK::new(
       &pp,
@@ -622,7 +622,7 @@ mod test {
 
   impl<E1: CurveCycleEquipped> NonUniformCircuit<E1> for BigTestCircuit<E1> {
     type C1 = Self;
-    type C2 = TrivialSecondaryCircuit<<SecEng<E1> as Engine>::Scalar>;
+    type C2 = TrivialSecondaryCircuit<<Dual<E1> as Engine>::Scalar>;
 
     fn num_circuits(&self) -> usize {
       2
@@ -645,9 +645,9 @@ mod test {
   where
     E1: CurveCycleEquipped,
     S1: BatchedRelaxedR1CSSNARKTrait<E1>,
-    S2: RelaxedR1CSSNARKTrait<SecEng<E1>>,
+    S2: RelaxedR1CSSNARKTrait<Dual<E1>>,
     <E1::Scalar as PrimeField>::Repr: Abomonation,
-    <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+    <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
   {
     const NUM_STEPS: usize = 4;
 
@@ -657,7 +657,7 @@ mod test {
     let pp = PublicParams::setup(&test_circuits[0], &*S1::ck_floor(), &*S2::ck_floor());
 
     let z0_primary = vec![E1::Scalar::from(17u64)];
-    let z0_secondary = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+    let z0_secondary = vec![<Dual<E1> as Engine>::Scalar::ZERO];
 
     let mut recursive_snark = RecursiveSNARK::new(
       &pp,
diff --git a/src/supernova/test.rs b/src/supernova/test.rs
index 9b481cfb6..c0d8e3939 100644
--- a/src/supernova/test.rs
+++ b/src/supernova/test.rs
@@ -225,7 +225,7 @@ where
 fn print_constraints_name_on_error_index<
   E1,
   C1: StepCircuit<E1::Scalar>,
-  C2: StepCircuit<<SecEng<E1> as Engine>::Scalar>,
+  C2: StepCircuit<<Dual<E1> as Engine>::Scalar>,
 >(
   err: &SuperNovaError,
   pp: &PublicParams<E1>,
@@ -237,7 +237,7 @@ fn print_constraints_name_on_error_index<
 {
   match err {
     SuperNovaError::UnSatIndex(msg, index) if *msg == "r_primary" => {
-      let circuit_primary: SuperNovaAugmentedCircuit<'_, SecEng<E1>, C1> =
+      let circuit_primary: SuperNovaAugmentedCircuit<'_, Dual<E1>, C1> =
         SuperNovaAugmentedCircuit::new(
           &pp.augmented_circuit_params_primary,
           None,
@@ -259,7 +259,7 @@ fn print_constraints_name_on_error_index<
         pp.ro_consts_circuit_secondary.clone(),
         num_augmented_circuits,
       );
-      let mut cs: TestShapeCS<SecEng<E1>> = TestShapeCS::new();
+      let mut cs: TestShapeCS<Dual<E1>> = TestShapeCS::new();
       let _ = circuit_secondary.synthesize(&mut cs);
       cs.constraints
         .get(*index)
@@ -316,7 +316,7 @@ where
   E1: CurveCycleEquipped,
 {
   type C1 = TestROMCircuit<E1::Scalar>;
-  type C2 = TrivialSecondaryCircuit<<SecEng<E1> as Engine>::Scalar>;
+  type C2 = TrivialSecondaryCircuit<<Dual<E1> as Engine>::Scalar>;
 
   fn num_circuits(&self) -> usize {
     2
@@ -384,7 +384,7 @@ where
       .iter()
       .map(|opcode| <E1 as Engine>::Scalar::from(*opcode as u64)),
   );
-  let z0_secondary = vec![<SecEng<E1> as Engine>::Scalar::ONE];
+  let z0_secondary = vec![<Dual<E1> as Engine>::Scalar::ONE];
 
   let mut recursive_snark_option: Option<RecursiveSNARK<E1>> = None;
 
@@ -452,7 +452,7 @@ fn test_trivial_nivc() {
 fn test_recursive_circuit_with<E1>(
   primary_params: &SuperNovaAugmentedCircuitParams,
   secondary_params: &SuperNovaAugmentedCircuitParams,
-  ro_consts1: ROConstantsCircuit<SecEng<E1>>,
+  ro_consts1: ROConstantsCircuit<Dual<E1>>,
   ro_consts2: ROConstantsCircuit<E1>,
   num_constraints_primary: &Expect,
   num_constraints_secondary: &Expect,
@@ -464,8 +464,8 @@ fn test_recursive_circuit_with<E1>(
   let arity1 = step_circuit1.arity();
   let circuit1: SuperNovaAugmentedCircuit<
     '_,
-    SecEng<E1>,
-    TrivialTestCircuit<<SecEng<E1> as Engine>::Base>,
+    Dual<E1>,
+    TrivialTestCircuit<<Dual<E1> as Engine>::Base>,
   > = SuperNovaAugmentedCircuit::new(primary_params, None, &step_circuit1, ro_consts1.clone(), 2);
   let mut cs: ShapeCS<E1> = ShapeCS::new();
   if let Err(e) = circuit1.synthesize(&mut cs) {
@@ -485,7 +485,7 @@ fn test_recursive_circuit_with<E1>(
       ro_consts2.clone(),
       2,
     );
-  let mut cs: ShapeCS<SecEng<E1>> = ShapeCS::new();
+  let mut cs: ShapeCS<Dual<E1>> = ShapeCS::new();
   if let Err(e) = circuit2.synthesize(&mut cs) {
     panic!("{}", e)
   }
@@ -493,10 +493,10 @@ fn test_recursive_circuit_with<E1>(
   num_constraints_secondary.assert_eq(&cs.num_constraints().to_string());
 
   // Execute the base case for the primary
-  let zero1 = <<SecEng<E1> as Engine>::Base as Field>::ZERO;
+  let zero1 = <<Dual<E1> as Engine>::Base as Field>::ZERO;
   let z0 = vec![zero1; arity1];
   let mut cs1 = SatisfyingAssignment::<E1>::new();
-  let inputs1: SuperNovaAugmentedCircuitInputs<'_, SecEng<E1>> =
+  let inputs1: SuperNovaAugmentedCircuitInputs<'_, Dual<E1>> =
     SuperNovaAugmentedCircuitInputs::new(
       scalar_as_base::<E1>(zero1), // pass zero for testing
       zero1,
@@ -511,8 +511,8 @@ fn test_recursive_circuit_with<E1>(
   let step_circuit = TrivialTestCircuit::default();
   let circuit1: SuperNovaAugmentedCircuit<
     '_,
-    SecEng<E1>,
-    TrivialTestCircuit<<SecEng<E1> as Engine>::Base>,
+    Dual<E1>,
+    TrivialTestCircuit<<Dual<E1> as Engine>::Base>,
   > = SuperNovaAugmentedCircuit::new(primary_params, Some(inputs1), &step_circuit, ro_consts1, 2);
   if let Err(e) = circuit1.synthesize(&mut cs1) {
     panic!("{}", e)
@@ -524,9 +524,9 @@ fn test_recursive_circuit_with<E1>(
   // Execute the base case for the secondary
   let zero2 = <<E1 as Engine>::Base as Field>::ZERO;
   let z0 = vec![zero2; arity2];
-  let mut cs2 = SatisfyingAssignment::<SecEng<E1>>::new();
+  let mut cs2 = SatisfyingAssignment::<Dual<E1>>::new();
   let inputs2: SuperNovaAugmentedCircuitInputs<'_, E1> = SuperNovaAugmentedCircuitInputs::new(
-    scalar_as_base::<SecEng<E1>>(zero2), // pass zero for testing
+    scalar_as_base::<Dual<E1>>(zero2), // pass zero for testing
     zero2,
     &z0,
     None,
@@ -801,7 +801,7 @@ where
   E1: CurveCycleEquipped,
 {
   type C1 = Self;
-  type C2 = TrivialSecondaryCircuit<<SecEng<E1> as Engine>::Scalar>;
+  type C2 = TrivialSecondaryCircuit<<Dual<E1> as Engine>::Scalar>;
 
   fn num_circuits(&self) -> usize {
     2
@@ -825,7 +825,7 @@ where
   E1: CurveCycleEquipped,
   // this is due to the reliance on Abomonation
   <<E1 as Engine>::Scalar as PrimeField>::Repr: Abomonation,
-  <<SecEng<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
+  <<Dual<E1> as Engine>::Scalar as PrimeField>::Repr: Abomonation,
 {
   let circuit_secondary = TrivialSecondaryCircuit::default();
 
@@ -834,7 +834,7 @@ where
   // produce non-deterministic hint
   let (z0_primary, roots) = RootCheckingCircuit::new(num_steps);
   assert_eq!(num_steps, roots.len());
-  let z0_secondary = vec![<SecEng<E1> as Engine>::Scalar::ZERO];
+  let z0_secondary = vec![<Dual<E1> as Engine>::Scalar::ZERO];
 
   // produce public parameters
   let pp = PublicParams::<E1>::setup(&roots[0], &*default_ck_hint(), &*default_ck_hint());
diff --git a/src/traits/mod.rs b/src/traits/mod.rs
index ed67d0d68..8f2c46653 100644
--- a/src/traits/mod.rs
+++ b/src/traits/mod.rs
@@ -62,7 +62,7 @@ pub trait CurveCycleEquipped: Engine {
 }
 
 /// Convenience projection to the Secondary Engine of a CurveCycleEquipped
-pub type SecEng<E> = <E as CurveCycleEquipped>::Secondary;
+pub type Dual<E> = <E as CurveCycleEquipped>::Secondary;
 
 /// A helper trait to absorb different objects in RO
 pub trait AbsorbInROTrait<E: Engine> {