Add integration test for interactions

rust-toolchain

@@ -1 +1 @@
-stable
+nightly-2024-05-01

stark-middleware/src/verifier/error.rs

@@ -1,4 +1,4 @@
-#[derive(Debug)]
+#[derive(Debug, PartialEq, Eq)]
 pub enum VerificationError {
     InvalidProofShape,
     /// An error occurred while verifying the claimed openings.

stark-middleware/tests/fib_selector_air/air.rs

@@ -2,17 +2,32 @@ use std::borrow::Borrow;
 
 use super::columns::FibonacciSelectorCols;
 use crate::fib_air::columns::{FibonacciCols, NUM_FIBONACCI_COLS};
-use afs_middleware::interaction::Chip;
-use p3_air::{Air, AirBuilder, AirBuilderWithPublicValues, BaseAir, PairBuilder};
+use afs_middleware::interaction::{Chip, Interaction};
+use p3_air::{Air, AirBuilder, AirBuilderWithPublicValues, BaseAir, PairBuilder, VirtualPairCol};
 use p3_field::{AbstractField, Field};
 use p3_matrix::{dense::RowMajorMatrix, Matrix};
 
 pub struct FibonacciSelectorAir {
     pub sels: Vec<bool>,
+    pub enable_interactions: bool,
 }
 
-// No interactions
-impl<F: Field> Chip<F> for FibonacciSelectorAir {}
+impl<F: Field> Chip<F> for FibonacciSelectorAir {
+    fn receives(&self) -> Vec<Interaction<F>> {
+        if self.enable_interactions {
+            vec![Interaction::<F> {
+                fields: vec![VirtualPairCol::<F>::new_main(
+                    vec![(0, F::one()), (1, F::one())],
+                    F::zero(),
+                )],
+                count: VirtualPairCol::<F>::single_preprocessed(0),
+                argument_index: 0,
+            }]
+        } else {
+            vec![]
+        }
+    }
+}
 
 impl<F: Field> BaseAir<F> for FibonacciSelectorAir {
     fn width(&self) -> usize {

stark-middleware/tests/integration_test.rs

@@ -1,7 +1,14 @@
+#![feature(trait_upcasting)]
+#![allow(incomplete_features)]
+
 use afs_middleware::{
-    prover::{trace::TraceCommitter, types::ProvenMultiMatrixAirTrace, PartitionProver},
+    prover::{
+        trace::TraceCommitter,
+        types::{ProvenMultiMatrixAirTrace, ProverRap},
+        PartitionProver,
+    },
     setup::PartitionSetup,
-    verifier::PartitionVerifier,
+    verifier::{types::VerifierRap, PartitionVerifier},
 };
 use p3_air::BaseAir;
 use p3_baby_bear::BabyBear;
@@ -19,6 +26,12 @@ mod config;
 mod fib_air;
 mod fib_selector_air;
 
+#[cfg(test)]
+mod interaction;
+
+trait ProverVerifierRap<SC: StarkGenericConfig>: ProverRap<SC> + VerifierRap<SC> {}
+impl<SC: StarkGenericConfig, RAP: ProverRap<SC> + VerifierRap<SC>> ProverVerifierRap<SC> for RAP {}
+
 #[test]
 fn test_single_fib_stark() {
     use fib_air::air::FibonacciAir;
@@ -99,7 +112,10 @@ fn test_single_fib_selector_stark() {
     let sels: Vec<bool> = (0..n).map(|i| i % 2 == 0).collect();
     let pis = [a, b, get_conditional_fib_number(&sels)].map(BabyBear::from_canonical_u32);
 
-    let air = FibonacciSelectorAir { sels };
+    let air = FibonacciSelectorAir {
+        sels,
+        enable_interactions: false,
+    };
 
     let prep_trace = air.preprocessed_trace();
     let setup = PartitionSetup::new(&config);
@@ -154,7 +170,10 @@ fn test_double_fib_starks() {
     let pis = [a, b, get_fib_number(n)].map(BabyBear::from_canonical_u32);
 
     let air1 = FibonacciAir {};
-    let air2 = FibonacciSelectorAir { sels };
+    let air2 = FibonacciSelectorAir {
+        sels,
+        enable_interactions: false,
+    };
 
     let prep_trace1 = air1.preprocessed_trace();
     let prep_trace2 = air2.preprocessed_trace();

stark-middleware/tests/interaction/dummy_interaction_air.rs

@@ -0,0 +1,48 @@
+use afs_middleware::interaction::{Chip, Interaction};
+use p3_air::{Air, AirBuilderWithPublicValues, BaseAir, PairBuilder, VirtualPairCol};
+use p3_field::Field;
+use p3_matrix::dense::RowMajorMatrix;
+
+pub struct DummyInteractionAir {
+    // Send if true. Receive if false.
+    pub is_send: bool,
+}
+
+impl<F: Field> Chip<F> for DummyInteractionAir {
+    fn sends(&self) -> Vec<Interaction<F>> {
+        if self.is_send {
+            vec![Interaction::<F> {
+                fields: vec![VirtualPairCol::<F>::single_main(1)],
+                count: VirtualPairCol::<F>::single_main(0),
+                argument_index: 0,
+            }]
+        } else {
+            vec![]
+        }
+    }
+    fn receives(&self) -> Vec<Interaction<F>> {
+        if !self.is_send {
+            vec![Interaction::<F> {
+                fields: vec![VirtualPairCol::<F>::single_main(1)],
+                count: VirtualPairCol::<F>::single_main(0),
+                argument_index: 0,
+            }]
+        } else {
+            vec![]
+        }
+    }
+}
+
+impl<F: Field> BaseAir<F> for DummyInteractionAir {
+    fn width(&self) -> usize {
+        2
+    }
+
+    fn preprocessed_trace(&self) -> Option<RowMajorMatrix<F>> {
+        None
+    }
+}
+
+impl<AB: AirBuilderWithPublicValues + PairBuilder> Air<AB> for DummyInteractionAir {
+    fn eval(&self, _builder: &mut AB) {}
+}