Enable Bus in tests (#2289)

This PR uses `LinkerMode::Bus` in all tests which:
- Are on Goldilocks or BN254 (the bus is not implemented for smaller
fields), AND
- Are tested with the mock prover or Plonky3 (while Halo2 does support
the bus in principle, its runtime is exponential, because it inlines
intermediate polynomials)

This is true for most tests.

Doing so, I came across a few bugs. I added comments for them below.

Author: georgwiese

ast/src/parsed/asm.rs

@@ -191,6 +191,16 @@ impl SymbolPath {
     pub fn into_parts(self) -> impl DoubleEndedIterator + ExactSizeIterator<Item = Part> {
         self.parts.into_iter()
     }
+
+    pub fn is_std(&self) -> bool {
+        self.parts
+            .first()
+            .map(|p| match p {
+                Part::Named(n) => n == "std",
+                Part::Super => false,
+            })
+            .unwrap_or(false)
+    }
 }
 
 impl FromStr for SymbolPath {

executor/src/witgen/jit/witgen_inference.rs

@@ -5,8 +5,8 @@ use itertools::Itertools;
 use powdr_ast::analyzed::{
     AlgebraicBinaryOperation, AlgebraicBinaryOperator, AlgebraicExpression as Expression,
     AlgebraicReference, AlgebraicUnaryOperation, AlgebraicUnaryOperator, Identity, LookupIdentity,
-    PermutationIdentity, PhantomBusInteractionIdentity, PhantomLookupIdentity,
-    PhantomPermutationIdentity, PolynomialIdentity, PolynomialType,
+    PermutationIdentity, PhantomLookupIdentity, PhantomPermutationIdentity, PolynomialIdentity,
+    PolynomialType,
 };
 use powdr_number::FieldElement;
 
@@ -86,12 +86,8 @@ impl<'a, T: FieldElement, FixedEval: FixedEvaluator<T>> WitgenInference<'a, T, F
                 &left.expressions,
                 row_offset,
             ),
-            Identity::PhantomBusInteraction(PhantomBusInteractionIdentity {
-                id,
-                multiplicity,
-                tuple,
-                ..
-            }) => self.process_call(can_process, *id, multiplicity, &tuple.0, row_offset),
+            // TODO(bus_interaction)
+            Identity::PhantomBusInteraction(_) => ProcessResult::empty(),
             Identity::Connect(_) => ProcessResult::empty(),
         };
         self.ingest_effects(result)

executor/src/witgen/machines/block_machine.rs

@@ -450,7 +450,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> {
 
                 let updates = updates.report_side_effect();
 
-                let global_latch_row_index = self.data.len() - 1 - self.block_size + self.latch_row;
+                let global_latch_row_index = self.data.len() - self.block_size + self.latch_row;
                 self.multiplicity_counter
                     .increment_at_row(identity_id, global_latch_row_index);
 

executor/src/witgen/machines/dynamic_machine.rs

@@ -96,7 +96,9 @@ impl<'a, T: FieldElement> Machine<'a, T> for DynamicMachine<'a, T> {
             self.data.extend(updated_data.block);
             self.publics.extend(updated_data.publics);
 
-            let latch_row = self.data.len() - 1;
+            // The block we just added contains the first row of the next block,
+            // so the latch row is the second-to-last row.
+            let latch_row = self.data.len() - 2;
             self.multiplicity_counter
                 .increment_at_row(identity_id, latch_row);
 

linker/src/lib.rs

@@ -360,9 +360,11 @@ fn namespaced_expression(namespace: String, mut expr: Expression) -> Expression
     expr.visit_expressions_mut(
         &mut |expr| {
             if let Expression::Reference(_, refs) = expr {
-                refs.path = SymbolPath::from_parts(
-                    once(Part::Named(namespace.clone())).chain(refs.path.clone().into_parts()),
-                );
+                if !refs.path.is_std() {
+                    refs.path = SymbolPath::from_parts(
+                        once(Part::Named(namespace.clone())).chain(refs.path.clone().into_parts()),
+                    );
+                }
             }
             ControlFlow::Continue::<(), _>(())
         },

pipeline/src/test_util.rs

@@ -1,4 +1,5 @@
 use powdr_ast::analyzed::Analyzed;
+use powdr_linker::{DegreeMode, LinkerMode, LinkerParams};
 use powdr_number::{
     BabyBearField, BigInt, Bn254Field, FieldElement, GoldilocksField, KoalaBearField,
 };
@@ -22,9 +23,17 @@ pub fn resolve_test_file(file_name: &str) -> PathBuf {
 /// Makes a new pipeline for the given file. All steps until witness generation are
 /// already computed, so that the test can branch off from there, without having to re-compute
 /// these steps.
-pub fn make_simple_prepared_pipeline<T: FieldElement>(file_name: &str) -> Pipeline<T> {
+pub fn make_simple_prepared_pipeline<T: FieldElement>(
+    file_name: &str,
+    linker_mode: LinkerMode,
+) -> Pipeline<T> {
+    let linker_params = LinkerParams {
+        mode: linker_mode,
+        degree_mode: DegreeMode::Vadcop,
+    };
     let mut pipeline = Pipeline::default()
         .with_tmp_output()
+        .with_linker_params(linker_params)
         .from_file(resolve_test_file(file_name));
     pipeline.compute_witness().unwrap();
     pipeline
@@ -37,9 +46,15 @@ pub fn make_prepared_pipeline<T: FieldElement>(
     file_name: &str,
     inputs: Vec<T>,
     external_witness_values: Vec<(String, Vec<T>)>,
+    linker_mode: LinkerMode,
 ) -> Pipeline<T> {
+    let linker_params = LinkerParams {
+        mode: linker_mode,
+        degree_mode: DegreeMode::Vadcop,
+    };
     let mut pipeline = Pipeline::default()
         .with_tmp_output()
+        .with_linker_params(linker_params)
         .from_file(resolve_test_file(file_name))
         .with_prover_inputs(inputs)
         .add_external_witness_values(external_witness_values);
@@ -62,27 +77,37 @@ pub fn regular_test_small_field(file_name: &str, inputs: &[i32]) {
 /// Tests witness generation, mock prover, pilcom and plonky3 with BabyBear.
 pub fn regular_test_bb(file_name: &str, inputs: &[i32]) {
     let inputs_bb = inputs.iter().map(|x| BabyBearField::from(*x)).collect();
-    let pipeline_bb = make_prepared_pipeline(file_name, inputs_bb, vec![]);
+    // LinkerMode::Native because the bus is not implemented for small fields
+    let pipeline_bb = make_prepared_pipeline(file_name, inputs_bb, vec![], LinkerMode::Native);
     test_mock_backend(pipeline_bb.clone());
     test_plonky3_pipeline(pipeline_bb);
 }
 
 /// Tests witness generation, mock prover, pilcom and plonky3 with BabyBear and KoalaBear.
 pub fn regular_test_kb(file_name: &str, inputs: &[i32]) {
     let inputs_kb = inputs.iter().map(|x| KoalaBearField::from(*x)).collect();
-    let pipeline_kb = make_prepared_pipeline(file_name, inputs_kb, vec![]);
+    // LinkerMode::Native because the bus is not implemented for small fields
+    let pipeline_kb = make_prepared_pipeline(file_name, inputs_kb, vec![], LinkerMode::Native);
     test_mock_backend(pipeline_kb.clone());
     test_plonky3_pipeline(pipeline_kb);
 }
 
 /// Tests witness generation, mock prover, pilcom and plonky3 with Goldilocks.
 pub fn regular_test_gl(file_name: &str, inputs: &[i32]) {
-    let inputs_gl = inputs.iter().map(|x| GoldilocksField::from(*x)).collect();
-    let pipeline_gl = make_prepared_pipeline(file_name, inputs_gl, vec![]);
-
-    test_mock_backend(pipeline_gl.clone());
-    run_pilcom_with_backend_variant(pipeline_gl.clone(), BackendVariant::Composite).unwrap();
-    test_plonky3_pipeline(pipeline_gl);
+    let inputs_gl = inputs
+        .iter()
+        .map(|x| GoldilocksField::from(*x))
+        .collect::<Vec<_>>();
+
+    let pipeline_gl_native =
+        make_prepared_pipeline(file_name, inputs_gl.clone(), vec![], LinkerMode::Native);
+    test_mock_backend(pipeline_gl_native.clone());
+    run_pilcom_with_backend_variant(pipeline_gl_native, BackendVariant::Composite).unwrap();
+
+    let pipeline_gl_bus =
+        make_prepared_pipeline(file_name, inputs_gl.clone(), vec![], LinkerMode::Bus);
+    test_mock_backend(pipeline_gl_bus.clone());
+    test_plonky3_pipeline(pipeline_gl_bus);
 }
 
 pub fn test_pilcom(pipeline: Pipeline<GoldilocksField>) {