Nova vairants (Ova) NIFS abstraction (#165)

* add NIFS trait abstraction (based on the needs for Nova, Mova, Ova), defining a common interface between the three Nova variants

The recent Ova NIFS PR #163 (https://github.com/privacy-scaling-explorations/sonobe/pull/163)
and Mova NIFS PR #161 (https://github.com/privacy-scaling-explorations/sonobe/pull/161)
PRs add Nova NIFS variants implementations which differ from Nova in the
logic done for the `E` error terms of the instances.

The current Ova implementation (https://github.com/privacy-scaling-explorations/sonobe/pull/163)
is based on the existing Nova NIFS code base and adds the modifications
to the `E` logic on top of it, and thus duplicating the code. Similarly
for the Mova NIFS impl.

The rest of the Mova & Ova schemes logic that is not yet implemented is
pretty similar to Nova one (ie. the IVC logic, the circuits and the
Decider), so ideally that can be done reusing most of the already
existing Nova code without duplicating it. This PR is a first step in
that direction for the existing Ova NIFS code.

This commit adds the NIFS trait abstraction with the idea of allowing to
reduce the amount of duplicated code for the Ova's NIFS impl on top of
the Nova's code.

* add Ova variant on top of the new NIFS trait abstraction

This is done from the existing Ova implementation at
`folding/ova/{mod.rs,nofs.rs}`, but removing when possible code that is not
needed or duplicated from the Nova logic.

* rm old Ova duplicated code

This commit combined with the other ones (add nifs abstraction & port
Ova to the nifs abstraction) allows to effectively get rid of ~400 lines
of code that were duplicated in the Ova NIFS impl from the Nova impl.

* small polishing & rebase to latest `main` branch updates

folding-schemes/src/folding/nova/traits.rs

@@ -1,4 +1,6 @@
+use ark_crypto_primitives::sponge::Absorb;
 use ark_ec::CurveGroup;
+use ark_std::fmt::Debug;
 use ark_std::{rand::RngCore, UniformRand};
 
 use super::{CommittedInstance, Witness};
@@ -6,11 +8,79 @@ use crate::arith::ArithSampler;
 use crate::arith::{r1cs::R1CS, Arith};
 use crate::commitment::CommitmentScheme;
 use crate::folding::circuits::CF1;
-use crate::folding::ova::{
-    CommittedInstance as OvaCommittedInstance, TestingWitness as OvaWitness,
-};
+use crate::transcript::Transcript;
 use crate::Error;
 
+/// Defines the NIFS (Non-Interactive Folding Scheme) trait, initially defined in
+/// [Nova](https://eprint.iacr.org/2021/370.pdf), and it's variants
+/// [Ova](https://hackmd.io/V4838nnlRKal9ZiTHiGYzw) and
+/// [Mova](https://eprint.iacr.org/2024/1220.pdf).
+/// `H` specifies whether the NIFS will use a blinding factor.
+pub trait NIFSTrait<C: CurveGroup, CS: CommitmentScheme<C, H>, const H: bool = false> {
+    type CommittedInstance: Debug + Clone + Absorb;
+    type Witness: Debug + Clone;
+    type ProverAux: Debug + Clone; // Prover's aux params
+    type VerifierAux: Debug + Clone; // Verifier's aux params
+
+    fn new_witness(w: Vec<C::ScalarField>, e_len: usize, rng: impl RngCore) -> Self::Witness;
+    fn new_instance(
+        w: &Self::Witness,
+        params: &CS::ProverParams,
+        x: Vec<C::ScalarField>,
+        aux: Vec<C::ScalarField>, // t_or_e in Ova, empty for Nova
+    ) -> Result<Self::CommittedInstance, Error>;
+
+    fn fold_witness(
+        r: C::ScalarField,
+        W: &Self::Witness, // running witness
+        w: &Self::Witness, // incoming witness
+        aux: &Self::ProverAux,
+    ) -> Result<Self::Witness, Error>;
+
+    /// computes the auxiliary parameters, eg. in Nova: (T, cmT), in Ova: T
+    fn compute_aux(
+        cs_prover_params: &CS::ProverParams,
+        r1cs: &R1CS<C::ScalarField>,
+        W_i: &Self::Witness,
+        U_i: &Self::CommittedInstance,
+        w_i: &Self::Witness,
+        u_i: &Self::CommittedInstance,
+    ) -> Result<(Self::ProverAux, Self::VerifierAux), Error>;
+
+    fn get_challenge<T: Transcript<C::ScalarField>>(
+        transcript: &mut T,
+        pp_hash: C::ScalarField, // public params hash
+        U_i: &Self::CommittedInstance,
+        u_i: &Self::CommittedInstance,
+        aux: &Self::VerifierAux, // ie. in Nova wouild be cmT, in Ova it's empty
+    ) -> Vec<bool>;
+
+    /// NIFS.P. Notice that this method is implemented at the trait level, and depends on the other
+    /// two methods `fold_witness` and `verify`.
+    fn prove(
+        r: C::ScalarField,
+        W_i: &Self::Witness,           // running witness
+        U_i: &Self::CommittedInstance, // running committed instance
+        w_i: &Self::Witness,           // incoming witness
+        u_i: &Self::CommittedInstance, // incoming committed instance
+        aux_p: &Self::ProverAux,
+        aux_v: &Self::VerifierAux,
+    ) -> Result<(Self::Witness, Self::CommittedInstance), Error> {
+        let w = Self::fold_witness(r, W_i, w_i, aux_p)?;
+        let ci = Self::verify(r, U_i, u_i, aux_v);
+        Ok((w, ci))
+    }
+
+    /// NIFS.V
+    fn verify(
+        // r comes from the transcript, and is a n-bit (N_BITS_CHALLENGE) element
+        r: C::ScalarField,
+        U_i: &Self::CommittedInstance,
+        u_i: &Self::CommittedInstance,
+        aux: &Self::VerifierAux,
+    ) -> Self::CommittedInstance;
+}
+
 /// Implements `Arith` for R1CS, where the witness is of type [`Witness`], and
 /// the committed instance is of type [`CommittedInstance`].
 ///
@@ -98,24 +168,3 @@ impl<C: CurveGroup> ArithSampler<C, Witness<C>, CommittedInstance<C>> for R1CS<C
         Ok((witness, cm_witness))
     }
 }
-
-// Sadly, this forces duplication of code. We can try to abstract with more traits if needed..
-impl<C: CurveGroup> Arith<OvaWitness<C>, OvaCommittedInstance<C>> for R1CS<CF1<C>> {
-    type Evaluation = Vec<CF1<C>>;
-
-    fn eval_relation(
-        &self,
-        w: &OvaWitness<C>,
-        u: &OvaCommittedInstance<C>,
-    ) -> Result<Self::Evaluation, Error> {
-        self.eval_at_z(&[&[u.mu], u.x.as_slice(), &w.w].concat())
-    }
-
-    fn check_evaluation(
-        w: &OvaWitness<C>,
-        _u: &OvaCommittedInstance<C>,
-        e: Self::Evaluation,
-    ) -> Result<(), Error> {
-        (w.e == e).then_some(()).ok_or(Error::NotSatisfied)
-    }
-}