constants: add F as a constant

Author: tcoratger

crates/leanVm/src/bytecode/hint.rs

@@ -4,7 +4,7 @@ use super::operand::MemOrConstant;
 ///
 /// They are not part of the verified computation trace.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Hint<F> {
+pub enum Hint {
     /// A hint for the prover to allocate a new memory segment for a function's stack frame.
     ///
     /// This is the core mechanism for memory management in a VM without an `ap` (allocation pointer)
@@ -13,7 +13,7 @@ pub enum Hint<F> {
         /// The offset from `fp` where the pointer to the newly allocated segment will be stored.
         offset: usize,
         /// The requested size of the memory segment in scalar field elements.
-        size: MemOrConstant<F>,
+        size: MemOrConstant,
         /// If true, the start of the allocated memory is aligned to an 8-element boundary
         /// to facilitate vectorized memory access for extension field operations.
         /// The value stored at `m[fp + offset]` will be the aligned address divided by 8.
@@ -27,13 +27,13 @@ pub enum Hint<F> {
         /// The starting offset from `fp` where the resulting bits will be stored.
         res_offset: usize,
         /// The field element that needs to be decomposed into its bits.
-        to_decompose: MemOrConstant<F>,
+        to_decompose: MemOrConstant,
     },
     /// A hint used for debugging to print values from memory during execution.
     Print {
         /// A string containing line information (e.g., file and line number) for context.
         line_info: String,
         /// A list of memory locations or constants whose values should be printed.
-        content: Vec<MemOrConstant<F>>,
+        content: Vec<MemOrConstant>,
     },
 }

crates/leanVm/src/bytecode/instruction.rs

@@ -8,19 +8,19 @@ use super::{
 /// The ISA is minimal and includes basic arithmetic, memory operations, control flow,
 /// and powerful precompiles for hashing and extension field arithmetic.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Instruction<F> {
+pub enum Instruction {
     /// Performs a basic arithmetic computation: `res = arg_a op arg_b`.
     ///
     /// This corresponds to the `ADD` and `MUL` opcodes in the design document.
     Computation {
         /// The arithmetic operation to perform (`Add` or `Mul`).
         operation: Operation,
         /// The first operand of the computation.
-        arg_a: MemOrConstant<F>,
+        arg_a: MemOrConstant,
         /// The second operand of the computation.
         arg_b: MemOrFp,
         /// The memory location or constant that the result must be equal to.
-        res: MemOrConstant<F>,
+        res: MemOrConstant,
     },
     /// Performs a memory dereference: `res = m[m[fp + shift_0] + shift_1]`.
     ///
@@ -31,16 +31,16 @@ pub enum Instruction<F> {
         /// The offset added to the pointer from the first access to get the final address.
         shift_1: usize,
         /// The value that the result of the double dereference must be equal to.
-        res: MemOrFpOrConstant<F>,
+        res: MemOrFpOrConstant,
     },
     /// A conditional jump, called `JUZ` (Jump Unless Zero).
     ///
     /// Changes the `pc` if `condition` is non-zero.
     JumpIfNotZero {
         /// The value to check. The jump is taken if this value is not zero.
-        condition: MemOrConstant<F>,
+        condition: MemOrConstant,
         /// The destination `pc` for the jump.
-        dest: MemOrConstant<F>,
+        dest: MemOrConstant,
         /// The new value for the frame pointer (`fp`) after the instruction.
         updated_fp: MemOrFp,
     },

crates/leanVm/src/bytecode/mod.rs

@@ -10,19 +10,19 @@ pub mod operation;
 
 /// Represents the compiled bytecode of a program for the zkVM.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct Bytecode<F> {
+pub struct Bytecode {
     /// A vector of instructions that form the executable part of the program.
     ///
     /// The Program Counter (pc) iterates over this vector.
-    pub instructions: Vec<Instruction<F>>,
+    pub instructions: Vec<Instruction>,
 
     /// A map from a program counter (pc) value to a list of `Hint`s.
     ///
     /// Hints are auxiliary, non-deterministic instructions executed only by the prover.
     ///
     /// In this zkVM, they are crucial for managing memory allocations in the absence
     /// of an `ap` register.
-    pub hints: BTreeMap<usize, Vec<Hint<F>>>,
+    pub hints: BTreeMap<usize, Vec<Hint>>,
 
     /// The memory offset from the frame pointer (fp) where the public input for the program begins.
     pub public_input_start: usize,

crates/leanVm/src/bytecode/operand.rs

@@ -1,6 +1,8 @@
+use crate::constant::F;
+
 /// Represents a value that can either be a constant or a value from memory.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum MemOrConstant<F> {
+pub enum MemOrConstant {
     /// A constant value (a field element).
     Constant(F),
     /// A memory location specified by a positive offset from the frame pointer (`fp`).
@@ -14,7 +16,7 @@ pub enum MemOrConstant<F> {
 
 /// Represents a value that can be a memory location, the `fp` register itself, or a constant.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum MemOrFpOrConstant<F> {
+pub enum MemOrFpOrConstant {
     /// A memory location specified by a positive offset from `fp`. Represents `m[fp + shift]`.
     MemoryAfterFp {
         /// The offset from `fp` where the memory location is located.

crates/leanVm/src/bytecode/operation.rs

@@ -1,4 +1,6 @@
-use p3_field::PrimeField64;
+use p3_field::Field;
+
+use crate::constant::F;
 
 /// The basic arithmetic operations supported by the VM's `Computation` instruction.
 #[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
@@ -23,10 +25,8 @@ impl Operation {
     /// For example:
     /// - If `self` is `Add`, returns `a + b`.
     /// - If `self` is `Mul`, returns `a * b`.
-    pub fn compute<F>(&self, a: F, b: F) -> F
-    where
-        F: PrimeField64,
-    {
+    #[must_use]
+    pub fn compute(&self, a: F, b: F) -> F {
         match self {
             Self::Add => a + b,
             Self::Mul => a * b,
@@ -47,10 +47,8 @@ impl Operation {
     ///
     /// - `Some(a)` if the inverse exists.
     /// - `None` if the inverse does not exist (e.g., `b == 0` for `Mul`).
-    pub fn inverse_compute<F>(&self, a: F, b: F) -> Option<F>
-    where
-        F: PrimeField64,
-    {
+    #[must_use]
+    pub fn inverse_compute(&self, a: F, b: F) -> Option<F> {
         match self {
             Self::Add => Some(a - b),
             Self::Mul => (!b.is_zero()).then(|| a / b),
@@ -60,13 +58,10 @@ impl Operation {
 
 #[cfg(test)]
 mod tests {
-    use p3_baby_bear::BabyBear;
     use p3_field::PrimeCharacteristicRing;
 
     use super::*;
 
-    type F = BabyBear;
-
     #[test]
     fn test_compute_add() {
         let op = Operation::Add;

crates/leanVm/src/constant.rs

@@ -0,0 +1,4 @@
+use p3_koala_bear::KoalaBear;
+
+pub(crate) const DIMENSION: usize = 8;
+pub(crate) type F = KoalaBear;

crates/leanVm/src/context/run_context.rs

@@ -1,5 +1,3 @@
-use p3_field::PrimeField64;
-
 use crate::{
     bytecode::operand::{MemOrConstant, MemOrFp, MemOrFpOrConstant},
     errors::{memory::MemoryError, vm::VirtualMachineError},
@@ -36,14 +34,11 @@ impl RunContext {
     ///
     /// - If the operand is a constant, it returns the constant.
     /// - If it's a memory location, it computes the address relative to `fp` and fetches the value from memory.
-    pub fn value_from_mem_or_constant<F>(
+    pub fn value_from_mem_or_constant(
         &self,
-        operand: &MemOrConstant<F>,
+        operand: &MemOrConstant,
         memory: &MemoryManager,
-    ) -> Result<MemoryValue<F>, MemoryError<F>>
-    where
-        F: PrimeField64,
-    {
+    ) -> Result<MemoryValue, MemoryError> {
         match operand {
             MemOrConstant::Constant(val) => Ok(MemoryValue::Int(*val)),
             MemOrConstant::MemoryAfterFp { shift } => {
@@ -59,14 +54,11 @@ impl RunContext {
     ///
     /// - If the operand is the frame pointer `Fp`, it returns the `fp` address itself.
     /// - If it's a memory location, it computes the address relative to `fp` and fetches the value.
-    pub fn value_from_mem_or_fp<F>(
+    pub fn value_from_mem_or_fp(
         &self,
         operand: &MemOrFp,
         memory: &MemoryManager,
-    ) -> Result<MemoryValue<F>, MemoryError<F>>
-    where
-        F: PrimeField64,
-    {
+    ) -> Result<MemoryValue, MemoryError> {
         match operand {
             MemOrFp::Fp => Ok(MemoryValue::Address(self.fp)),
             MemOrFp::MemoryAfterFp { shift } => {
@@ -84,14 +76,11 @@ impl RunContext {
     /// - a constant value,
     /// - a memory location relative to `fp`,
     /// - the `fp` register itself.
-    pub fn value_from_mem_or_fp_or_constant<F>(
+    pub fn value_from_mem_or_fp_or_constant(
         &self,
-        operand: &MemOrFpOrConstant<F>,
+        operand: &MemOrFpOrConstant,
         memory: &MemoryManager,
-    ) -> Result<MemoryValue<F>, VirtualMachineError<F>>
-    where
-        F: PrimeField64,
-    {
+    ) -> Result<MemoryValue, VirtualMachineError> {
         match operand {
             MemOrFpOrConstant::Constant(val) => Ok(MemoryValue::Int(*val)),
             MemOrFpOrConstant::Fp => Ok(MemoryValue::Address(self.fp)),
@@ -107,12 +96,10 @@ impl RunContext {
 
 #[cfg(test)]
 mod tests {
-    use p3_baby_bear::BabyBear;
     use p3_field::PrimeCharacteristicRing;
 
     use super::*;
-
-    type F = BabyBear;
+    use crate::constant::F;
 
     #[test]
     fn test_get_value_constant() {
@@ -183,7 +170,7 @@ mod tests {
         // We won't insert anything, so all memory is uninitialized.
 
         // Shift = 1 → fp + 1 points to offset 1 (which is uninitialized).
-        let operand: MemOrConstant<F> = MemOrConstant::MemoryAfterFp { shift: 1 };
+        let operand: MemOrConstant = MemOrConstant::MemoryAfterFp { shift: 1 };
 
         // Set up context.
         let ctx = RunContext::new(
@@ -223,7 +210,7 @@ mod tests {
     fn test_get_value_from_mem_or_fp_or_constant_is_fp() {
         let fp_addr = MemoryAddress::new(1, 10);
         let ctx = RunContext::new(MemoryAddress::new(0, 0), fp_addr);
-        let operand = MemOrFpOrConstant::<F>::Fp;
+        let operand = MemOrFpOrConstant::Fp;
         let memory = MemoryManager::default();
         let result = ctx
             .value_from_mem_or_fp_or_constant(&operand, &memory)
@@ -235,8 +222,8 @@ mod tests {
     fn test_get_value_from_mem_or_fp_or_constant_is_mem_success() {
         let mut memory = MemoryManager::default();
         let fp = memory.add();
-        let addr_to_read = fp.add_usize::<F>(7).unwrap();
-        let expected_val = MemoryValue::<F>::Address(MemoryAddress::new(5, 5));
+        let addr_to_read = fp.add_usize(7).unwrap();
+        let expected_val = MemoryValue::Address(MemoryAddress::new(5, 5));
         memory.memory.insert(addr_to_read, expected_val).unwrap();
 
         let ctx = RunContext::new(MemoryAddress::new(0, 0), fp);