Removed the pairing chips, added fill_dummy_row to TraceStep, other minor improvements

Author: arayikhalatyan

crates/circuits/mod-builder/src/core_chip.rs

@@ -1,5 +1,6 @@
 use itertools::Itertools;
 use num_bigint::BigUint;
+use num_traits::Zero;
 use openvm_circuit::{
     arch::{
         AdapterAirContext, AdapterExecutorE1, AdapterTraceStep, DynAdapterInterface, DynArray,
@@ -283,6 +284,20 @@ where
         let (adapter_row, _) = row.split_at_mut(A::WIDTH);
         self.adapter.fill_trace_row(mem_helper, (), adapter_row);
     }
+
+    // We will be setting is_valid = 0. That forces all flags be 0 (otherwise setup will be -1).
+    // We generate a dummy row with all flags set to 0, then we set is_valid = 0.
+    fn fill_dummy_trace_row(&self, _mem_helper: &MemoryAuxColsFactory<F>, row: &mut [F]) {
+        let inputs: Vec<BigUint> = vec![BigUint::zero(); self.num_inputs()];
+        let flags: Vec<bool> = vec![false; self.num_flags()];
+        let core_row = &mut row[A::WIDTH..];
+        // We **do not** want this trace row to update the range checker
+        // so we must create a temporary range checker
+        let tmp_range_checker = SharedVariableRangeCheckerChip::new(self.range_checker.bus());
+        self.expr
+            .generate_subrow((tmp_range_checker.as_ref(), inputs, flags), core_row);
+        core_row[0] = F::ZERO; // is_valid = 0
+    }
 }
 
 impl<F, A> StepExecutorE1<F> for FieldExpressionStep<A>
@@ -321,7 +336,7 @@ fn run_field_expression<F: PrimeField32, A>(
 
     assert_eq!(data.len(), step.num_inputs() * field_element_limbs);
 
-    let mut inputs = vec![];
+    let mut inputs = Vec::with_capacity(step.num_inputs());
     for i in 0..step.num_inputs() {
         let start = i * field_element_limbs;
         let end = start + field_element_limbs;

crates/vm/src/arch/integration_api.rs

@@ -172,14 +172,26 @@ pub trait TraceStep<F, CTX> {
     /// [`TraceStep::execute`], so the `trace` should already contain context necessary to
     /// fill in the rest of it.
     // TODO(ayush): come up with a better abstraction for chips that fill a dynamic number of rows
-    fn fill_trace(&self, mem_helper: &MemoryAuxColsFactory<F>, trace: &mut [F], width: usize)
-    where
+    fn fill_trace(
+        &self,
+        mem_helper: &MemoryAuxColsFactory<F>,
+        trace: &mut [F],
+        width: usize,
+        rows_used: usize,
+    ) where
         Self: Send + Sync,
         F: Send + Sync,
     {
-        trace.par_chunks_exact_mut(width).for_each(|row_slice| {
-            self.fill_trace_row(mem_helper, row_slice);
-        });
+        trace[..rows_used * width]
+            .par_chunks_exact_mut(width)
+            .for_each(|row_slice| {
+                self.fill_trace_row(mem_helper, row_slice);
+            });
+        trace[rows_used * width..]
+            .par_chunks_exact_mut(width)
+            .for_each(|row_slice| {
+                self.fill_dummy_trace_row(mem_helper, row_slice);
+            });
     }
 
     /// Populates `row_slice`. This function will always be called after
@@ -192,6 +204,13 @@ pub trait TraceStep<F, CTX> {
         unreachable!("fill_trace_row is not implemented")
     }
 
+    /// Populates `row_slice`. This function will be called on dummy rows.
+    /// By default the trace is padded with empty (all 0) rows to make the height a power of 2.
+    ///
+    /// The provided `row_slice` will have length equal to the width of the AIR.
+    fn fill_dummy_trace_row(&self, mem_helper: &MemoryAuxColsFactory<F>, row_slice: &mut [F]) {
+        // By default, the row is filled with zeroes
+    }
     /// Returns a list of public values to publish.
     fn generate_public_values(&self) -> Vec<F> {
         vec![]
@@ -292,14 +311,8 @@ where
         assert!(height.checked_mul(self.width).unwrap() <= self.trace_buffer.len());
         self.trace_buffer.truncate(height * self.width);
         let mem_helper = self.mem_helper.as_borrowed();
-        // This zip only goes through used rows.
-        // TODO: check if zero-init assumption changes
-        // The padding(=dummy) rows between rows_used..height are ASSUMED to be filled with zeros.
-        self.step.fill_trace(
-            &mem_helper,
-            &mut self.trace_buffer[..rows_used * self.width],
-            self.width,
-        );
+        self.step
+            .fill_trace(&mem_helper, &mut self.trace_buffer, self.width, rows_used);
         drop(self.mem_helper);
         let trace = RowMajorMatrix::new(self.trace_buffer, self.width);
         // self.inner.finalize(&mut trace, num_records);

extensions/ecc/circuit/src/weierstrass_chip/tests.rs

@@ -290,6 +290,8 @@ fn test_p256_double() {
         chip.0.step.offset + Rv32WeierstrassOpcode::EC_DOUBLE as usize,
     );
 
+    tester.execute(&mut chip, &instruction);
+    // Adding another row to make sure there are dummy rows, and that the dummy row constraints are satisfied
     tester.execute(&mut chip, &instruction);
     let tester = tester.build().load(chip).load(bitwise_chip).finalize();