fix some comments, remove some unsed functions

Author: TomWambsgans

crates/lean_vm/src/core/constants.rs

@@ -1,5 +1,3 @@
-//! VM constants and configuration
-
 /// Vector dimension for field operations
 pub const DIMENSION: usize = 5;
 

crates/lean_vm/src/core/mod.rs

@@ -1,5 +1,3 @@
-//! Core VM abstractions and type definitions
-
 pub mod constants;
 pub mod types;
 

crates/lean_vm/src/core/types.rs

@@ -1,5 +1,3 @@
-//! Core type definitions for the VM
-
 use p3_koala_bear::{KoalaBear, QuinticExtensionFieldKB};
 
 /// Base field type for VM operations
@@ -10,3 +8,6 @@ pub type EF = QuinticExtensionFieldKB;
 
 /// Location in source code for debugging
 pub type LocationInSourceCode = usize;
+
+/// String label for bytecode locations
+pub type Label = String;

crates/lean_vm/src/diagnostics/error.rs

@@ -1,13 +1,10 @@
-//! VM error types and execution results
-
 use crate::core::F;
 use crate::execution::Memory;
 use crate::witness::{
     WitnessDotProduct, WitnessMultilinearEval, WitnessPoseidon16, WitnessPoseidon24,
 };
 use thiserror::Error;
 
-/// Errors that can occur during VM execution
 #[derive(Debug, Clone, Error)]
 pub enum RunnerError {
     #[error("Out of memory")]
@@ -35,10 +32,8 @@ pub enum RunnerError {
     MultilinearEvalPointNotPadded,
 }
 
-/// Result type for VM operations
 pub type VMResult<T> = Result<T, RunnerError>;
 
-/// Execution result containing outputs and execution data
 #[derive(Debug)]
 pub struct ExecutionResult {
     pub no_vec_runtime_memory: usize,
@@ -51,12 +46,3 @@ pub struct ExecutionResult {
     pub dot_products: Vec<WitnessDotProduct>,
     pub multilinear_evals: Vec<WitnessMultilinearEval>,
 }
-
-impl ExecutionResult {
-    /// Check if execution was successful
-    ///
-    /// TODO: placeholder for now.
-    pub fn is_success(&self) -> bool {
-        true
-    }
-}

crates/lean_vm/src/diagnostics/mod.rs

@@ -1,4 +1,3 @@
-//! Diagnostics, error handling, and debugging utilities
 #![allow(unused_imports)]
 
 pub mod error;

crates/lean_vm/src/execution/context.rs

@@ -1,9 +1,6 @@
-//! Execution context and state management
-
 use crate::core::LocationInSourceCode;
 use std::collections::BTreeMap;
 
-/// Execution history for profiling and debugging
 #[derive(Debug, Clone, Default)]
 pub struct ExecutionHistory {
     pub lines: Vec<LocationInSourceCode>,
@@ -33,7 +30,6 @@ impl ExecutionHistory {
     }
 }
 
-/// VM execution context
 #[derive(Debug)]
 pub struct ExecutionContext<'a> {
     pub source_code: &'a str,

crates/lean_vm/src/execution/memory.rs

@@ -55,43 +55,11 @@ impl Memory {
         Ok(())
     }
 
-    /// Reads a slice of memory values
-    pub fn get_slice(&self, start: usize, len: usize) -> Result<Vec<F>, RunnerError> {
-        (start..start + len).map(|i| self.get(i)).collect()
-    }
-
-    /// Sets a slice of memory values
-    pub fn set_slice(&mut self, start: usize, values: &[F]) -> Result<(), RunnerError> {
-        for (i, &value) in values.iter().enumerate() {
-            self.set(start + i, value)?;
-        }
-        Ok(())
-    }
-
     /// Gets the current size of allocated memory
     pub const fn size(&self) -> usize {
         self.0.len()
     }
 
-    /// Checks if a memory address is initialized
-    pub fn is_initialized(&self, index: usize) -> bool {
-        self.0.get(index).and_then(|x| x.as_ref()).is_some()
-    }
-
-    /// Gets all initialized memory addresses and their values
-    pub fn initialized_entries(&self) -> Vec<(usize, F)> {
-        self.0
-            .iter()
-            .enumerate()
-            .filter_map(|(i, opt)| opt.map(|v| (i, v)))
-            .collect()
-    }
-
-    /// Clears all memory
-    pub fn clear(&mut self) {
-        self.0.clear();
-    }
-
     /// Get a vector from vectorized memory
     pub fn get_vector(&self, index: usize) -> Result<[F; VECTOR_LEN], RunnerError> {
         Ok(self.get_vectorized_slice(index, 1)?.try_into().unwrap())
@@ -107,7 +75,6 @@ impl Memory {
         Ok(EF::from_basis_coefficients_slice(&coeffs).unwrap())
     }
 
-    /// Get a vectorized slice from memory
     pub fn get_vectorized_slice(&self, index: usize, len: usize) -> Result<Vec<F>, RunnerError> {
         let start = index * VECTOR_LEN;
         let total_len = len * VECTOR_LEN;
@@ -142,133 +109,8 @@ impl Memory {
         Ok(())
     }
 
-    /// Set a vectorized slice in memory
-    pub fn set_vectorized_slice(&mut self, index: usize, value: &[F]) -> Result<(), RunnerError> {
-        assert!(value.len().is_multiple_of(VECTOR_LEN));
-        let start = index * VECTOR_LEN;
-        value
-            .iter()
-            .enumerate()
-            .try_for_each(|(i, &v)| self.set(start + i, v))
-    }
-
     /// Get a slice from memory for multilinear evaluation
     pub fn slice(&self, start: usize, len: usize) -> Result<Vec<F>, RunnerError> {
         (0..len).map(|i| self.get(start + i)).collect()
     }
 }
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_basic_memory_operations() {
-        let mut memory = Memory::empty();
-
-        // Test setting and getting values
-        memory.set(0, F::ONE).unwrap();
-        memory.set(5, F::from_usize(42)).unwrap();
-
-        assert_eq!(memory.get(0).unwrap(), F::ONE);
-        assert_eq!(memory.get(5).unwrap(), F::from_usize(42));
-
-        // Test undefined memory access
-        assert!(matches!(memory.get(1), Err(RunnerError::UndefinedMemory)));
-    }
-
-    #[test]
-    fn test_memory_already_set_error() {
-        let mut memory = Memory::empty();
-
-        memory.set(0, F::ONE).unwrap();
-        // Setting same value should work
-        memory.set(0, F::ONE).unwrap();
-
-        // Setting different value should fail
-        assert!(matches!(
-            memory.set(0, F::ZERO),
-            Err(RunnerError::MemoryAlreadySet)
-        ));
-    }
-
-    #[test]
-    fn test_memory_slices() {
-        let mut memory = Memory::empty();
-        let values = vec![F::ONE, F::ZERO, F::from_usize(42), F::from_usize(100)];
-
-        memory.set_slice(10, &values).unwrap();
-        let retrieved = memory.get_slice(10, 4).unwrap();
-
-        assert_eq!(retrieved, values);
-    }
-
-    #[test]
-    fn test_memory_initialization_and_utilities() {
-        let public_data = vec![F::ONE, F::ZERO, F::from_usize(123)];
-        let memory = Memory::new(public_data.clone());
-
-        // All public data should be initialized
-        for (i, expected) in public_data.iter().enumerate() {
-            assert!(memory.is_initialized(i));
-            assert_eq!(memory.get(i).unwrap(), *expected);
-        }
-
-        assert_eq!(memory.size(), 3);
-
-        let entries = memory.initialized_entries();
-        assert_eq!(entries.len(), 3);
-        assert_eq!(entries[0], (0, F::ONE));
-        assert_eq!(entries[2], (2, F::from_usize(123)));
-    }
-
-    #[test]
-    fn test_vectorized_operations() {
-        let mut memory = Memory::empty();
-        let vector = [F::ONE; VECTOR_LEN];
-
-        memory.set_vector(0, vector).unwrap();
-        let retrieved = memory.get_vector(0).unwrap();
-
-        assert_eq!(retrieved, vector);
-
-        // Test vectorized slice
-        let slice_data = vec![F::from_usize(1); 2 * VECTOR_LEN];
-        memory.set_vectorized_slice(1, &slice_data).unwrap();
-        let retrieved_slice = memory.get_vectorized_slice(1, 2).unwrap();
-
-        assert_eq!(retrieved_slice, slice_data);
-    }
-
-    #[test]
-    fn test_extension_field_operations() {
-        let mut memory = Memory::empty();
-
-        // Create a simple extension field element with proper dimension
-        let mut coeffs = [F::ZERO; DIMENSION];
-        coeffs[0] = F::ONE;
-        let ef_value = EF::from_basis_coefficients_slice(&coeffs).unwrap();
-
-        memory.set_ef_element(0, ef_value).unwrap();
-        let retrieved = memory.get_ef_element(0).unwrap();
-
-        assert_eq!(retrieved, ef_value);
-
-        // Test continuous slice of EF elements
-        memory.set_ef_element(DIMENSION, ef_value).unwrap();
-        let ef_slice = memory.get_continuous_slice_of_ef_elements(0, 2).unwrap();
-
-        assert_eq!(ef_slice.len(), 2);
-        assert_eq!(ef_slice[0], ef_value);
-        assert_eq!(ef_slice[1], ef_value);
-    }
-
-    #[test]
-    fn test_memory_clear() {
-        let mut memory = Memory::new(vec![F::ONE, F::ZERO]);
-        assert_eq!(memory.size(), 2);
-
-        memory.clear();
-        assert_eq!(memory.size(), 0);
-    }
-}

crates/lean_vm/src/execution/mod.rs

@@ -7,3 +7,6 @@ pub mod runner;
 pub use context::*;
 pub use memory::*;
 pub use runner::*;
+
+#[cfg(test)]
+mod tests;

crates/lean_vm/src/execution/tests.rs

@@ -0,0 +1,56 @@
+use crate::*;
+use p3_field::BasedVectorSpace;
+use p3_field::PrimeCharacteristicRing;
+
+#[test]
+fn test_basic_memory_operations() {
+    let mut memory = Memory::empty();
+
+    // Test setting and getting values
+    memory.set(0, F::ONE).unwrap();
+    memory.set(5, F::from_usize(42)).unwrap();
+
+    assert_eq!(memory.get(0).unwrap(), F::ONE);
+    assert_eq!(memory.get(5).unwrap(), F::from_usize(42));
+
+    // Test undefined memory access
+    assert!(matches!(memory.get(1), Err(RunnerError::UndefinedMemory)));
+}
+
+#[test]
+fn test_memory_already_set_error() {
+    let mut memory = Memory::empty();
+
+    memory.set(0, F::ONE).unwrap();
+    // Setting same value should work
+    memory.set(0, F::ONE).unwrap();
+
+    // Setting different value should fail
+    assert!(matches!(
+        memory.set(0, F::ZERO),
+        Err(RunnerError::MemoryAlreadySet)
+    ));
+}
+
+#[test]
+fn test_extension_field_operations() {
+    let mut memory = Memory::empty();
+
+    // Create a simple extension field element with proper dimension
+    let mut coeffs = [F::ZERO; DIMENSION];
+    coeffs[0] = F::ONE;
+    let ef_value = EF::from_basis_coefficients_slice(&coeffs).unwrap();
+
+    memory.set_ef_element(0, ef_value).unwrap();
+    let retrieved = memory.get_ef_element(0).unwrap();
+
+    assert_eq!(retrieved, ef_value);
+
+    // Test continuous slice of EF elements
+    memory.set_ef_element(DIMENSION, ef_value).unwrap();
+    let ef_slice = memory.get_continuous_slice_of_ef_elements(0, 2).unwrap();
+
+    assert_eq!(ef_slice.len(), 2);
+    assert_eq!(ef_slice[0], ef_value);
+    assert_eq!(ef_slice[1], ef_value);
+}

crates/lean_vm/src/isa/bytecode.rs

@@ -15,38 +15,6 @@ pub struct Bytecode {
     pub ending_pc: usize,
 }
 
-impl Bytecode {
-    /// Create new bytecode with the given instructions
-    pub fn new(instructions: Vec<Instruction>) -> Self {
-        Self {
-            ending_pc: instructions.len().saturating_sub(1),
-            instructions,
-            hints: BTreeMap::new(),
-            starting_frame_memory: 0,
-        }
-    }
-
-    /// Add a hint at the specified program counter
-    pub fn add_hint(&mut self, pc: usize, hint: Hint) {
-        self.hints.entry(pc).or_default().push(hint);
-    }
-
-    /// Get hints for a specific program counter
-    pub fn get_hints(&self, pc: usize) -> &[Hint] {
-        self.hints.get(&pc).map_or(&[], |v| v.as_slice())
-    }
-
-    /// Get the number of instructions
-    pub const fn len(&self) -> usize {
-        self.instructions.len()
-    }
-
-    /// Check if bytecode is empty
-    pub const fn is_empty(&self) -> bool {
-        self.instructions.is_empty()
-    }
-}
-
 impl Display for Bytecode {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         for (pc, instruction) in self.instructions.iter().enumerate() {