apply serialization trick to permutation argument too

input-output-hk · Apr 23, 2024 · f38697a · f38697a
1 parent d317e93
commit f38697a
Show file tree

Hide file tree

Showing 3 changed files with 35 additions and 10 deletions.
diff --git a/halo2_proofs/src/plonk.rs b/halo2_proofs/src/plonk.rs
@@ -19,7 +19,6 @@ use crate::poly::{
 };
 use crate::transcript::{ChallengeScalar, EncodedChallenge, Transcript};
 use crate::SerdeFormat;
-use std::time::Instant;
 
 mod assigned;
 mod circuit;
@@ -434,7 +433,8 @@ where
             .iter()
             .map(|poly| vk.domain.coeff_to_extended(poly.clone()))
             .collect();
-        let permutation = permutation::ProvingKey::read(reader, format)?;
+        let permutation =
+            permutation::ProvingKey::read(reader, format, &vk.domain, &vk.cs.permutation)?;
         let ev = Evaluator::new(vk.cs());
         Ok(Self {
             vk,

diff --git a/halo2_proofs/src/plonk/keygen.rs b/halo2_proofs/src/plonk/keygen.rs
@@ -1,6 +1,6 @@
 #![allow(clippy::int_plus_one)]
 
-use std::ops::Range;
+use std::{ops::Range, time::Instant};
 
 use ff::{Field, FromUniformBytes};
 use group::Curve;

diff --git a/halo2_proofs/src/plonk/permutation.rs b/halo2_proofs/src/plonk/permutation.rs
@@ -2,12 +2,12 @@
 
 use super::circuit::{Any, Column};
 use crate::{
-    arithmetic::CurveAffine,
+    arithmetic::{parallelize, CurveAffine},
     helpers::{
         polynomial_slice_byte_length, read_polynomial_vec, write_polynomial_slice,
         SerdeCurveAffine, SerdePrimeField,
     },
-    poly::{Coeff, ExtendedLagrangeCoeff, LagrangeCoeff, Polynomial},
+    poly::{Coeff, EvaluationDomain, ExtendedLagrangeCoeff, LagrangeCoeff, Polynomial},
     SerdeFormat,
 };
 
@@ -138,10 +138,35 @@ where
     C::Scalar: SerdePrimeField,
 {
     /// Reads proving key for a single permutation argument from buffer using `Polynomial::read`.  
-    pub(super) fn read<R: io::Read>(reader: &mut R, format: SerdeFormat) -> io::Result<Self> {
+    pub(super) fn read<R: io::Read>(
+        reader: &mut R,
+        format: SerdeFormat,
+        domain: &EvaluationDomain<C::Scalar>,
+        p: &Argument,
+    ) -> io::Result<Self> {
         let permutations = read_polynomial_vec(reader, format)?;
-        let polys = read_polynomial_vec(reader, format)?;
-        let cosets = read_polynomial_vec(reader, format)?;
+        // let polys = read_polynomial_vec(reader, format)?;
+        // let cosets = read_polynomial_vec(reader, format)?;
+        let mut polys = vec![domain.empty_coeff(); p.columns.len()];
+        {
+            parallelize(&mut polys, |o, start| {
+                for (x, poly) in o.iter_mut().enumerate() {
+                    let i = start + x;
+                    let permutation_poly = permutations[i].clone();
+                    *poly = domain.lagrange_to_coeff(permutation_poly);
+                }
+            });
+        }
+        let mut cosets = vec![domain.empty_extended(); p.columns.len()];
+        {
+            parallelize(&mut cosets, |o, start| {
+                for (x, coset) in o.iter_mut().enumerate() {
+                    let i = start + x;
+                    let poly = polys[i].clone();
+                    *coset = domain.coeff_to_extended(poly);
+                }
+            });
+        }
         Ok(ProvingKey {
             permutations,
             polys,
@@ -156,8 +181,8 @@ where
         format: SerdeFormat,
     ) -> io::Result<()> {
         write_polynomial_slice(&self.permutations, writer, format)?;
-        write_polynomial_slice(&self.polys, writer, format)?;
-        write_polynomial_slice(&self.cosets, writer, format)?;
+        //write_polynomial_slice(&self.polys, writer, format)?;
+        //write_polynomial_slice(&self.cosets, writer, format)?;
         Ok(())
     }
 }