dev::cost: Estimate prover work for a given circuit

halo2_proofs/src/dev/cost.rs

@@ -414,6 +414,97 @@ impl<G: PrimeGroup, ConcreteCircuit: Circuit<G::Scalar>> CircuitCost<G, Concrete
             _marker: PhantomData::default(),
         }
     }
+
+    /// Returns the marginal prover work per instance of this circuit.
+    pub fn marginal_prover_work(&self) -> MarginalProverWork {
+        // Instance columns
+        // - 1 `lagrange_to_coeff` for each instance column
+        // - 1 `coeff_to_extended` for each instance column
+        // - 1 `commit_lagrange` for each instance column
+        let instance = ProverWorkContribution::new(
+            self.num_instance_columns,
+            self.num_instance_columns,
+            self.num_instance_columns,
+        );
+        // Instance columns
+        // - 1 `lagrange_to_coeff` for each advice column
+        // - 1 `coeff_to_extended` for each advice column
+        // - 1 `commit_lagrange` for each advice column
+        let advice = ProverWorkContribution::new(
+            self.num_advice_columns,
+            self.num_advice_columns,
+            self.num_advice_columns,
+        );
+        // Lookup arguments
+        // - for the permuted input expression:
+        //   - 1 `lagrange_to_coeff`
+        //   - 1 `coeff_to_extended`
+        //   - 1 `commit_lagrange`
+        // - for the permuted table expression:
+        //   - 1 `lagrange_to_coeff`
+        //   - 1 `coeff_to_extended`
+        //   - 1 `commit_lagrange`
+        // - for the lookup product:
+        //   - 1 `lagrange_to_coeff`
+        //   - 1 `coeff_to_extended`
+        //   - 1 `commit_lagrange`
+        let lookups =
+            ProverWorkContribution::new(self.lookups * 3, self.lookups * 3, self.lookups * 3);
+        // For each chunk:
+        // - 1 `lagrange_to_coeff`
+        // - 1 `coeff_to_extended`
+        // - 1 `commit_lagrange`
+        let equality = ProverWorkContribution::new(
+            self.permutation_chunks(),
+            self.permutation_chunks(),
+            self.permutation_chunks(),
+        );
+
+        MarginalProverWork {
+            instance,
+            advice,
+            lookups,
+            equality,
+        }
+    }
+
+    /// Returns the prover work for the given number of instances of this circuit.
+    pub fn prover_work(&self, instances: usize) -> ProverWork {
+        let mut extended_k = self.k;
+        let n = 1u64 << self.k;
+        while (1 << extended_k) < (n * (self.max_deg as u64 - 1)) {
+            extended_k += 1;
+        }
+
+        let marginal = self.marginal_prover_work();
+
+        // Vanishing argument
+        // - 1 `extended_to_coeff` on `h_poly`
+        // - 1 commitment to random_poly
+        // - (max_deg - 1) commitments (1 for each `h(X)` piece)
+        let vanishing = ProverWorkContribution::new(0, 1, 1 + (self.max_deg - 1));
+
+        // Multiopen argument
+        // - 1 commitment to q_prime
+        let multiopen = ProverWorkContribution::new(0, 0, 1);
+
+        // IPA polynomial commitment
+        // - 1 commitment to s_poly
+        // - the number of scalar multiplications resulting from all rounds of IPA
+        //   is equivalent to about 2 * (2 * 2^k) (excluding some constants)
+        let polycomm = ProverWorkContribution::new(0, 0, 4);
+
+        ProverWork {
+            extended_k,
+            instance: marginal.instance * instances,
+            advice: marginal.advice * instances,
+            lookups: marginal.lookups * instances,
+            equality: marginal.equality * instances,
+            vanishing,
+            multiopen,
+            polycomm,
+        }
+    }
 }
 
 /// (commitments, evaluations)
@@ -510,6 +601,72 @@ impl<G: PrimeGroup> From<ProofSize<G>> for usize {
     }
 }
 
+#[derive(Debug)]
+struct ProverWorkContribution {
+    // Number of FFTs in the 2^k domain
+    ffts: usize,
+    // Number of FFTs in the 2^extended_k domain
+    extended_ffts: usize,
+    // Number of multi-scalar multiplications of length 2^k
+    msms: usize,
+}
+
+impl ProverWorkContribution {
+    fn new(ffts: usize, extended_ffts: usize, msms: usize) -> Self {
+        ProverWorkContribution {
+            ffts,
+            extended_ffts,
+            msms,
+        }
+    }
+}
+
+impl Add for ProverWorkContribution {
+    type Output = Self;
+
+    fn add(self, rhs: Self) -> Self::Output {
+        Self {
+            ffts: self.ffts + rhs.ffts,
+            extended_ffts: self.extended_ffts + rhs.extended_ffts,
+            msms: self.msms + rhs.msms,
+        }
+    }
+}
+
+impl Mul<usize> for ProverWorkContribution {
+    type Output = Self;
+
+    fn mul(self, instances: usize) -> Self::Output {
+        Self {
+            ffts: self.ffts * instances,
+            extended_ffts: self.extended_ffts * instances,
+            msms: self.msms * instances,
+        }
+    }
+}
+
+/// The marginal prover work to generate a Halo 2 proof, broken down into its contributing factors.
+#[derive(Debug)]
+pub struct MarginalProverWork {
+    instance: ProverWorkContribution,
+    advice: ProverWorkContribution,
+    lookups: ProverWorkContribution,
+    equality: ProverWorkContribution,
+}
+
+/// The prover work to generate a Halo 2 proof, broken down into its contributing factors.
+#[derive(Debug)]
+pub struct ProverWork {
+    extended_k: u32,
+    instance: ProverWorkContribution,
+    advice: ProverWorkContribution,
+    lookups: ProverWorkContribution,
+    equality: ProverWorkContribution,
+    vanishing: ProverWorkContribution,
+    multiopen: ProverWorkContribution,
+    polycomm: ProverWorkContribution,
+}
+
 #[cfg(test)]
 mod tests {
     use pasta_curves::{Eq, Fp};