Add Precompile Verification to Recursion VM Program

Cargo.toml

@@ -38,14 +38,15 @@ ark-poly = "0.5"
 ark-serialize = "0.5"
 
 # Ceno
-ceno_mle = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc", package = "multilinear_extensions" }
-ceno_sumcheck = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc", package = "sumcheck" }
-ceno_transcript = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc", package = "transcript" }
-ceno_witness = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc", package = "witness" }
-ceno_zkvm = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc" }
-ceno_emul = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc" }
-mpcs = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc" }
-ff_ext = { git = "https://github.com/scroll-tech/ceno.git", branch = "build/smaller_field_support_plonky3_539bbc" }
+ceno_mle = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support", package = "multilinear_extensions" }
+ceno_sumcheck = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support", package = "sumcheck" }
+ceno_transcript = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support", package = "transcript" }
+ceno_witness = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support", package = "witness" }
+ceno_zkvm = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support" }
+ceno_emul = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support" }
+gkr_iop = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support" }
+mpcs = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support" }
+ff_ext = { git = "https://github.com/scroll-tech/ceno.git", branch = "feat/smaller_field_support" }
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
 

scripts/e2e_test.sh

@@ -9,11 +9,11 @@ if [ ! -d "$REPO_ROOT/build/ceno" ] || [ -z "$(ls -A "$REPO_ROOT/build/ceno" 2>/
 fi
 
 # Enter the ceno directory
-cd $REPO_ROOT/build/ceno && git checkout build/smaller_field_support_plonky3_539bbc
+cd $REPO_ROOT/build/ceno && git checkout feat/smaller_field_support
 
 # Execute the ceno_zkvm e2e test
 RUST_LOG=info cargo run --release --package ceno_zkvm --bin e2e -- --platform=ceno \
-    --hints=10 --public-io=4191 examples/target/riscv32im-ceno-zkvm-elf/release/examples/fibonacci \
+    examples/target/riscv32im-ceno-zkvm-elf/release/examples/keccak_syscall \
     --field=baby-bear
 
 mkdir -p $REPO_ROOT/src/e2e/encoded

src/arithmetics/mod.rs

@@ -7,30 +7,26 @@ use ff_ext::{BabyBearExt4, SmallField};
 use itertools::Either;
 use openvm_native_compiler::prelude::*;
 use openvm_native_compiler_derive::iter_zip;
-use openvm_native_recursion::challenger::ChallengerVariable;
-use openvm_native_recursion::challenger::{
-    duplex::DuplexChallengerVariable, CanObserveVariable, FeltChallenger,
-};
-use p3_field::{FieldAlgebra, FieldExtensionAlgebra};
+use openvm_native_recursion::challenger::{duplex::DuplexChallengerVariable, FeltChallenger};
+use openvm_stark_backend::p3_field::{FieldAlgebra, FieldExtensionAlgebra};
 type E = BabyBearExt4;
-const HASH_RATE: usize = 8;
 const MAX_NUM_VARS: usize = 25;
 
-pub fn print_ext_arr<C: Config>(builder: &mut Builder<C>, arr: &Array<C, Ext<C::F, C::EF>>) {
+pub fn _print_ext_arr<C: Config>(builder: &mut Builder<C>, arr: &Array<C, Ext<C::F, C::EF>>) {
     iter_zip!(builder, arr).for_each(|ptr_vec, builder| {
         let e = builder.iter_ptr_get(arr, ptr_vec[0]);
         builder.print_e(e);
     });
 }
 
-pub fn print_felt_arr<C: Config>(builder: &mut Builder<C>, arr: &Array<C, Felt<C::F>>) {
+pub fn _print_felt_arr<C: Config>(builder: &mut Builder<C>, arr: &Array<C, Felt<C::F>>) {
     iter_zip!(builder, arr).for_each(|ptr_vec, builder| {
         let f = builder.iter_ptr_get(arr, ptr_vec[0]);
         builder.print_f(f);
     });
 }
 
-pub fn print_usize_arr<C: Config>(builder: &mut Builder<C>, arr: &Array<C, Usize<C::N>>) {
+pub fn _print_usize_arr<C: Config>(builder: &mut Builder<C>, arr: &Array<C, Usize<C::N>>) {
     iter_zip!(builder, arr).for_each(|ptr_vec, builder| {
         let n = builder.iter_ptr_get(arr, ptr_vec[0]);
         builder.print_v(n.get_var());
@@ -204,24 +200,6 @@ pub fn dot_product<C: Config>(
     acc
 }
 
-pub fn dot_product_pt_n_eval<C: Config>(
-    builder: &mut Builder<C>,
-    pt_and_eval: &Array<C, PointAndEvalVariable<C>>,
-    b: &Array<C, Ext<C::F, C::EF>>,
-) -> Ext<<C as Config>::F, <C as Config>::EF> {
-    let acc: Ext<C::F, C::EF> = builder.eval(C::F::ZERO);
-
-    iter_zip!(builder, pt_and_eval, b).for_each(|idx_vec, builder| {
-        let ptr_a = idx_vec[0];
-        let ptr_b = idx_vec[1];
-        let v_a = builder.iter_ptr_get(&pt_and_eval, ptr_a);
-        let v_b = builder.iter_ptr_get(&b, ptr_b);
-        builder.assign(&acc, acc + v_a.eval * v_b);
-    });
-
-    acc
-}
-
 pub fn reverse<C: Config, T: MemVariable<C>>(
     builder: &mut Builder<C>,
     arr: &Array<C, T>,
@@ -321,20 +299,6 @@ pub fn eq_eval_with_index<C: Config>(
     acc
 }
 
-// Multiply all elements in the Array
-pub fn product<C: Config>(
-    builder: &mut Builder<C>,
-    arr: &Array<C, Ext<C::F, C::EF>>,
-) -> Ext<C::F, C::EF> {
-    let acc = builder.constant(C::EF::ONE);
-    iter_zip!(builder, arr).for_each(|idx_vec, builder| {
-        let el = builder.iter_ptr_get(arr, idx_vec[0]);
-        builder.assign(&acc, acc * el);
-    });
-
-    acc
-}
-
 // Multiply all elements in a nested Array
 pub fn nested_product<C: Config>(
     builder: &mut Builder<C>,
@@ -353,47 +317,6 @@ pub fn nested_product<C: Config>(
     acc
 }
 
-// Add all elements in the Array
-pub fn sum<C: Config>(
-    builder: &mut Builder<C>,
-    arr: &Array<C, Ext<C::F, C::EF>>,
-) -> Ext<C::F, C::EF> {
-    let acc = builder.constant(C::EF::ZERO);
-    iter_zip!(builder, arr).for_each(|idx_vec, builder| {
-        let el = builder.iter_ptr_get(arr, idx_vec[0]);
-        builder.assign(&acc, acc + el);
-    });
-
-    acc
-}
-
-// Join two arrays
-pub fn join<C: Config>(
-    builder: &mut Builder<C>,
-    a: &Array<C, Ext<C::F, C::EF>>,
-    b: &Array<C, Ext<C::F, C::EF>>,
-) -> Array<C, Ext<C::F, C::EF>> {
-    let a_len = a.len();
-    let b_len = b.len();
-    let out_len = builder.eval_expr(a_len.clone() + b_len.clone());
-    let out = builder.dyn_array(out_len);
-
-    builder.range(0, a_len.clone()).for_each(|i_vec, builder| {
-        let i = i_vec[0];
-        let a_val = builder.get(a, i);
-        builder.set(&out, i, a_val);
-    });
-
-    builder.range(0, b_len).for_each(|i_vec, builder| {
-        let b_i = i_vec[0];
-        let i = builder.eval_expr(b_i + a_len.clone());
-        let b_val = builder.get(b, b_i);
-        builder.set(&out, i, b_val);
-    });
-
-    out
-}
-
 // Generate alpha power challenges
 pub fn gen_alpha_pows<C: Config>(
     builder: &mut Builder<C>,
@@ -421,7 +344,6 @@ pub fn gen_alpha_pows<C: Config>(
 ///         = \sum_{\mathbf{b}=0}^{max_idx} \prod_{i=0}^{n-1} (x_i y_i b_i + (1 - x_i)(1 - y_i)(1 - b_i))
 pub fn eq_eval_less_or_equal_than<C: Config>(
     builder: &mut Builder<C>,
-    _challenger: &mut DuplexChallengerVariable<C>,
     opcode_proof: &ZKVMChipProofInputVariable<C>,
     a: &Array<C, Ext<C::F, C::EF>>,
     b: &Array<C, Ext<C::F, C::EF>>,
@@ -519,35 +441,6 @@ pub fn build_eq_x_r_vec_sequential<C: Config>(
     evals
 }
 
-pub fn build_eq_x_r_vec_sequential_with_offset<C: Config>(
-    builder: &mut Builder<C>,
-    r: &Array<C, Ext<C::F, C::EF>>,
-    offset: Usize<C::N>,
-) -> Array<C, Ext<C::F, C::EF>> {
-    // we build eq(x,r) from its evaluations
-    // we want to evaluate eq(x,r) over x \in {0, 1}^num_vars
-    // for example, with num_vars = 4, x is a binary vector of 4, then
-    //  0 0 0 0 -> (1-r0)   * (1-r1)    * (1-r2)    * (1-r3)
-    //  1 0 0 0 -> r0       * (1-r1)    * (1-r2)    * (1-r3)
-    //  0 1 0 0 -> (1-r0)   * r1        * (1-r2)    * (1-r3)
-    //  1 1 0 0 -> r0       * r1        * (1-r2)    * (1-r3)
-    //  ....
-    //  1 1 1 1 -> r0       * r1        * r2        * r3
-    // we will need 2^num_var evaluations
-
-    let r_len: Var<C::N> = builder.eval(r.len() - offset);
-    let evals_len: Felt<C::F> = builder.constant(C::F::ONE);
-    let evals_len = builder.exp_power_of_2_v::<Felt<C::F>>(evals_len, r_len);
-    let evals_len = builder.cast_felt_to_var(evals_len);
-
-    let evals: Array<C, Ext<C::F, C::EF>> = builder.dyn_array(evals_len);
-    // _debug
-    // build_eq_x_r_helper_sequential_offset(r, &mut evals, E::ONE);
-    // unsafe { std::mem::transmute(evals) }
-    // FIXME: this function is not implemented yet
-    evals
-}
-
 pub fn ceil_log2(x: usize) -> usize {
     assert!(x > 0, "ceil_log2: x must be positive");
     // Calculate the number of bits in usize

src/basefold_verifier/verifier.rs

@@ -398,7 +398,6 @@ pub mod tests {
         let executor = VmExecutor::<BabyBear, NativeConfig>::new(config);
         executor.execute(program.clone(), witness.clone()).unwrap();
 
-        // _debug
         let results = executor.execute_segments(program, witness).unwrap();
         for seg in results {
             println!("=> cycle count: {:?}", seg.metrics.cycle_count);