use explicit names for instruction encoding (instead of basic integers)

Author: TomWambsgans

crates/lean_prover/vm_air/src/execution_air.rs

@@ -5,35 +5,6 @@ use p3_field::PrimeCharacteristicRing;
 use p3_matrix::Matrix;
 use witness_generation::*;
 
-/*
-
-Bytecode columns:
-
-0: OPERAND_A
-1: OPERAND_B
-2: OPERAND_C
-3: FLAG_A
-4: FLAG_B
-5: FLAG_C
-6: ADD
-7: MUL
-8: DEREF
-9: JUMP
-10: AUX
-
-Execution columns:
-
-11: VALUE_A (virtual)
-12: VALUE_B (virtual)
-13: VALUE_C (virtual)
-14: PC
-15: FP
-16: ADDR_A
-17: ADDR_B
-18: ADDR_C
-
-*/
-
 #[derive(Debug)]
 pub struct VMAir;
 

crates/lean_prover/witness_generation/src/instruction_encoder.rs

@@ -14,10 +14,10 @@ pub fn field_representation(instr: &Instruction) -> [F; N_INSTRUCTION_COLUMNS] {
         } => {
             match operation {
                 Operation::Add => {
-                    fields[6] = F::ONE;
+                    fields[COL_INDEX_ADD] = F::ONE;
                 }
                 Operation::Mul => {
-                    fields[7] = F::ONE;
+                    fields[COL_INDEX_MUL] = F::ONE;
                 }
             }
 
@@ -30,25 +30,25 @@ pub fn field_representation(instr: &Instruction) -> [F; N_INSTRUCTION_COLUMNS] {
             shift_1,
             res,
         } => {
-            fields[8] = F::ONE; // DEREF = 1
-            fields[3] = F::ZERO; // flag_A = 0
-            fields[0] = F::from_usize(*shift_0);
-            fields[5] = F::ONE; // flag_C = 1
-            fields[2] = F::from_usize(*shift_1);
+            fields[COL_INDEX_DEREF] = F::ONE;
+            fields[COL_INDEX_FLAG_A] = F::ZERO;
+            fields[COL_INDEX_OPERAND_A] = F::from_usize(*shift_0);
+            fields[COL_INDEX_FLAG_C] = F::ONE;
+            fields[COL_INDEX_OPERAND_C] = F::from_usize(*shift_1);
             match res {
                 MemOrFpOrConstant::Constant(cst) => {
-                    fields[10] = F::ONE; // AUX = 1
-                    fields[4] = F::ONE; // flag_B = 1
-                    fields[1] = *cst;
+                    fields[COL_INDEX_AUX] = F::ONE;
+                    fields[COL_INDEX_FLAG_B] = F::ONE;
+                    fields[COL_INDEX_OPERAND_B] = *cst;
                 }
                 MemOrFpOrConstant::MemoryAfterFp { offset } => {
-                    fields[10] = F::ONE; // AUX = 1
-                    fields[4] = F::ZERO; // flag_B = 0
-                    fields[1] = F::from_usize(*offset);
+                    fields[COL_INDEX_AUX] = F::ONE;
+                    fields[COL_INDEX_FLAG_B] = F::ZERO;
+                    fields[COL_INDEX_OPERAND_B] = F::from_usize(*offset);
                 }
                 MemOrFpOrConstant::Fp => {
-                    fields[10] = F::ZERO; // AUX = 0
-                    fields[4] = F::ONE; // flag_B = 1
+                    fields[COL_INDEX_AUX] = F::ZERO;
+                    fields[COL_INDEX_FLAG_B] = F::ONE;
                 }
             }
         }
@@ -58,7 +58,7 @@ pub fn field_representation(instr: &Instruction) -> [F; N_INSTRUCTION_COLUMNS] {
             dest,
             updated_fp,
         } => {
-            fields[9] = F::ONE; // JUMP = 1
+            fields[COL_INDEX_JUMP] = F::ONE;
             set_nu_a(&mut fields, condition);
             set_nu_b(&mut fields, dest);
             set_nu_c(&mut fields, updated_fp);
@@ -69,14 +69,14 @@ pub fn field_representation(instr: &Instruction) -> [F; N_INSTRUCTION_COLUMNS] {
             res,
             is_compression,
         } => {
-            fields[11] = F::ONE; // POSEIDON_16 = 1
+            fields[COL_INDEX_POSEIDON_16] = F::ONE;
             set_nu_a(&mut fields, arg_a);
             set_nu_b(&mut fields, arg_b);
             set_nu_c(&mut fields, res);
-            fields[10] = F::from_bool(*is_compression); // AUX = "is_compression"
+            fields[COL_INDEX_AUX] = F::from_bool(*is_compression); // AUX = "is_compression"
         }
         Instruction::Poseidon2_24 { arg_a, arg_b, res } => {
-            fields[12] = F::ONE; // POSEIDON_24 = 1
+            fields[COL_INDEX_POSEIDON_24] = F::ONE;
             set_nu_a(&mut fields, arg_a);
             set_nu_b(&mut fields, arg_b);
             set_nu_c(&mut fields, res);
@@ -87,11 +87,11 @@ pub fn field_representation(instr: &Instruction) -> [F; N_INSTRUCTION_COLUMNS] {
             res,
             size,
         } => {
-            fields[13] = F::ONE; // DOT_PRODUCT_EXTENSION = 1
+            fields[COL_INDEX_DOT_PRODUCT] = F::ONE;
             set_nu_a(&mut fields, arg0);
             set_nu_b(&mut fields, arg1);
             set_nu_c(&mut fields, res);
-            fields[10] = F::from_usize(*size); // AUX stores size
+            fields[COL_INDEX_AUX] = F::from_usize(*size); // AUX stores size
         }
         Instruction::MultilinearEval {
             coeffs,