feat: v1 prove method + program table (#15)

* v1 coordinator * v1 coordinator * resolve merge conflicts * v1 program table
succinctlabs · Dec 13, 2023 · 895cb48 · 895cb48
1 parent 80b819e
commit 895cb48
Show file tree

Hide file tree

Showing 11 changed files with 584 additions and 455 deletions.
diff --git a/core/src/alu/add/mod.rs b/core/src/alu/add/mod.rs
@@ -14,8 +14,6 @@ use crate::lookup::Interaction;
 use crate::utils::{pad_to_power_of_two, Chip};
 use crate::Runtime;
 
-use super::AluEvent;
-
 pub const NUM_ADD_COLS: usize = size_of::<AddCols<u8>>();
 
 /// The column layout for the chip.
@@ -35,15 +33,19 @@ pub struct AddCols<T> {
 }
 
 /// A chip that implements addition for the opcodes ADD and ADDI.
-pub struct AddChip {
-    events: Vec<AluEvent>,
+pub struct AddChip;
+
+impl AddChip {
+    pub fn new() -> Self {
+        Self {}
+    }
 }
 
 impl<F: PrimeField> Chip<F> for AddChip {
-    fn generate_trace(&self, _: &mut Runtime) -> RowMajorMatrix<F> {
+    fn generate_trace(&self, runtime: &mut Runtime) -> RowMajorMatrix<F> {
         // Generate the trace rows for each event.
-        let rows = self
-            .events
+        let rows = runtime
+            .add_events
             .par_iter()
             .map(|event| {
                 let mut row = [F::zero(); NUM_ADD_COLS];
@@ -165,14 +167,8 @@ mod tests {
     fn generate_trace() {
         let program = vec![];
         let mut runtime = Runtime::new(program);
-        let events = vec![AluEvent {
-            clk: 0,
-            opcode: Opcode::ADD,
-            a: 14,
-            b: 8,
-            c: 6,
-        }];
-        let chip = AddChip { events };
+        runtime.add_events = vec![AluEvent::new(0, Opcode::ADD, 14, 8, 6)];
+        let chip = AddChip::new();
         let trace: RowMajorMatrix<BabyBear> = chip.generate_trace(&mut runtime);
         println!("{:?}", trace.values)
     }
@@ -221,15 +217,8 @@ mod tests {
 
         let program = vec![];
         let mut runtime = Runtime::new(program);
-        let events = vec![AluEvent {
-            clk: 0,
-            opcode: Opcode::ADD,
-            a: 14,
-            b: 8,
-            c: 6,
-        }]
-        .repeat(1000);
-        let chip = AddChip { events };
+        runtime.add_events = vec![AluEvent::new(0, Opcode::ADD, 14, 8, 6)].repeat(1000);
+        let chip = AddChip::new();
         let trace: RowMajorMatrix<BabyBear> = chip.generate_trace(&mut runtime);
         let proof = prove::<MyConfig, _>(&config, &chip, &mut challenger, trace);
 

diff --git a/core/src/alu/bitwise/mod.rs b/core/src/alu/bitwise/mod.rs
@@ -7,14 +7,14 @@ use p3_field::PrimeField;
 use p3_matrix::dense::RowMajorMatrix;
 use p3_matrix::MatrixRowSlices;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
 use valida_derive::AlignedBorrow;
 
 use crate::air::Word;
 use crate::lookup::Interaction;
 use crate::runtime::Opcode;
 use crate::utils::{pad_to_power_of_two, Chip};
-
-use super::AluEvent;
+use crate::Runtime;
 
 pub const NUM_BITWISE_COLS: usize = size_of::<BitwiseCols<u8>>();
 
@@ -41,15 +41,19 @@ pub struct BitwiseCols<T> {
 }
 
 /// A chip that implements bitwise operations for the opcodes XOR, XORI, OR, ORI, AND, and ANDI.
-pub struct BitwiseChip {
-    events: Vec<AluEvent>,
+pub struct BitwiseChip;
+
+impl BitwiseChip {
+    pub fn new() -> Self {
+        Self {}
+    }
 }
 
 impl<F: PrimeField> Chip<F> for BitwiseChip {
-    fn generate_trace(&self, _: &mut crate::Runtime) -> RowMajorMatrix<F> {
+    fn generate_trace(&self, runtime: &mut Runtime) -> RowMajorMatrix<F> {
         // Generate the trace rows for each event.
-        let rows = self
-            .events
+        let rows = runtime
+            .bitwise_events
             .par_iter()
             .map(|event| {
                 let mut row = [F::zero(); NUM_BITWISE_COLS];
@@ -195,14 +199,8 @@ mod tests {
     fn generate_trace() {
         let program = vec![];
         let mut runtime = Runtime::new(program);
-        let events = vec![AluEvent {
-            clk: 0,
-            opcode: Opcode::ADD,
-            a: 14,
-            b: 8,
-            c: 6,
-        }];
-        let chip = BitwiseChip { events };
+        runtime.bitwise_events = vec![AluEvent::new(0, Opcode::XOR, 25, 10, 19)];
+        let chip = BitwiseChip::new();
         let trace: RowMajorMatrix<BabyBear> = chip.generate_trace(&mut runtime);
         println!("{:?}", trace.values)
     }
@@ -251,31 +249,13 @@ mod tests {
 
         let program = vec![];
         let mut runtime = Runtime::new(program);
-        let events = vec![
-            AluEvent {
-                clk: 0,
-                opcode: Opcode::XOR,
-                a: 25,
-                b: 10,
-                c: 19,
-            },
-            AluEvent {
-                clk: 0,
-                opcode: Opcode::OR,
-                a: 27,
-                b: 10,
-                c: 19,
-            },
-            AluEvent {
-                clk: 0,
-                opcode: Opcode::AND,
-                a: 2,
-                b: 10,
-                c: 19,
-            },
+        runtime.bitwise_events = vec![
+            AluEvent::new(0, Opcode::XOR, 25, 10, 19),
+            AluEvent::new(0, Opcode::OR, 27, 10, 19),
+            AluEvent::new(0, Opcode::AND, 2, 10, 19),
         ]
         .repeat(1000);
-        let chip = BitwiseChip { events };
+        let chip = BitwiseChip::new();
         let trace: RowMajorMatrix<BabyBear> = chip.generate_trace(&mut runtime);
         let proof = prove::<MyConfig, _>(&config, &chip, &mut challenger, trace);
 

diff --git a/core/src/alu/mod.rs b/core/src/alu/mod.rs
@@ -1,11 +1,8 @@
-use p3_field::PrimeField;
-use p3_matrix::dense::RowMajorMatrix;
-
-use crate::{lookup::Interaction, runtime::Opcode, Runtime};
-mod add;
-mod bitwise;
-mod shift;
-mod sub;
+use crate::runtime::Opcode;
+pub mod add;
+pub mod bitwise;
+pub mod shift;
+pub mod sub;
 
 #[derive(Debug, Clone, Copy)]
 pub struct AluEvent {
@@ -15,3 +12,15 @@ pub struct AluEvent {
     pub b: u32,
     pub c: u32,
 }
+
+impl AluEvent {
+    pub fn new(clk: u32, opcode: Opcode, a: u32, b: u32, c: u32) -> Self {
+        Self {
+            clk,
+            opcode,
+            a,
+            b,
+            c,
+        }
+    }
+}
diff --git a/core/src/alu/sub/mod.rs b/core/src/alu/sub/mod.rs
@@ -6,14 +6,15 @@ use p3_field::PrimeField;
 use p3_matrix::dense::RowMajorMatrix;
 use p3_matrix::MatrixRowSlices;
 use rayon::iter::{IntoParallelRefIterator, ParallelIterator};
+
 use std::mem::transmute;
 use valida_derive::AlignedBorrow;
 
 use crate::air::Word;
 use crate::lookup::Interaction;
-use crate::utils::{pad_to_power_of_two, Chip};
 
-use super::AluEvent;
+use crate::utils::{pad_to_power_of_two, Chip};
+use crate::Runtime;
 
 pub const NUM_SUB_COLS: usize = size_of::<SubCols<u8>>();
 
@@ -34,15 +35,19 @@ pub struct SubCols<T> {
 }
 
 /// A chip that implements subtraction for the opcode SUB.
-pub struct SubChip {
-    events: Vec<AluEvent>,
+pub struct SubChip;
+
+impl SubChip {
+    pub fn new() -> Self {
+        Self {}
+    }
 }
 
 impl<F: PrimeField> Chip<F> for SubChip {
-    fn generate_trace(&self, _: &mut crate::Runtime) -> RowMajorMatrix<F> {
+    fn generate_trace(&self, runtime: &mut Runtime) -> RowMajorMatrix<F> {
         // Generate the trace rows for each event.
-        let rows = self
-            .events
+        let rows = runtime
+            .sub_events
             .par_iter()
             .map(|event| {
                 let mut row = [F::zero(); NUM_SUB_COLS];
@@ -169,14 +174,8 @@ mod tests {
     fn generate_trace() {
         let program = vec![];
         let mut runtime = Runtime::new(program);
-        let events = vec![AluEvent {
-            clk: 0,
-            opcode: Opcode::ADD,
-            a: 2,
-            b: 8,
-            c: 6,
-        }];
-        let chip = SubChip { events };
+        runtime.sub_events = vec![AluEvent::new(0, Opcode::SUB, 14, 8, 6)];
+        let chip = SubChip {};
         let trace: RowMajorMatrix<BabyBear> = chip.generate_trace(&mut runtime);
         println!("{:?}", trace.values)
     }
@@ -225,15 +224,8 @@ mod tests {
 
         let program = vec![];
         let mut runtime = Runtime::new(program);
-        let events = vec![AluEvent {
-            clk: 0,
-            opcode: Opcode::SUB,
-            a: 2,
-            b: 8,
-            c: 6,
-        }]
-        .repeat(1000);
-        let chip = SubChip { events };
+        runtime.sub_events = vec![AluEvent::new(0, Opcode::SUB, 14, 8, 6)].repeat(1000);
+        let chip = SubChip::new();
         let trace: RowMajorMatrix<BabyBear> = chip.generate_trace(&mut runtime);
         let proof = prove::<MyConfig, _>(&config, &chip, &mut challenger, trace);