remove duplicated structs

Author: TomWambsgans

Cargo.lock

@@ -24,7 +24,7 @@ pub fn compile_program(program: &str) -> (Bytecode, BTreeMap<usize, String>) {
     let intermediate_bytecode = compile_to_intermediate_bytecode(simple_program).unwrap();
     // println!("Intermediate Bytecode:\n\n{}", intermediate_bytecode.to_string());
     let compiled = compile_to_low_level_bytecode(intermediate_bytecode).unwrap();
-    println!("Compiled Program:\n\n{}", compiled.to_string());
+    println!("Compiled Program:\n\n{}", compiled);
     (compiled, function_locations)
 }
 

crates/lean_compiler/src/lib.rs

@@ -46,7 +46,7 @@ pub fn prove_execution(
         poseidons_16, // padded with empty poseidons
         poseidons_24, // padded with empty poseidons
         dot_products,
-        vm_multilinear_evals,
+        multilinear_evals: vm_multilinear_evals,
         public_memory_size,
         non_zero_memory_size,
         memory, // padded with zeros to next power of two
@@ -59,7 +59,7 @@ pub fn prove_execution(
             function_locations,
             vm_profiler,
         );
-        get_execution_trace(bytecode, &execution_result)
+        get_execution_trace(bytecode, execution_result)
     });
 
     let public_memory = &memory[..public_memory_size];

crates/lean_prover/src/prove_execution.rs

@@ -1,10 +1,9 @@
 use std::borrow::Borrow;
 
-use lean_vm::{DIMENSION, EF};
+use lean_vm::{DIMENSION, EF, WitnessDotProduct};
 use p3_air::{Air, AirBuilder, BaseAir};
 use p3_field::PrimeCharacteristicRing;
 use p3_matrix::Matrix;
-use witness_generation::WitnessDotProduct;
 
 /*
 (DIMENSION = 5)

crates/lean_prover/vm_air/src/dot_product_air.rs

@@ -11,123 +11,6 @@ use p3_symmetric::Permutation;
 use rayon::prelude::*;
 use utils::{ToUsize, get_poseidon16, get_poseidon24};
 
-#[derive(Debug)]
-pub struct WitnessDotProduct {
-    pub cycle: usize,
-    pub addr_0: usize,   // normal pointer
-    pub addr_1: usize,   // normal pointer
-    pub addr_res: usize, // normal pointer
-    pub len: usize,
-    pub slice_0: Vec<EF>,
-    pub slice_1: Vec<EF>,
-    pub res: EF,
-}
-impl WitnessDotProduct {
-    pub fn addresses_and_len_field_repr(&self) -> [F; 4] {
-        [
-            F::from_usize(self.addr_0),
-            F::from_usize(self.addr_1),
-            F::from_usize(self.addr_res),
-            F::from_usize(self.len),
-        ]
-    }
-}
-
-#[derive(Debug)]
-pub struct RowMultilinearEval {
-    pub addr_coeffs: usize,
-    pub addr_point: usize,
-    pub addr_res: usize,
-    pub point: Vec<EF>,
-    pub res: EF,
-}
-
-impl RowMultilinearEval {
-    pub fn n_vars(&self) -> usize {
-        self.point.len()
-    }
-
-    pub fn addresses_and_n_vars_field_repr(&self) -> [F; 4] {
-        [
-            F::from_usize(self.addr_coeffs),
-            F::from_usize(self.addr_point),
-            F::from_usize(self.addr_res),
-            F::from_usize(self.n_vars()),
-        ]
-    }
-}
-
-#[derive(Debug, derive_more::Deref)]
-pub struct WitnessMultilinearEval {
-    pub cycle: usize,
-    #[deref]
-    pub inner: RowMultilinearEval,
-}
-
-#[derive(Debug)]
-pub struct WitnessPoseidon16 {
-    pub cycle: Option<usize>,
-    pub addr_input_a: usize, // vectorized pointer (of size 1)
-    pub addr_input_b: usize, // vectorized pointer (of size 1)
-    pub addr_output: usize,  // vectorized pointer (of size 2)
-    pub input: [F; 16],
-    pub output: [F; 16],
-}
-
-impl WitnessPoseidon16 {
-    pub fn poseidon_of_zero() -> Self {
-        Self {
-            cycle: None,
-            addr_input_a: ZERO_VEC_PTR,
-            addr_input_b: ZERO_VEC_PTR,
-            addr_output: POSEIDON_16_NULL_HASH_PTR,
-            input: [F::ZERO; 16],
-            output: get_poseidon16().permute([F::ZERO; 16]),
-        }
-    }
-
-    pub fn addresses_field_repr(&self) -> [F; 3] {
-        [
-            F::from_usize(self.addr_input_a),
-            F::from_usize(self.addr_input_b),
-            F::from_usize(self.addr_output),
-        ]
-    }
-}
-
-#[derive(Debug)]
-pub struct WitnessPoseidon24 {
-    pub cycle: Option<usize>,
-    pub addr_input_a: usize, // vectorized pointer (of size 2)
-    pub addr_input_b: usize, // vectorized pointer (of size 1)
-    pub addr_output: usize,  // vectorized pointer (of size 1)
-    pub input: [F; 24],
-    pub output: [F; 8], // last 8 elements of the output
-}
-
-impl WitnessPoseidon24 {
-    pub fn poseidon_of_zero() -> Self {
-        Self {
-            cycle: None,
-            addr_input_a: ZERO_VEC_PTR,
-            addr_input_b: ZERO_VEC_PTR,
-            addr_output: POSEIDON_24_NULL_HASH_PTR,
-            input: [F::ZERO; 24],
-            output: get_poseidon24().permute([F::ZERO; 24])[16..24]
-                .try_into()
-                .unwrap(),
-        }
-    }
-
-    pub fn addresses_field_repr(&self) -> [F; 3] {
-        [
-            F::from_usize(self.addr_input_a),
-            F::from_usize(self.addr_input_b),
-            F::from_usize(self.addr_output),
-        ]
-    }
-}
-
 #[derive(Debug)]
 pub struct ExecutionTrace {
     pub full_trace: Vec<Vec<F>>,
@@ -136,15 +19,15 @@ pub struct ExecutionTrace {
     pub poseidons_16: Vec<WitnessPoseidon16>, // padded with empty poseidons
     pub poseidons_24: Vec<WitnessPoseidon24>, // padded with empty poseidons
     pub dot_products: Vec<WitnessDotProduct>,
-    pub vm_multilinear_evals: Vec<WitnessMultilinearEval>,
+    pub multilinear_evals: Vec<WitnessMultilinearEval>,
     pub public_memory_size: usize,
     pub non_zero_memory_size: usize,
     pub memory: Vec<F>, // of length a multiple of public_memory_size
 }
 
 pub fn get_execution_trace(
     bytecode: &Bytecode,
-    execution_result: &ExecutionResult,
+    execution_result: ExecutionResult,
 ) -> ExecutionTrace {
     assert_eq!(execution_result.pcs.len(), execution_result.fps.len());
     let n_cycles = execution_result.pcs.len();
@@ -153,10 +36,6 @@ pub fn get_execution_trace(
     let mut trace = (0..N_INSTRUCTION_COLUMNS + N_EXEC_COLUMNS)
         .map(|_| F::zero_vec(1 << log_n_cycles_rounded_up))
         .collect::<Vec<Vec<F>>>();
-    let mut poseidons_16 = Vec::new();
-    let mut poseidons_24 = Vec::new();
-    let mut dot_products = Vec::new();
-    let mut vm_multilinear_evals = Vec::new();
 
     for (cycle, (&pc, &fp)) in execution_result
         .pcs
@@ -223,60 +102,22 @@ pub fn get_execution_trace(
         .collect::<Vec<F>>();
     memory_padded.resize(memory.0.len().next_power_of_two(), F::ZERO);
 
-    // Build witnesses from VM-collected events
-    for e in &execution_result.vm_poseidon16_events {
-        poseidons_16.push(WitnessPoseidon16 {
-            cycle: Some(e.cycle),
-            addr_input_a: e.addr_input_a,
-            addr_input_b: e.addr_input_b,
-            addr_output: e.addr_output,
-            input: e.input,
-            output: e.output,
-        });
-    }
-    for e in &execution_result.vm_poseidon24_events {
-        poseidons_24.push(WitnessPoseidon24 {
-            cycle: Some(e.cycle),
-            addr_input_a: e.addr_input_a,
-            addr_input_b: e.addr_input_b,
-            addr_output: e.addr_output,
-            input: e.input,
-            output: e.output,
-        });
-    }
-    for e in &execution_result.vm_dot_product_events {
-        dot_products.push(WitnessDotProduct {
-            cycle: e.cycle,
-            addr_0: e.addr_0,
-            addr_1: e.addr_1,
-            addr_res: e.addr_res,
-            len: e.len,
-            slice_0: e.slice_0.clone(),
-            slice_1: e.slice_1.clone(),
-            res: e.res,
-        });
-    }
-    for e in &execution_result.vm_multilinear_eval_events {
-        vm_multilinear_evals.push(WitnessMultilinearEval {
-            cycle: e.cycle,
-            inner: RowMultilinearEval {
-                addr_coeffs: e.addr_coeffs,
-                addr_point: e.addr_point,
-                addr_res: e.addr_res,
-                point: e.point.clone(),
-                res: e.res,
-            },
-        });
-    }
-
-    let n_poseidons_16 = poseidons_16.len();
-    let n_poseidons_24 = poseidons_24.len();
+    let n_poseidons_16 = execution_result.poseidons_16.len();
+    let n_poseidons_24 = execution_result.poseidons_24.len();
 
     let empty_poseidon16_output = get_poseidon16().permute([F::ZERO; 16]);
     let empty_poseidon24_output = get_poseidon24().permute([F::ZERO; 24])[16..24]
         .try_into()
         .unwrap();
 
+    let ExecutionResult {
+        mut poseidons_16,
+        mut poseidons_24,
+        dot_products,
+        multilinear_evals,
+        ..
+    } = execution_result;
+
     poseidons_16.extend(
         (0..n_poseidons_16.next_power_of_two() - n_poseidons_16).map(|_| WitnessPoseidon16 {
             cycle: None,
@@ -305,7 +146,7 @@ pub fn get_execution_trace(
         poseidons_16,
         poseidons_24,
         dot_products,
-        vm_multilinear_evals,
+        multilinear_evals,
         public_memory_size: execution_result.public_memory_size,
         non_zero_memory_size: memory.0.len(),
         memory: memory_padded,

crates/lean_prover/witness_generation/src/execution_trace.rs

@@ -1,12 +1,10 @@
-use lean_vm::F;
+use lean_vm::{F, WitnessPoseidon16, WitnessPoseidon24};
 use p3_field::PrimeCharacteristicRing;
 use rayon::prelude::*;
 use utils::{
     generate_trace_poseidon_16, generate_trace_poseidon_24, padd_with_zero_to_next_power_of_two,
 };
 
-use crate::{WitnessPoseidon16, WitnessPoseidon24};
-
 pub fn build_poseidon_columns(
     poseidons_16: &[WitnessPoseidon16],
     poseidons_24: &[WitnessPoseidon24],

crates/lean_prover/witness_generation/src/poseidon_tables.rs

@@ -30,3 +30,4 @@ p3-poseidon2-air.workspace = true
 lookup.workspace = true
 sumcheck.workspace = true
 thiserror.workspace = true
+derive_more.workspace = true