Merge branch 'master' into brian/o1js-test

Author: Geometer1729

Cargo.lock

@@ -85,6 +85,8 @@ spmc = "=0.3.0"
 strum = "0.26.1"
 strum_macros = "0.26.1"
 thiserror = { version = "2", default-features = false }
+tikv-jemalloc-ctl = { version = "0.5" }
+tikv-jemallocator = { version = "0.5" }
 tinytemplate = "1.1"
 wasm-bindgen = "=0.2.89"
 wasm-bindgen-test = ">=0.3.0"

Cargo.toml

@@ -1712,7 +1712,7 @@ These pre-computations are optimizations, in the context of normal proofs, but t
 pub struct ProverIndex<G: KimchiCurve, OpeningProof: OpenProof<G>> {
     /// constraints system polynomials
     #[serde(bound = "ConstraintSystem<G::ScalarField>: Serialize + DeserializeOwned")]
-    pub cs: ConstraintSystem<G::ScalarField>,
+    pub cs: Arc<ConstraintSystem<G::ScalarField>>,
 
     /// The symbolic linearization of our circuit, which can compile to concrete types once certain values are learned in the protocol.
     #[serde(skip)]
@@ -1732,7 +1732,7 @@ pub struct ProverIndex<G: KimchiCurve, OpeningProof: OpenProof<G>> {
     pub max_poly_size: usize,
 
     #[serde(bound = "ColumnEvaluations<G::ScalarField>: Serialize + DeserializeOwned")]
-    pub column_evaluations: ColumnEvaluations<G::ScalarField>,
+    pub column_evaluations: Arc<LazyCache<ColumnEvaluations<G::ScalarField>>>,
 
     /// The verifier index corresponding to this prover index
     #[serde(skip)]
@@ -1798,7 +1798,7 @@ pub struct VerifierIndex<G: KimchiCurve, OpeningProof: OpenProof<G>> {
     /// coefficient commitment array
     #[serde(bound = "PolyComm<G>: Serialize + DeserializeOwned")]
     pub coefficients_comm: [PolyComm<G>; COLUMNS],
-    /// coefficient commitment array
+    /// generic gate commitment array
     #[serde(bound = "PolyComm<G>: Serialize + DeserializeOwned")]
     pub generic_comm: PolyComm<G>,
 

book/src/specs/kimchi.md

@@ -57,6 +57,7 @@ pub fn caml_pasta_fp_plonk_index_create(
     runtime_tables: Vec<CamlRuntimeTableCfg<CamlFp>>,
     prev_challenges: ocaml::Int,
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> Result<CamlPastaFpPlonkIndex, ocaml::Error> {
     let gates: Vec<_> = gates
         .as_ref()
@@ -85,6 +86,7 @@ pub fn caml_pasta_fp_plonk_index_create(
         } else {
             Some(runtime_tables)
         })
+        .lazy_mode(lazy_mode)
         .build()
     {
         Err(e) => return Err(e.into()),
@@ -97,7 +99,8 @@ pub fn caml_pasta_fp_plonk_index_create(
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     // create index
-    let mut index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.clone());
+    let mut index =
+        ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.clone(), lazy_mode);
     // Compute and cache the verifier index digest
     index.compute_verifier_index_digest::<DefaultFqSponge<VestaParameters, PlonkSpongeConstantsKimchi>>();
 

kimchi-stubs/src/pasta_fp_plonk_index.rs

@@ -189,6 +189,7 @@ pub fn caml_pasta_fp_plonk_proof_create_and_verify(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_lookup(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     CamlFp,
@@ -279,13 +280,14 @@ pub fn caml_pasta_fp_plonk_proof_example_with_lookup(
         .runtime(Some(runtime_tables_setup))
         .lookup(fixed_tables)
         .public(num_public_inputs)
+        .lazy_mode(lazy_mode)
         .build()
         .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let public_input = witness[0][0];
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(
@@ -312,6 +314,7 @@ pub fn caml_pasta_fp_plonk_proof_example_with_lookup(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_foreign_field_mul(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     CamlProofWithPublic<CamlGVesta, CamlFp>,
@@ -443,12 +446,15 @@ pub fn caml_pasta_fp_plonk_proof_example_with_foreign_field_mul(
     }
 
     // Create constraint system
-    let cs = ConstraintSystem::<Fp>::create(gates).build().unwrap();
+    let cs = ConstraintSystem::<Fp>::create(gates)
+        .lazy_mode(lazy_mode)
+        .build()
+        .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(
         &group_map,
@@ -470,6 +476,7 @@ pub fn caml_pasta_fp_plonk_proof_example_with_foreign_field_mul(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_range_check(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     CamlProofWithPublic<CamlGVesta, CamlFp>,
@@ -511,12 +518,15 @@ pub fn caml_pasta_fp_plonk_proof_example_with_range_check(
     }
 
     // Create constraint system
-    let cs = ConstraintSystem::<Fp>::create(gates).build().unwrap();
+    let cs = ConstraintSystem::<Fp>::create(gates)
+        .lazy_mode(lazy_mode)
+        .build()
+        .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(
         &group_map,
@@ -538,6 +548,7 @@ pub fn caml_pasta_fp_plonk_proof_example_with_range_check(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_range_check0(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     CamlProofWithPublic<CamlGVesta, CamlFp>,
@@ -583,12 +594,15 @@ pub fn caml_pasta_fp_plonk_proof_example_with_range_check0(
     };
 
     // not sure if theres a smarter way instead of the double unwrap, but should be fine in the test
-    let cs = ConstraintSystem::<Fp>::create(gates).build().unwrap();
+    let cs = ConstraintSystem::<Fp>::create(gates)
+        .lazy_mode(lazy_mode)
+        .build()
+        .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(
         &group_map,
@@ -610,6 +624,7 @@ pub fn caml_pasta_fp_plonk_proof_example_with_range_check0(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_ffadd(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     CamlFp,
@@ -708,13 +723,14 @@ pub fn caml_pasta_fp_plonk_proof_example_with_ffadd(
     // be fine in the test
     let cs = ConstraintSystem::<Fp>::create(gates)
         .public(num_public_inputs)
+        .lazy_mode(lazy_mode)
         .build()
         .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let public_input = witness[0][0];
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(
@@ -738,6 +754,7 @@ pub fn caml_pasta_fp_plonk_proof_example_with_ffadd(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_xor(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     (CamlFp, CamlFp),
@@ -799,13 +816,14 @@ pub fn caml_pasta_fp_plonk_proof_example_with_xor(
     // be fine in the test
     let cs = ConstraintSystem::<Fp>::create(gates)
         .public(num_public_inputs)
+        .lazy_mode(lazy_mode)
         .build()
         .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let public_input = (witness[0][0], witness[0][1]);
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(
@@ -829,6 +847,7 @@ pub fn caml_pasta_fp_plonk_proof_example_with_xor(
 #[ocaml::func]
 pub fn caml_pasta_fp_plonk_proof_example_with_rot(
     srs: CamlFpSrs,
+    lazy_mode: bool,
 ) -> (
     CamlPastaFpPlonkIndex,
     (CamlFp, CamlFp),
@@ -893,13 +912,14 @@ pub fn caml_pasta_fp_plonk_proof_example_with_rot(
     // be fine in the test
     let cs = ConstraintSystem::<Fp>::create(gates)
         .public(num_public_inputs)
+        .lazy_mode(lazy_mode)
         .build()
         .unwrap();
 
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     let (endo_q, _endo_r) = endos::<Pallas>();
-    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0);
+    let index = ProverIndex::<Vesta, OpeningProof<Vesta>>::create(cs, endo_q, srs.0, lazy_mode);
     let group_map = <Vesta as CommitmentCurve>::Map::setup();
     let public_input = (witness[0][0], witness[0][1]);
     let proof = ProverProof::create_recursive::<EFqSponge, EFrSponge, _>(

kimchi-stubs/src/pasta_fp_plonk_proof.rs

@@ -57,6 +57,7 @@ pub fn caml_pasta_fq_plonk_index_create(
     runtime_tables: Vec<CamlRuntimeTableCfg<CamlFq>>,
     prev_challenges: ocaml::Int,
     srs: CamlFqSrs,
+    lazy_mode: bool,
 ) -> Result<CamlPastaFqPlonkIndex, ocaml::Error> {
     let gates: Vec<_> = gates
         .as_ref()
@@ -84,6 +85,7 @@ pub fn caml_pasta_fq_plonk_index_create(
         } else {
             Some(runtime_tables)
         })
+        .lazy_mode(lazy_mode)
         .build()
     {
         Err(e) => return Err(e.into()),
@@ -96,7 +98,8 @@ pub fn caml_pasta_fq_plonk_index_create(
     srs.0.with_lagrange_basis(cs.domain.d1);
 
     // create index
-    let mut index = ProverIndex::<Pallas, OpeningProof<Pallas>>::create(cs, endo_q, srs.clone());
+    let mut index =
+        ProverIndex::<Pallas, OpeningProof<Pallas>>::create(cs, endo_q, srs.clone(), lazy_mode);
     // Compute and cache the verifier index digest
     index.compute_verifier_index_digest::<DefaultFqSponge<PallasParameters, PlonkSpongeConstantsKimchi>>();
 

kimchi-stubs/src/pasta_fq_plonk_index.rs

@@ -13,6 +13,10 @@ license = "Apache-2.0"
 path = "src/lib.rs"
 bench = false       # needed for criterion (https://bheisler.github.io/criterion.rs/book/faq.html#cargo-bench-gives-unrecognized-option-errors-for-valid-command-line-options)
 
+[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
+tikv-jemalloc-ctl = { workspace = true }
+tikv-jemallocator = { workspace = true }
+
 [dependencies]
 ark-bn254 = { workspace = true, optional = true }
 ark-ec.workspace = true

kimchi/Cargo.toml

@@ -231,7 +231,8 @@ where
     let cs: ConstraintSystem<G::ScalarField> = rmp_serde::from_read(bytes_cs.as_slice()).unwrap();
 
     let endo = cs.endo;
-    let mut index: ProverIndex<G, OpeningProof<G>> = ProverIndex::create(cs, endo, srs.into());
+    let mut index: ProverIndex<G, OpeningProof<G>> =
+        ProverIndex::create(cs, endo, srs.into(), false);
     index.compute_verifier_index_digest::<BaseSponge>();
 
     (index, witness, runtime_tables, prev)