Orion PCS implementation prorotyped

Author: tonyfloatersu

Cargo.lock

@@ -20,7 +20,6 @@ members = [
 ]
 resolver = "2"
 
-
 [workspace.dependencies]
 ark-std = "0.4"
 ark-bn254 = "0.4.0"

Cargo.toml

@@ -23,19 +23,19 @@ pub trait FieldSerde: Sized {
     fn deserialize_from<R: Read>(reader: R) -> FieldSerdeResult<Self>;
 }
 
-macro_rules! field_serde_for_integer {
+macro_rules! field_serde_for_number {
     ($int_type: ident, $size_in_bytes: expr) => {
         impl FieldSerde for $int_type {
             /// size of the serialized bytes
             const SERIALIZED_SIZE: usize = $size_in_bytes;
 
-            /// serialize u64 into bytes
+            /// serialize number into bytes
             fn serialize_into<W: Write>(&self, mut writer: W) -> FieldSerdeResult<()> {
                 writer.write_all(&self.to_le_bytes())?;
                 Ok(())
             }
 
-            /// deserialize bytes into u64
+            /// deserialize bytes into number
             fn deserialize_from<R: Read>(mut reader: R) -> FieldSerdeResult<Self> {
                 let mut buffer = [0u8; Self::SERIALIZED_SIZE];
                 reader.read_exact(&mut buffer)?;
@@ -45,9 +45,10 @@ macro_rules! field_serde_for_integer {
     };
 }
 
-field_serde_for_integer!(u64, 8);
-field_serde_for_integer!(usize, 8);
-field_serde_for_integer!(u8, 1);
+field_serde_for_number!(u64, 8);
+field_serde_for_number!(usize, 8);
+field_serde_for_number!(u8, 1);
+field_serde_for_number!(f64, 8);
 
 impl<V: FieldSerde> FieldSerde for Vec<V> {
     const SERIALIZED_SIZE: usize = unimplemented!();

arith/src/serde.rs

@@ -168,6 +168,7 @@ impl<Cfg: GKRConfig> Prover<Cfg> {
         pcs_scratch: &mut <Cfg::PCS as PCSForExpanderGKR<Cfg::FieldConfig, Cfg::Transcript>>::ScratchPad,
         transcript: &mut Cfg::Transcript,
     ) {
+        transcript.lock_proof();
         let opening = Cfg::PCS::open(
             pcs_params,
             &self.config.mpi_config,
@@ -177,6 +178,8 @@ impl<Cfg: GKRConfig> Prover<Cfg> {
             transcript,
             pcs_scratch,
         );
+        transcript.unlock_proof();
+
         let mut buffer = vec![];
         opening.serialize_into(&mut buffer).unwrap(); // TODO: error propagation
         transcript.append_u8_slice(&buffer);

gkr/src/prover/linear_gkr.rs

@@ -360,6 +360,7 @@ impl<Cfg: GKRConfig> Verifier<Cfg> {
         )
         .unwrap();
 
+        transcript.lock_proof();
         let verified = Cfg::PCS::verify(
             pcs_params,
             &self.config.mpi_config,
@@ -370,6 +371,7 @@ impl<Cfg: GKRConfig> Verifier<Cfg> {
             transcript,
             &opening,
         );
+        transcript.unlock_proof();
 
         let mut buffer = vec![];
         opening.serialize_into(&mut buffer).unwrap(); // TODO: error propagation

gkr/src/verifier.rs

@@ -9,5 +9,20 @@ gkr_field_config = { path = "../config/gkr_field_config" }
 mpi_config = { path = "../config/mpi_config" }
 polynomials = { path = "../arith/polynomials"}
 transcript = { path = "../transcript" }
+tree = { path = "../tree" }
 
 rand.workspace = true
+ark-std.workspace = true
+thiserror.workspace = true
+
+[dev-dependencies]
+gf2 = { path = "../arith/gf2" }
+gf2_128 = { path = "../arith/gf2_128" }
+mersenne31 = { path = "../arith/mersenne31" }
+
+tynm.workspace = true
+criterion.workspace = true
+
+[[bench]]
+name = "orion"
+harness = false

poly_commit/Cargo.toml

@@ -0,0 +1,126 @@
+use std::{hint::black_box, ops::Mul};
+
+use arith::{Field, SimdField};
+use ark_std::test_rng;
+use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion};
+use gf2::{GF2x128, GF2x8, GF2};
+use gf2_128::GF2_128;
+use poly_commit::{OrionSRS, OrionScratchPad, ORION_CODE_PARAMETER_INSTANCE};
+use polynomials::MultiLinearPoly;
+use transcript::{BytesHashTranscript, Keccak256hasher, Transcript};
+use tynm::type_name;
+
+fn committing_benchmark_helper<F, EvalF, ComPackF, OpenPackF, T>(
+    c: &mut Criterion,
+    lowest_num_vars: usize,
+    highest_num_vars: usize,
+) where
+    F: Field,
+    EvalF: Field + From<F> + Mul<F, Output = EvalF>,
+    ComPackF: SimdField<Scalar = F>,
+    OpenPackF: SimdField<Scalar = F>,
+    T: Transcript<EvalF>,
+{
+    let mut group = c.benchmark_group(format!(
+        "Orion PCS committing benchmarking: F = {}, ComPackF = {}",
+        type_name::<F>(),
+        type_name::<ComPackF>(),
+    ));
+
+    let mut rng = test_rng();
+    let mut orion_scratch = OrionScratchPad::default();
+
+    for num_vars in lowest_num_vars..=highest_num_vars {
+        let poly = MultiLinearPoly::<F>::random(num_vars, &mut rng);
+
+        let orion_srs =
+            OrionSRS::from_random::<F>(num_vars, ORION_CODE_PARAMETER_INSTANCE, &mut rng);
+
+        group
+            .bench_function(
+                BenchmarkId::new(format!("{num_vars} variables"), num_vars),
+                |b| {
+                    b.iter(|| {
+                        _ = black_box(
+                            orion_srs
+                                .commit::<F, ComPackF>(&poly, &mut orion_scratch)
+                                .unwrap(),
+                        )
+                    })
+                },
+            )
+            .sample_size(10);
+    }
+}
+
+fn orion_committing_benchmark(c: &mut Criterion) {
+    committing_benchmark_helper::<
+        GF2,
+        GF2_128,
+        GF2x128,
+        GF2x8,
+        BytesHashTranscript<_, Keccak256hasher>,
+    >(c, 19, 30);
+}
+
+fn opening_benchmark_helper<F, EvalF, ComPackF, OpenPackF, T>(
+    c: &mut Criterion,
+    lowest_num_vars: usize,
+    highest_num_vars: usize,
+) where
+    F: Field,
+    EvalF: Field + From<F> + Mul<F, Output = EvalF>,
+    ComPackF: SimdField<Scalar = F>,
+    OpenPackF: SimdField<Scalar = F>,
+    T: Transcript<EvalF>,
+{
+    let mut group = c.benchmark_group(format!(
+        "Orion PCS opening benchmarking: F = {}, EvalF = {}, ComPackF = {}",
+        type_name::<F>(),
+        type_name::<EvalF>(),
+        type_name::<ComPackF>(),
+    ));
+
+    let mut rng = test_rng();
+    let mut transcript = T::new();
+    let mut orion_scratch = OrionScratchPad::default();
+
+    for num_vars in lowest_num_vars..=highest_num_vars {
+        let poly = MultiLinearPoly::<F>::random(num_vars, &mut rng);
+        let eval_point: Vec<_> = (0..num_vars)
+            .map(|_| EvalF::random_unsafe(&mut rng))
+            .collect();
+
+        let orion_srs =
+            OrionSRS::from_random::<F>(num_vars, ORION_CODE_PARAMETER_INSTANCE, &mut rng);
+
+        let _orion_commitment = orion_srs
+            .commit::<F, ComPackF>(&poly, &mut orion_scratch)
+            .unwrap();
+
+        group
+            .bench_function(
+                BenchmarkId::new(format!("{num_vars} variables"), num_vars),
+                |b| {
+                    b.iter(|| {
+                        _ = black_box(orion_srs.open::<F, EvalF, ComPackF, OpenPackF, T>(
+                            &poly,
+                            &eval_point,
+                            &mut transcript,
+                            &orion_scratch,
+                        ))
+                    })
+                },
+            )
+            .sample_size(10);
+    }
+}
+
+fn orion_opening_benchmark(c: &mut Criterion) {
+    opening_benchmark_helper::<GF2, GF2_128, GF2x128, GF2x8, BytesHashTranscript<_, Keccak256hasher>>(
+        c, 19, 30,
+    );
+}
+
+criterion_group!(bench, orion_committing_benchmark, orion_opening_benchmark);
+criterion_main!(bench);

poly_commit/benches/orion.rs

@@ -39,8 +39,13 @@ pub fn expander_pcs_init_testing_only<
     )
 }
 
+pub const PCS_SOUNDNESS_BITS: usize = 128;
+
 mod utils;
 use transcript::Transcript;
 use utils::PCSEmptyType;
 
 pub mod raw;
+
+pub mod orion;
+pub use self::orion::*;

poly_commit/src/lib.rs

@@ -0,0 +1,14 @@
+mod utils;
+pub use utils::{
+    OrionCommitment, OrionPCSError, OrionProof, OrionResult, OrionSRS, OrionScratchPad,
+    SubsetSumLUTs,
+};
+
+mod linear_code;
+pub use linear_code::{OrionCodeParameter, ORION_CODE_PARAMETER_INSTANCE};
+
+mod pcs_impl;
+mod serde;
+
+#[cfg(test)]
+mod tests;