From 43f62108b3365c0124f298aa67899accadcd2485 Mon Sep 17 00:00:00 2001 From: kunxian xia Date: Mon, 21 Jul 2025 19:14:10 +0800 Subject: [PATCH] fmt whole codebase --- src/arithmetics/mod.rs | 23 +++--- src/e2e/mod.rs | 24 +++--- src/extensions/mod.rs | 12 +-- src/tower_verifier/program.rs | 60 +++++--------- src/zkvm_verifier/binding.rs | 24 ++++-- src/zkvm_verifier/verifier.rs | 145 ++++++++++++++++++++-------------- 6 files changed, 151 insertions(+), 137 deletions(-) diff --git a/src/arithmetics/mod.rs b/src/arithmetics/mod.rs index 3c12dff..68cecae 100644 --- a/src/arithmetics/mod.rs +++ b/src/arithmetics/mod.rs @@ -4,13 +4,13 @@ use ceno_mle::expression::{Expression, Fixed, Instance}; use ceno_zkvm::structs::{ChallengeId, WitnessId}; use ff_ext::ExtensionField; 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 itertools::Either; use p3_field::{FieldAlgebra, FieldExtensionAlgebra}; type E = BabyBearExt4; const HASH_RATE: usize = 8; @@ -161,7 +161,8 @@ impl PolyEvaluator { builder.range(0, idx_bound).for_each(|idx_vec, builder| { let left_idx: Usize = builder.eval(idx_vec[0] * Usize::from(2)); - let right_idx: Usize = builder.eval(idx_vec[0] * Usize::from(2) + Usize::from(1)); + let right_idx: Usize = + builder.eval(idx_vec[0] * Usize::from(2) + Usize::from(1)); let left = builder.get(&evals_ext, left_idx); let right = builder.get(&evals_ext, right_idx); @@ -418,7 +419,11 @@ pub fn eq_eval_less_or_equal_than( builder.assign(&ans, ans - v1 * running_product2 * a_i * b_i); }); - builder.assign(&running_product2, running_product2 * (a_i * b_i * bit_ext + (one_ext - a_i) * (one_ext - b_i) * (one_ext - bit_ext))); + builder.assign( + &running_product2, + running_product2 + * (a_i * b_i * bit_ext + (one_ext - a_i) * (one_ext - b_i) * (one_ext - bit_ext)), + ); builder.assign(&idx, idx - C::N::ONE); }); @@ -602,15 +607,9 @@ pub fn evaluate_ceno_expr( structural_wit_in(builder, *witness_id, *max_len, *offset, *multi_factor) } Expression::Instance(i) => instance(builder, *i), - Expression::Constant(scalar) => { - match scalar { - Either::Left(s) => { - constant(builder, E::from_base(*s)) - }, - Either::Right(s) => { - constant(builder, *s) - }, - } + Expression::Constant(scalar) => match scalar { + Either::Left(s) => constant(builder, E::from_base(*s)), + Either::Right(s) => constant(builder, *s), }, Expression::Sum(a, b) => { let a = evaluate_ceno_expr( diff --git a/src/e2e/mod.rs b/src/e2e/mod.rs index f00f0a3..229c0cd 100644 --- a/src/e2e/mod.rs +++ b/src/e2e/mod.rs @@ -22,9 +22,9 @@ use openvm_stark_sdk::config::setup_tracing_with_log_level; use openvm_stark_sdk::{ config::baby_bear_poseidon2::BabyBearPoseidon2Config, p3_baby_bear::BabyBear, }; -use std::thread; use std::collections::HashMap; use std::fs::File; +use std::thread; type SC = BabyBearPoseidon2Config; type EF = ::Challenge; @@ -129,7 +129,8 @@ pub fn parse_zkvm_proof_import( for v_vec in &opcode_proof.r_out_evals { let mut arr: Vec = vec![]; for v in v_vec { - let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); + let v_e: E = + serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); arr.push(v_e); } record_r_out_evals.push(arr); @@ -138,7 +139,8 @@ pub fn parse_zkvm_proof_import( for v_vec in &opcode_proof.w_out_evals { let mut arr: Vec = vec![]; for v in v_vec { - let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); + let v_e: E = + serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); arr.push(v_e); } record_w_out_evals.push(arr); @@ -147,7 +149,8 @@ pub fn parse_zkvm_proof_import( for v_vec in &opcode_proof.lk_out_evals { let mut arr: Vec = vec![]; for v in v_vec { - let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); + let v_e: E = + serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); arr.push(v_e); } record_lk_out_evals.push(arr); @@ -227,7 +230,7 @@ pub fn parse_zkvm_proof_import( }); } } - + let mut wits_in_evals: Vec = vec![]; for v in &opcode_proof.wits_in_evals { let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); @@ -266,7 +269,8 @@ pub fn parse_zkvm_proof_import( for v_vec in &table_proof.r_out_evals { let mut arr: Vec = vec![]; for v in v_vec { - let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); + let v_e: E = + serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); arr.push(v_e); } record_r_out_evals.push(arr); @@ -275,7 +279,8 @@ pub fn parse_zkvm_proof_import( for v_vec in &table_proof.w_out_evals { let mut arr: Vec = vec![]; for v in v_vec { - let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); + let v_e: E = + serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); arr.push(v_e); } record_w_out_evals.push(arr); @@ -284,7 +289,8 @@ pub fn parse_zkvm_proof_import( for v_vec in &table_proof.lk_out_evals { let mut arr: Vec = vec![]; for v in v_vec { - let v_e: E = serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); + let v_e: E = + serde_json::from_value(serde_json::to_value(v.clone()).unwrap()).unwrap(); arr.push(v_e); } record_lk_out_evals.push(arr); @@ -411,7 +417,7 @@ pub fn inner_test_thread() { let verifier = ZKVMVerifier::new(vk); let (zkvm_proof_input, proving_sequence) = parse_zkvm_proof_import(zkvm_proof, &verifier); - + // OpenVM DSL let mut builder = AsmBuilder::::default(); diff --git a/src/extensions/mod.rs b/src/extensions/mod.rs index 1ccb2e0..438284d 100644 --- a/src/extensions/mod.rs +++ b/src/extensions/mod.rs @@ -11,17 +11,13 @@ use crate::zkvm_verifier::verifier::verify_zkvm_proof; use crate::{ arithmetics::{ build_eq_x_r_vec_sequential, ceil_log2, concat, dot_product as ext_dot_product, - eq_eval_less_or_equal_than, eval_wellform_address_vec, - gen_alpha_pows, max_usize_arr, max_usize_vec, next_pow2_instance_padding, product, - sum as ext_sum, - }, - tower_verifier::{ - binding::PointVariable, - program::iop_verifier_state_verify, + eq_eval_less_or_equal_than, eval_wellform_address_vec, gen_alpha_pows, max_usize_arr, + max_usize_vec, next_pow2_instance_padding, product, sum as ext_sum, }, + tower_verifier::{binding::PointVariable, program::iop_verifier_state_verify}, }; -use ceno_zkvm::{circuit_builder::SetTableSpec, scheme::verifier::ZKVMVerifier}; use ceno_mle::expression::StructuralWitIn; +use ceno_zkvm::{circuit_builder::SetTableSpec, scheme::verifier::ZKVMVerifier}; use ff_ext::BabyBearExt4; use itertools::interleave; use itertools::max; diff --git a/src/tower_verifier/program.rs b/src/tower_verifier/program.rs index 2c81c01..6c90245 100644 --- a/src/tower_verifier/program.rs +++ b/src/tower_verifier/program.rs @@ -1,9 +1,8 @@ -use super::binding::{ - IOPProverMessageVariable, PointAndEvalVariable, PointVariable, -}; +use super::binding::{IOPProverMessageVariable, PointAndEvalVariable, PointVariable}; use crate::arithmetics::{ - challenger_multi_observe, dot_product, eq_eval, evaluate_at_point_degree_1, extend, exts_to_felts, - fixed_dot_product, gen_alpha_pows, is_smaller_than, reverse, UniPolyExtrapolator, print_ext_arr, + challenger_multi_observe, dot_product, eq_eval, evaluate_at_point_degree_1, extend, + exts_to_felts, fixed_dot_product, gen_alpha_pows, is_smaller_than, print_ext_arr, reverse, + UniPolyExtrapolator, }; use crate::transcript::transcript_observe_label; use crate::zkvm_verifier::binding::TowerProofInputVariable; @@ -149,19 +148,13 @@ pub fn verify_tower_proof( let one: Ext = builder.constant(C::EF::ONE); let zero: Ext = builder.constant(C::EF::ZERO); - builder.assert_usize_eq( - proof.prod_specs_eval.len(), - num_prod_spec.clone(), - ); + builder.assert_usize_eq(proof.prod_specs_eval.len(), num_prod_spec.clone()); iter_zip!(builder, prod_out_evals).for_each(|ptr_vec, builder| { let ptr = ptr_vec[0]; let evals = builder.iter_ptr_get(&prod_out_evals, ptr); builder.assert_usize_eq(evals.len(), num_fanin.clone()); }); - builder.assert_usize_eq( - proof.logup_specs_eval.len(), - num_logup_spec.clone(), - ); + builder.assert_usize_eq(proof.logup_specs_eval.len(), num_logup_spec.clone()); iter_zip!(builder, logup_out_evals).for_each(|ptr_vec, builder| { let ptr = ptr_vec[0]; let evals = builder.iter_ptr_get(&logup_out_evals, ptr); @@ -206,12 +199,7 @@ pub fn verify_tower_proof( let prod_spec_point_n_eval: Array> = builder.dyn_array(num_prod_spec.clone()); - iter_zip!( - builder, - prod_out_evals, - prod_spec_point_n_eval - ) - .for_each(|ptr_vec, builder| { + iter_zip!(builder, prod_out_evals, prod_spec_point_n_eval).for_each(|ptr_vec, builder| { let ptr = ptr_vec[0]; let evals = builder.iter_ptr_get(&prod_out_evals, ptr); let e = evaluate_at_point_degree_1(builder, &evals, &initial_rt); @@ -309,8 +297,7 @@ pub fn verify_tower_proof( let curr_pt = initial_rt.clone(); let curr_eval = initial_claim.clone(); - let op_range: RVar = - builder.eval_expr(max_num_variables - Usize::from(1)); + let op_range: RVar = builder.eval_expr(max_num_variables - Usize::from(1)); let round: Felt = builder.constant(C::F::ZERO); let mut next_rt = PointAndEvalVariable { @@ -369,8 +356,7 @@ pub fn verify_tower_proof( builder.if_eq(skip, var_zero.clone()).then(|builder| { builder.if_ne(round_var, round_limit).then_or_else( |builder| { - let prod_slice = - builder.get(&proof.prod_specs_eval, spec_index); + let prod_slice = builder.get(&proof.prod_specs_eval, spec_index); let prod_round_slice = builder.get(&prod_slice, round_var); builder.assign(&prod, one * one); for j in 0..NUM_FANIN { @@ -390,11 +376,8 @@ pub fn verify_tower_proof( }); let num_variables_len = num_variables.len(); - let logup_num_variables_slice = num_variables.slice( - builder, - num_prod_spec.clone(), - num_variables_len.clone(), - ); + let logup_num_variables_slice = + num_variables.slice(builder, num_prod_spec.clone(), num_variables_len.clone()); builder .range(0, num_logup_spec.clone()) @@ -419,8 +402,7 @@ pub fn verify_tower_proof( builder.if_eq(skip, var_zero).then(|builder| { builder.if_ne(round_var, round_limit).then_or_else( |builder| { - let prod_slice = - builder.get(&proof.logup_specs_eval, spec_index); + let prod_slice = builder.get(&proof.logup_specs_eval, spec_index); let prod_round_slice = builder.get(&prod_slice, round_var); let p1 = builder.get(&prod_round_slice, 0); @@ -479,14 +461,12 @@ pub fn verify_tower_proof( builder.cycle_tracker_start("derive next layer for prod specs"); let spec_index = i_vec[0]; let skip = builder.get(&should_skip, spec_index.clone()); - let max_round = - builder.get(&num_variables, spec_index.clone()); + let max_round = builder.get(&num_variables, spec_index.clone()); let round_limit: RVar = builder.eval_expr(max_round - RVar::from(1)); // now skip is 0 if and only if current round_var is smaller than round_limit. builder.if_eq(skip, var_zero.clone()).then(|builder| { - let prod_slice = - builder.get(&proof.prod_specs_eval, spec_index); + let prod_slice = builder.get(&proof.prod_specs_eval, spec_index); let prod_round_slice = builder.get(&prod_slice, round_var); let evals = fixed_dot_product(builder, &coeffs, &prod_round_slice, zero); @@ -520,11 +500,8 @@ pub fn verify_tower_proof( let next_logup_spec_evals: Ext<::F, ::EF> = builder.eval(zero + zero); - let logup_num_variables_slice = num_variables.slice( - builder, - num_prod_spec.clone(), - num_variables_len.clone(), - ); + let logup_num_variables_slice = + num_variables.slice(builder, num_prod_spec.clone(), num_variables_len.clone()); builder .range(0, num_logup_spec.clone()) @@ -544,8 +521,7 @@ pub fn verify_tower_proof( // now skip is 0 if and only if current round_var is smaller than round_limit. builder.if_eq(skip, var_zero).then(|builder| { - let prod_slice = - builder.get(&proof.logup_specs_eval, spec_index); + let prod_slice = builder.get(&proof.logup_specs_eval, spec_index); let prod_round_slice = builder.get(&prod_slice, round_var); let p1 = builder.get(&prod_round_slice, 0); let p2 = builder.get(&prod_round_slice, 1); @@ -952,4 +928,4 @@ mod tests { unsafe { Vec::from_raw_parts(new_ptr, length, capacity) } } } -*/ \ No newline at end of file +*/ diff --git a/src/zkvm_verifier/binding.rs b/src/zkvm_verifier/binding.rs index 4d1bb25..4007238 100644 --- a/src/zkvm_verifier/binding.rs +++ b/src/zkvm_verifier/binding.rs @@ -378,9 +378,15 @@ impl Hintable for ZKVMOpcodeProofInput { let log2_num_instances = ceil_log2(next_pow2_instance); stream.extend(>::write(&log2_num_instances)); - stream.extend(>::write(&self.record_r_out_evals_len)); - stream.extend(>::write(&self.record_w_out_evals_len)); - stream.extend(>::write(&self.record_lk_out_evals_len)); + stream.extend(>::write( + &self.record_r_out_evals_len, + )); + stream.extend(>::write( + &self.record_w_out_evals_len, + )); + stream.extend(>::write( + &self.record_lk_out_evals_len, + )); stream.extend(self.record_r_out_evals.write()); stream.extend(self.record_w_out_evals.write()); @@ -463,9 +469,15 @@ impl Hintable for ZKVMTableProofInput { let log2_num_instances = ceil_log2(self.num_instances); stream.extend(>::write(&log2_num_instances)); - stream.extend(>::write(&self.record_r_out_evals_len)); - stream.extend(>::write(&self.record_w_out_evals_len)); - stream.extend(>::write(&self.record_lk_out_evals_len)); + stream.extend(>::write( + &self.record_r_out_evals_len, + )); + stream.extend(>::write( + &self.record_w_out_evals_len, + )); + stream.extend(>::write( + &self.record_lk_out_evals_len, + )); stream.extend(self.record_r_out_evals.write()); stream.extend(self.record_w_out_evals.write()); diff --git a/src/zkvm_verifier/verifier.rs b/src/zkvm_verifier/verifier.rs index a7ab5d5..699b64a 100644 --- a/src/zkvm_verifier/verifier.rs +++ b/src/zkvm_verifier/verifier.rs @@ -1,24 +1,23 @@ use super::binding::{ ZKVMOpcodeProofInputVariable, ZKVMProofInputVariable, ZKVMTableProofInputVariable, }; -use crate::arithmetics::{challenger_multi_observe, eval_ceno_expr_with_instance, print_ext_arr, print_felt_arr, PolyEvaluator, UniPolyExtrapolator}; +use crate::arithmetics::{ + challenger_multi_observe, eval_ceno_expr_with_instance, print_ext_arr, print_felt_arr, + PolyEvaluator, UniPolyExtrapolator, +}; use crate::e2e::SubcircuitParams; use crate::tower_verifier::program::verify_tower_proof; use crate::transcript::transcript_observe_label; use crate::{ arithmetics::{ build_eq_x_r_vec_sequential, ceil_log2, concat, dot_product as ext_dot_product, - eq_eval_less_or_equal_than, eval_wellform_address_vec, - gen_alpha_pows, max_usize_arr, max_usize_vec, next_pow2_instance_padding, product, nested_product, - sum as ext_sum, - }, - tower_verifier::{ - binding::PointVariable, - program::iop_verifier_state_verify, + eq_eval_less_or_equal_than, eval_wellform_address_vec, gen_alpha_pows, max_usize_arr, + max_usize_vec, nested_product, next_pow2_instance_padding, product, sum as ext_sum, }, + tower_verifier::{binding::PointVariable, program::iop_verifier_state_verify}, }; +use ceno_mle::expression::{Instance, StructuralWitIn}; use ceno_zkvm::{circuit_builder::SetTableSpec, scheme::verifier::ZKVMVerifier}; -use ceno_mle::expression::{StructuralWitIn, Instance}; use ff_ext::BabyBearExt4; use itertools::interleave; use itertools::max; @@ -154,7 +153,8 @@ pub fn verify_zkvm_proof( let dummy_table_item_multiplicity: Ext = builder.constant(C::EF::ZERO); let mut rt_points: Vec>> = Vec::with_capacity(proving_sequence.len()); - let mut evaluations: Vec>> = Vec::with_capacity(2 * proving_sequence.len()); // witin + fixed thus *2 + let mut evaluations: Vec>> = + Vec::with_capacity(2 * proving_sequence.len()); // witin + fixed thus *2 for subcircuit_params in proving_sequence { if subcircuit_params.is_opcode { @@ -187,8 +187,9 @@ pub fn verify_zkvm_proof( let num_instances = subcircuit_params.num_instances; let num_lks = cs.lk_expressions.len(); let num_padded_instance = next_pow2_instance_padding(num_instances) - num_instances; - - let new_multiplicity: Ext = builder.constant(C::EF::from_canonical_usize(num_lks * num_padded_instance)); + + let new_multiplicity: Ext = + builder.constant(C::EF::from_canonical_usize(num_lks * num_padded_instance)); builder.assign( &dummy_table_item_multiplicity, dummy_table_item_multiplicity + new_multiplicity, @@ -207,14 +208,8 @@ pub fn verify_zkvm_proof( let q1 = builder.get(&evals, 2); let q2 = builder.get(&evals, 3); - builder.assign( - &logup_sum, - logup_sum + p1 * q1.inverse(), - ); - builder.assign( - &logup_sum, - logup_sum + p2 * q2.inverse(), - ); + builder.assign(&logup_sum, logup_sum + p1 * q1.inverse()); + builder.assign(&logup_sum, logup_sum + p2 * q2.inverse()); }); } else { let table_proof = builder.get( @@ -342,17 +337,23 @@ pub fn verify_opcode_proof( let log2_r_count: Usize = Usize::from(ceil_log2(r_len)); let log2_w_count: Usize = Usize::from(ceil_log2(w_len)); let log2_lk_count: Usize = Usize::from(ceil_log2(lk_len)); - + let log2_num_instances = opcode_proof.log2_num_instances.clone(); let tower_proof = &opcode_proof.tower_proof; let num_variables: Array> = builder.dyn_array(num_batched); - builder.range(0, num_variables.len()).for_each(|idx_vec, builder| { - builder.set(&num_variables, idx_vec[0], log2_num_instances.clone()); - }); + builder + .range(0, num_variables.len()) + .for_each(|idx_vec, builder| { + builder.set(&num_variables, idx_vec[0], log2_num_instances.clone()); + }); - let prod_out_evals: Array>> = concat(builder, &opcode_proof.record_r_out_evals, &opcode_proof.record_w_out_evals); + let prod_out_evals: Array>> = concat( + builder, + &opcode_proof.record_r_out_evals, + &opcode_proof.record_w_out_evals, + ); let num_fanin: Usize = Usize::from(NUM_FANIN); let max_expr_len = *max([r_len, w_len, lk_len].iter()).unwrap(); @@ -379,7 +380,11 @@ pub fn verify_opcode_proof( let num_rw_records: Usize = builder.eval(r_counts_per_instance + w_counts_per_instance); builder.assert_usize_eq(record_evals.len(), num_rw_records.clone()); - let alpha_len = builder.eval(num_rw_records.clone() + lk_counts_per_instance + Usize::from(cs.assert_zero_sumcheck_expressions.len())); + let alpha_len = builder.eval( + num_rw_records.clone() + + lk_counts_per_instance + + Usize::from(cs.assert_zero_sumcheck_expressions.len()), + ); transcript_observe_label(builder, challenger, b"combine subset evals"); let alpha_pow = gen_alpha_pows(builder, challenger, alpha_len); @@ -398,7 +403,10 @@ pub fn verify_opcode_proof( iter_zip!(builder, alpha_logup_slice, logup_q_evals).for_each(|ptr_vec, builder| { let alpha = builder.iter_ptr_get(&alpha_logup_slice, ptr_vec[0]); let eval = builder.iter_ptr_get(&logup_q_evals, ptr_vec[1]); - builder.assign(&claim_sum, claim_sum + alpha * (eval.eval - chip_record_alpha)); + builder.assign( + &claim_sum, + claim_sum + alpha * (eval.eval - chip_record_alpha), + ); }); let log2_num_instances_var: Var = RVar::from(log2_num_instances.clone()).variable(); @@ -420,7 +428,13 @@ pub fn verify_opcode_proof( builder.cycle_tracker_end("main sumcheck"); // sel(rt, t) - let sel = eq_eval_less_or_equal_than(builder, challenger, opcode_proof, &input_opening_point, &rt.point.fs); + let sel = eq_eval_less_or_equal_than( + builder, + challenger, + opcode_proof, + &input_opening_point, + &rt.point.fs, + ); // derive r_records, w_records, lk_records from witness's evaluations let alpha_idx: Var = builder.uninit(); @@ -428,36 +442,42 @@ pub fn verify_opcode_proof( let empty_arr: Array> = builder.dyn_array(0); let rw_expressions_sum: Ext = builder.constant(C::EF::ZERO); - cs.r_expressions.iter().chain(cs.w_expressions.iter()).for_each(|expr| { - let e = eval_ceno_expr_with_instance( - builder, - &empty_arr, - &opcode_proof.wits_in_evals, - &empty_arr, - pi_evals, - challenges, - expr - ); - let alpha = builder.get(&alpha_pow, alpha_idx); - builder.assign(&alpha_idx, alpha_idx + Usize::from(1)); - builder.assign(&rw_expressions_sum, rw_expressions_sum + alpha * (e - one)) - }); + cs.r_expressions + .iter() + .chain(cs.w_expressions.iter()) + .for_each(|expr| { + let e = eval_ceno_expr_with_instance( + builder, + &empty_arr, + &opcode_proof.wits_in_evals, + &empty_arr, + pi_evals, + challenges, + expr, + ); + let alpha = builder.get(&alpha_pow, alpha_idx); + builder.assign(&alpha_idx, alpha_idx + Usize::from(1)); + builder.assign(&rw_expressions_sum, rw_expressions_sum + alpha * (e - one)) + }); builder.assign(&rw_expressions_sum, rw_expressions_sum * sel); let lk_expressions_sum: Ext = builder.constant(C::EF::ZERO); cs.lk_expressions.iter().for_each(|expr| { let e = eval_ceno_expr_with_instance( - builder, - &empty_arr, - &opcode_proof.wits_in_evals, - &empty_arr, - pi_evals, - challenges, - expr + builder, + &empty_arr, + &opcode_proof.wits_in_evals, + &empty_arr, + pi_evals, + challenges, + expr, ); let alpha = builder.get(&alpha_pow, alpha_idx); builder.assign(&alpha_idx, alpha_idx + Usize::from(1)); - builder.assign(&lk_expressions_sum, lk_expressions_sum + alpha * (e - chip_record_alpha)) + builder.assign( + &lk_expressions_sum, + lk_expressions_sum + alpha * (e - chip_record_alpha), + ) }); builder.assign(&lk_expressions_sum, lk_expressions_sum * sel); @@ -465,13 +485,13 @@ pub fn verify_opcode_proof( cs.assert_zero_sumcheck_expressions.iter().for_each(|expr| { // evaluate zero expression by all wits_in_evals because they share the unique input_opening_point opening let e = eval_ceno_expr_with_instance( - builder, - &empty_arr, - &opcode_proof.wits_in_evals, - &empty_arr, - pi_evals, - challenges, - expr + builder, + &empty_arr, + &opcode_proof.wits_in_evals, + &empty_arr, + pi_evals, + challenges, + expr, ); let alpha = builder.get(&alpha_pow, alpha_idx); builder.assign(&alpha_idx, alpha_idx + Usize::from(1)); @@ -479,7 +499,8 @@ pub fn verify_opcode_proof( }); builder.assign(&zero_expressions_sum, zero_expressions_sum * sel); - let computed_eval: Ext = builder.eval(rw_expressions_sum + lk_expressions_sum + zero_expressions_sum); + let computed_eval: Ext = + builder.eval(rw_expressions_sum + lk_expressions_sum + zero_expressions_sum); builder.assert_ext_eq(computed_eval, expected_evaluation); // verify zero expression (degree = 1) statement, thus no sumcheck @@ -491,7 +512,7 @@ pub fn verify_opcode_proof( &empty_arr, pi_evals, challenges, - expr + expr, ); builder.assert_ext_eq(e, zero); }); @@ -567,7 +588,11 @@ pub fn verify_table_proof( let max_expected_rounds = max_usize_arr(builder, &expected_rounds); let num_fanin: Usize = Usize::from(NUM_FANIN); let max_num_variables: Usize = Usize::from(max_expected_rounds); - let prod_out_evals: Array>> = concat(builder, &table_proof.record_r_out_evals, &table_proof.record_w_out_evals); + let prod_out_evals: Array>> = concat( + builder, + &table_proof.record_r_out_evals, + &table_proof.record_w_out_evals, + ); builder.cycle_tracker_start("verify tower proof"); let (rt_tower, prod_point_and_eval, logup_p_point_and_eval, logup_q_point_and_eval) =