instruction: generate witness for dot product

Author: tcoratger

crates/leanVm/src/air/dot_product.rs

@@ -210,14 +210,19 @@ pub fn build_dot_product_columns(witness: &[WitnessDotProduct]) -> (Vec<Vec<EF>>
 
         // The `index_a` and `index_b` columns are the memory addresses, incrementing from the start.
         index_a.extend(
-            (dot_product.addr_0..(dot_product.addr_0 + dot_product.len)).map(EF::from_usize),
+            (dot_product.addr_0.offset..(dot_product.addr_0.offset + dot_product.len))
+                .map(EF::from_usize),
         );
         index_b.extend(
-            (dot_product.addr_1..(dot_product.addr_1 + dot_product.len)).map(EF::from_usize),
+            (dot_product.addr_1.offset..(dot_product.addr_1.offset + dot_product.len))
+                .map(EF::from_usize),
         );
 
         // The `index_res` column holds the constant result address, repeated for every row.
-        index_res.extend(vec![EF::from_usize(dot_product.addr_res); dot_product.len]);
+        index_res.extend(vec![
+            EF::from_usize(dot_product.addr_res.offset);
+            dot_product.len
+        ]);
 
         // The `value_a` and `value_b` columns are direct copies of the input slices.
         value_a.extend_from_slice(&dot_product.slice_0);

crates/leanVm/src/bytecode/instruction/dot_product.rs

@@ -6,6 +6,7 @@ use crate::{
     context::run_context::RunContext,
     errors::vm::VirtualMachineError,
     memory::{address::MemoryAddress, manager::MemoryManager},
+    witness::dot_product::WitnessDotProduct,
 };
 
 /// An instruction to compute the dot product of two vectors of extension field elements.
@@ -63,4 +64,48 @@ impl DotProductInstruction {
 
         Ok(())
     }
+
+    /// Generates the witness for the dot product instruction.
+    pub fn generate_witness(
+        &self,
+        cycle: usize,
+        run_context: &RunContext,
+        memory_manager: &MemoryManager,
+    ) -> Result<WitnessDotProduct, VirtualMachineError> {
+        // Resolve pointers for inputs and result.
+        let addr_0: MemoryAddress = run_context
+            .value_from_mem_or_constant(&self.arg0, memory_manager)?
+            .try_into()?;
+        let addr_1: MemoryAddress = run_context
+            .value_from_mem_or_constant(&self.arg1, memory_manager)?
+            .try_into()?;
+        let addr_res: MemoryAddress = run_context
+            .value_from_mem_or_fp(&self.res, memory_manager)?
+            .try_into()?;
+
+        // Read the first vector slice from memory.
+        let slice_0 = memory_manager
+            .memory
+            .get_vectorized_slice_extension(addr_0, self.size)?;
+
+        // Read the second vector slice from memory.
+        let slice_1 = memory_manager
+            .memory
+            .get_vectorized_slice_extension(addr_1, self.size)?;
+
+        // Read the result from memory.
+        let res = memory_manager.memory.get_extension(addr_res)?;
+
+        // Construct and return the witness.
+        Ok(WitnessDotProduct {
+            cycle,
+            addr_0,
+            addr_1,
+            addr_res,
+            len: self.size,
+            slice_0,
+            slice_1,
+            res,
+        })
+    }
 }

crates/leanVm/src/witness/dot_product.rs

@@ -1,16 +1,16 @@
-use crate::constant::EF;
+use crate::{constant::EF, memory::address::MemoryAddress};
 
 /// Holds the high-level witness data for a single dot product precompile execution.
 #[derive(Debug)]
 pub struct WitnessDotProduct {
     /// The CPU cycle at which the dot product operation is initiated.
     pub cycle: usize,
     /// The starting memory address (vectorized pointer) of the first input slice.
-    pub addr_0: usize,
+    pub addr_0: MemoryAddress,
     /// The starting memory address (vectorized pointer) of the second input slice.
-    pub addr_1: usize,
+    pub addr_1: MemoryAddress,
     /// The memory address (vectorized pointer) where the final result is stored.
-    pub addr_res: usize,
+    pub addr_res: MemoryAddress,
     /// The number of elements in each input slice.
     pub len: usize,
     /// The actual data values of the first input slice.