Conversion to ceno ExtensionField and Transcript

Author: Kunming Jiang

circ_blocks/Cargo.lock

@@ -59,6 +59,8 @@ paste = "1"
 im = "15"
 once_cell = "1"
 regex = "1"
+ff_ext = { path = "../../ceno/ff_ext" }
+goldilocks = { git = "https://github.com/scroll-tech/ceno-Goldilocks" }
 
 [dev-dependencies]
 quickcheck = "1"

circ_blocks/Cargo.toml

@@ -13,7 +13,12 @@ use circ::target::r1cs::wit_comp::StagedWitCompEvaluator;
 use circ::target::r1cs::ProverData;
 use circ::target::r1cs::{Lc, VarType};
 use core::cmp::min;
-use libspartan::scalar::{ScalarExt2, SpartanExtensionField};
+use ff_ext::ExtensionField;
+use libspartan::{
+    bytes::{to_bytes},
+    transcript::Transcript,
+};
+use goldilocks::GoldilocksExt2;
 use rug::Integer;
 
 use std::fs::{create_dir_all, File};
@@ -31,7 +36,6 @@ use std::path::PathBuf;
 use libspartan::{
     instance::Instance, Assignment, InputsAssignment, MemsAssignment, VarsAssignment, SNARK,
 };
-use merlin::Transcript;
 use serde::{Deserialize, Serialize};
 use std::time::*;
 
@@ -361,7 +365,7 @@ impl CompileTimeKnowledge {
 }
 
 #[derive(Serialize, Deserialize)]
-struct RunTimeKnowledge<S: SpartanExtensionField + Send + Sync> {
+struct RunTimeKnowledge<E: ExtensionField + Send + Sync> {
     block_max_num_proofs: usize,
     block_num_proofs: Vec<usize>,
     consis_num_proofs: usize,
@@ -370,14 +374,14 @@ struct RunTimeKnowledge<S: SpartanExtensionField + Send + Sync> {
     total_num_phy_mem_accesses: usize,
     total_num_vir_mem_accesses: usize,
 
-    block_vars_matrix: Vec<Vec<VarsAssignment<S>>>,
-    exec_inputs: Vec<InputsAssignment<S>>,
+    block_vars_matrix: Vec<Vec<VarsAssignment<E>>>,
+    exec_inputs: Vec<InputsAssignment<E>>,
     // Initial memory state, in (addr, val, ls = STORE, ts = 0) pair, sorted by appearance in program input (the same as address order)
-    init_phy_mems_list: Vec<MemsAssignment<S>>,
-    init_vir_mems_list: Vec<MemsAssignment<S>>,
-    addr_phy_mems_list: Vec<MemsAssignment<S>>,
-    addr_vir_mems_list: Vec<MemsAssignment<S>>,
-    addr_ts_bits_list: Vec<MemsAssignment<S>>,
+    init_phy_mems_list: Vec<MemsAssignment<E>>,
+    init_vir_mems_list: Vec<MemsAssignment<E>>,
+    addr_phy_mems_list: Vec<MemsAssignment<E>>,
+    addr_vir_mems_list: Vec<MemsAssignment<E>>,
+    addr_ts_bits_list: Vec<MemsAssignment<E>>,
 
     input: Vec<[u8; 32]>,
     input_stack: Vec<[u8; 32]>,
@@ -386,7 +390,7 @@ struct RunTimeKnowledge<S: SpartanExtensionField + Send + Sync> {
     output_exec_num: usize,
 }
 
-impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
+impl<E: ExtensionField + Send + Sync> RunTimeKnowledge<E> {
     fn serialize_to_file(
         &self,
         benchmark_name: String,
@@ -455,7 +459,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
             for exec in block {
                 writeln!(&mut f, "EXEC {}", exec_counter)?;
                 for assg in &exec.assignment {
-                    write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                    write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
                 }
                 writeln!(&mut f)?;
                 exec_counter += 1;
@@ -467,7 +471,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
         for exec in &self.exec_inputs {
             writeln!(&mut f, "EXEC {}", exec_counter)?;
             for assg in &exec.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
             }
             writeln!(&mut f)?;
             exec_counter += 1;
@@ -477,7 +481,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
         for addr in &self.init_phy_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -487,7 +491,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
         for addr in &self.init_vir_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -497,7 +501,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
         for addr in &self.addr_phy_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -507,7 +511,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
         for addr in &self.addr_vir_mems_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -517,7 +521,7 @@ impl<S: SpartanExtensionField + Send + Sync> RunTimeKnowledge<S> {
         for addr in &self.addr_ts_bits_list {
             writeln!(&mut f, "ACCESS {}", addr_counter)?;
             for assg in &addr.assignment {
-                write!(&mut f, "{} ", bytes_to_integer(&assg.to_bytes()))?;
+                write!(&mut f, "{} ", bytes_to_integer(&to_bytes(*assg)))?;
             }
             writeln!(&mut f)?;
             addr_counter += 1;
@@ -850,7 +854,7 @@ fn get_compile_time_knowledge<const VERBOSE: bool>(
 // --
 // Generate witnesses and others
 // --
-fn get_run_time_knowledge<const VERBOSE: bool, S: SpartanExtensionField + Send + Sync>(
+fn get_run_time_knowledge<const VERBOSE: bool, E: ExtensionField + Send + Sync>(
     path: PathBuf,
     options: &Options,
     entry_regs: Vec<Integer>,
@@ -863,7 +867,7 @@ fn get_run_time_knowledge<const VERBOSE: bool, S: SpartanExtensionField + Send +
     prover_data_list: Vec<ProverData>,
     total_num_init_phy_mem_accesses: usize,
     total_num_init_vir_mem_accesses: usize,
-) -> RunTimeKnowledge<S> {
+) -> RunTimeKnowledge<E> {
     let num_blocks = ctk.block_num_instances;
     let num_input_unpadded = ctk.num_inputs_unpadded;
     let io_width = 2 * num_input_unpadded;
@@ -1285,9 +1289,9 @@ fn get_run_time_knowledge<const VERBOSE: bool, S: SpartanExtensionField + Send +
     }
 }
 
-fn run_spartan_proof<S: SpartanExtensionField + Send + Sync>(
+fn run_spartan_proof<E: ExtensionField + Send + Sync>(
     ctk: CompileTimeKnowledge,
-    rtk: RunTimeKnowledge<S>,
+    rtk: RunTimeKnowledge<E>,
 ) {
     // --
     // INSTANCE PREPROCESSING
@@ -1329,7 +1333,7 @@ fn run_spartan_proof<S: SpartanExtensionField + Send + Sync>(
             &rtk.block_num_proofs,
         );
     // block_inst is used by commitment. Every block has different number of variables
-    let (_, _, _, block_inst_for_commit) = Instance::<S>::gen_block_inst::<true, true>(
+    let (_, _, _, block_inst_for_commit) = Instance::<E>::gen_block_inst::<true, true>(
         block_num_instances_bound,
         num_vars,
         &ctk.args,
@@ -1600,7 +1604,7 @@ fn main() {
     // --
     // Generate Witnesses
     // --
-    let rtk = get_run_time_knowledge::<false, ScalarExt2>(
+    let rtk = get_run_time_knowledge::<false, GoldilocksExt2>(
         path.clone(),
         &options,
         entry_regs,
@@ -1634,4 +1638,4 @@ fn main() {
 
     println!("Compiler time: {}ms", compiler_time.as_millis());
     println!("\n--\nWitness time: {}ms", witness_time.as_millis());
-}
+}

circ_blocks/examples/zxc.rs

@@ -30,6 +30,8 @@ colored = { version = "2", default-features = false, optional = true }
 flate2 = { version = "1" }
 goldilocks = { git = "https://github.com/scroll-tech/ceno-Goldilocks" }
 ff = "0.13.0"
+ff_ext = { path = "../../ceno/ff_ext" }
+transcript = { path = "../../ceno/transcript" }
 
 [dev-dependencies]
 criterion = "0.5"

spartan_parallel/Cargo.toml

@@ -4,10 +4,9 @@
 use std::io::{BufRead, Read};
 use std::{default, env};
 use std::{fs::File, io::BufReader};
-
-use libspartan::scalar::{ScalarExt2, SpartanExtensionField};
-use libspartan::{instance::Instance, InputsAssignment, MemsAssignment, VarsAssignment, SNARK};
-use merlin::Transcript;
+use ff_ext::ExtensionField;
+use goldilocks::GoldilocksExt2;
+use libspartan::{instance::Instance, InputsAssignment, MemsAssignment, VarsAssignment, SNARK, transcript::Transcript};
 use serde::{Deserialize, Serialize};
 use std::time::*;
 
@@ -59,7 +58,7 @@ impl CompileTimeKnowledge {
 
 // Everything provided by the prover
 #[derive(Serialize, Deserialize)]
-struct RunTimeKnowledge<S: SpartanExtensionField> {
+struct RunTimeKnowledge<E: ExtensionField> {
   block_max_num_proofs: usize,
   block_num_proofs: Vec<usize>,
   consis_num_proofs: usize,
@@ -68,13 +67,13 @@ struct RunTimeKnowledge<S: SpartanExtensionField> {
   total_num_phy_mem_accesses: usize,
   total_num_vir_mem_accesses: usize,
 
-  block_vars_matrix: Vec<Vec<VarsAssignment<S>>>,
-  exec_inputs: Vec<InputsAssignment<S>>,
-  init_phy_mems_list: Vec<MemsAssignment<S>>,
-  init_vir_mems_list: Vec<MemsAssignment<S>>,
-  addr_phy_mems_list: Vec<MemsAssignment<S>>,
-  addr_vir_mems_list: Vec<MemsAssignment<S>>,
-  addr_ts_bits_list: Vec<MemsAssignment<S>>,
+  block_vars_matrix: Vec<Vec<VarsAssignment<E>>>,
+  exec_inputs: Vec<InputsAssignment<E>>,
+  init_phy_mems_list: Vec<MemsAssignment<E>>,
+  init_vir_mems_list: Vec<MemsAssignment<E>>,
+  addr_phy_mems_list: Vec<MemsAssignment<E>>,
+  addr_vir_mems_list: Vec<MemsAssignment<E>>,
+  addr_ts_bits_list: Vec<MemsAssignment<E>>,
 
   input: Vec<[u8; 32]>,
   input_stack: Vec<[u8; 32]>,
@@ -83,8 +82,8 @@ struct RunTimeKnowledge<S: SpartanExtensionField> {
   output_exec_num: usize,
 }
 
-impl<S: SpartanExtensionField + for<'de> serde::de::Deserialize<'de>> RunTimeKnowledge<S> {
-  fn deserialize_from_file(benchmark_name: String) -> RunTimeKnowledge<S> {
+impl<E: ExtensionField + for<'de> serde::de::Deserialize<'de>> RunTimeKnowledge<E> {
+  fn deserialize_from_file(benchmark_name: String) -> RunTimeKnowledge<E> {
     // Input can be provided through multiple files, use i to determine the next file label
     let mut i = 0;
     let mut file_name = format!("../zok_tests/inputs/{benchmark_name}_bin_{i}.rtk");
@@ -105,7 +104,7 @@ fn main() {
   // let ctk = CompileTimeKnowledge::read_from_file(benchmark_name.to_string()).unwrap();
   let ctk = CompileTimeKnowledge::deserialize_from_file(benchmark_name.to_string());
   // let rtk = RunTimeKnowledge::read_from_file(benchmark_name.to_string()).unwrap();
-  let rtk: RunTimeKnowledge<ScalarExt2> =
+  let rtk: RunTimeKnowledge<GoldilocksExt2> =
     RunTimeKnowledge::deserialize_from_file(benchmark_name.to_string());
 
   // --
@@ -148,7 +147,7 @@ fn main() {
       &rtk.block_num_proofs,
     );
   // block_inst is used by commitment. Every block has different number of variables
-  let (_, _, _, block_inst_for_commit) = Instance::<ScalarExt2>::gen_block_inst::<true, true>(
+  let (_, _, _, block_inst_for_commit) = Instance::<GoldilocksExt2>::gen_block_inst::<true, true>(
     block_num_instances_bound,
     num_vars,
     &ctk.args,

spartan_parallel/examples/interface.rs

@@ -0,0 +1,30 @@
+use ff_ext::ExtensionField;
+use subtle::{Choice, CtOption};
+
+/// Attempts to convert a little-endian byte representation of
+/// a field element into an `ExtensionField`, failing if the input is not canonical.
+pub fn from_bytes<E: ExtensionField>(bytes: &[u8; 32]) -> CtOption<E> {
+    let mut padded = [0u8; 64];
+    padded[..32].copy_from_slice(bytes);
+
+    CtOption::new(
+        E::from_uniform_bytes(&padded),
+        Choice::from(1u8),
+    )
+}
+
+/// Converts an element of `ExtensionField` into a byte representation in
+/// little-endian byte order.
+pub fn to_bytes<E: ExtensionField>(num: E) -> [u8; 32] {
+    let mut res = [0; 32];
+    let els = num.to_canonical_u64_vec();
+    res[..8].copy_from_slice(&els[0].to_le_bytes());
+    res[8..16].copy_from_slice(&els[1].to_le_bytes());
+    res
+}
+
+/// Converts a 512-bit little endian integer into
+/// an `ExtensionField` element by reducing by the modulus.
+pub fn from_bytes_wide<E: ExtensionField>(bytes: &[u8; 64]) -> E {
+    E::from_uniform_bytes(bytes).into()
+}