Rebased logUp implementation

evm/src/all_stark.rs

@@ -51,27 +51,15 @@ impl<F: RichField + Extendable<D>, const D: usize> Default for AllStark<F, D> {
 }
 
 impl<F: RichField + Extendable<D>, const D: usize> AllStark<F, D> {
-    pub(crate) fn nums_permutation_zs(&self, config: &StarkConfig) -> [usize; NUM_TABLES] {
+    pub(crate) fn num_lookups_helper_columns(&self, config: &StarkConfig) -> [usize; NUM_TABLES] {
         [
-            self.arithmetic_stark.num_permutation_batches(config),
-            self.byte_packing_stark.num_permutation_batches(config),
-            self.cpu_stark.num_permutation_batches(config),
-            self.keccak_stark.num_permutation_batches(config),
-            self.keccak_sponge_stark.num_permutation_batches(config),
-            self.logic_stark.num_permutation_batches(config),
-            self.memory_stark.num_permutation_batches(config),
-        ]
-    }
-
-    pub(crate) fn permutation_batch_sizes(&self) -> [usize; NUM_TABLES] {
-        [
-            self.arithmetic_stark.permutation_batch_size(),
-            self.byte_packing_stark.permutation_batch_size(),
-            self.cpu_stark.permutation_batch_size(),
-            self.keccak_stark.permutation_batch_size(),
-            self.keccak_sponge_stark.permutation_batch_size(),
-            self.logic_stark.permutation_batch_size(),
-            self.memory_stark.permutation_batch_size(),
+            self.arithmetic_stark.num_lookup_helper_columns(config),
+            self.byte_packing_stark.num_lookup_helper_columns(config),
+            self.cpu_stark.num_lookup_helper_columns(config),
+            self.keccak_stark.num_lookup_helper_columns(config),
+            self.keccak_sponge_stark.num_lookup_helper_columns(config),
+            self.logic_stark.num_lookup_helper_columns(config),
+            self.memory_stark.num_lookup_helper_columns(config),
         ]
     }
 }

evm/src/arithmetic/arithmetic_stark.rs

@@ -1,7 +1,6 @@
 use std::marker::PhantomData;
 use std::ops::Range;
 
-use itertools::Itertools;
 use plonky2::field::extension::{Extendable, FieldExtension};
 use plonky2::field::packed::PackedField;
 use plonky2::field::polynomial::PolynomialValues;
@@ -14,12 +13,12 @@ use static_assertions::const_assert;
 
 use super::columns::NUM_ARITH_COLUMNS;
 use crate::all_stark::Table;
+use crate::arithmetic::columns::{RANGE_COUNTER, RC_FREQUENCIES, SHARED_COLS};
 use crate::arithmetic::{addcy, byte, columns, divmod, modular, mul, Operation};
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use crate::cross_table_lookup::{Column, TableWithColumns};
 use crate::evaluation_frame::{StarkEvaluationFrame, StarkFrame};
-use crate::lookup::{eval_lookups, eval_lookups_circuit, permuted_cols};
-use crate::permutation::PermutationPair;
+use crate::lookup::Lookup;
 use crate::stark::Stark;
 
 /// Link the 16-bit columns of the arithmetic table, split into groups
@@ -124,13 +123,18 @@ impl<F: RichField, const D: usize> ArithmeticStark<F, D> {
             cols[columns::RANGE_COUNTER][i] = F::from_canonical_usize(RANGE_MAX - 1);
         }
 
-        // For each column c in cols, generate the range-check
-        // permutations and put them in the corresponding range-check
-        // columns rc_c and rc_c+1.
-        for (c, rc_c) in columns::SHARED_COLS.zip(columns::RC_COLS.step_by(2)) {
-            let (col_perm, table_perm) = permuted_cols(&cols[c], &cols[columns::RANGE_COUNTER]);
-            cols[rc_c].copy_from_slice(&col_perm);
-            cols[rc_c + 1].copy_from_slice(&table_perm);
+        // Generate the frequencies column.
+        for col in SHARED_COLS {
+            for i in 0..n_rows {
+                let x = cols[col][i].to_canonical_u64() as usize;
+                assert!(
+                    x < RANGE_MAX,
+                    "column value {} exceeds the max range value {}",
+                    x,
+                    RANGE_MAX
+                );
+                cols[RC_FREQUENCIES][x] += F::ONE;
+            }
         }
     }
 
@@ -185,11 +189,6 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for ArithmeticSta
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>,
     {
-        // Range check all the columns
-        for col in columns::RC_COLS.step_by(2) {
-            eval_lookups(vars, yield_constr, col, col + 1);
-        }
-
         let lv: &[P; NUM_ARITH_COLUMNS] = vars.get_local_values().try_into().unwrap();
         let nv: &[P; NUM_ARITH_COLUMNS] = vars.get_next_values().try_into().unwrap();
 
@@ -217,11 +216,6 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for ArithmeticSta
         vars: &Self::EvaluationFrameTarget,
         yield_constr: &mut RecursiveConstraintConsumer<F, D>,
     ) {
-        // Range check all the columns
-        for col in columns::RC_COLS.step_by(2) {
-            eval_lookups_circuit(builder, vars, yield_constr, col, col + 1);
-        }
-
         let lv: &[ExtensionTarget<D>; NUM_ARITH_COLUMNS] =
             vars.get_local_values().try_into().unwrap();
         let nv: &[ExtensionTarget<D>; NUM_ARITH_COLUMNS] =
@@ -249,18 +243,12 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for ArithmeticSta
         3
     }
 
-    fn permutation_pairs(&self) -> Vec<PermutationPair> {
-        const START: usize = columns::START_SHARED_COLS;
-        const END: usize = START + columns::NUM_SHARED_COLS;
-        let mut pairs = Vec::with_capacity(2 * columns::NUM_SHARED_COLS);
-        for (c, c_perm) in (START..END).zip_eq(columns::RC_COLS.step_by(2)) {
-            pairs.push(PermutationPair::singletons(c, c_perm));
-            pairs.push(PermutationPair::singletons(
-                c_perm + 1,
-                columns::RANGE_COUNTER,
-            ));
-        }
-        pairs
+    fn lookups(&self) -> Vec<Lookup> {
+        vec![Lookup {
+            columns: SHARED_COLS.collect(),
+            table_column: RANGE_COUNTER,
+            frequencies_column: RC_FREQUENCIES,
+        }]
     }
 }
 

evm/src/arithmetic/columns.rs

@@ -109,8 +109,7 @@ pub(crate) const MODULAR_DIV_DENOM_IS_ZERO: usize = AUX_REGISTER_2.end;
 // of the column and the permutation of the range. The two
 // permutations associated to column i will be in columns RC_COLS[2i]
 // and RC_COLS[2i+1].
-pub(crate) const NUM_RANGE_CHECK_COLS: usize = 1 + 2 * NUM_SHARED_COLS;
 pub(crate) const RANGE_COUNTER: usize = START_SHARED_COLS + NUM_SHARED_COLS;
-pub(crate) const RC_COLS: Range<usize> = RANGE_COUNTER + 1..RANGE_COUNTER + 1 + 2 * NUM_SHARED_COLS;
+pub(crate) const RC_FREQUENCIES: usize = RANGE_COUNTER + 1;
 
-pub const NUM_ARITH_COLUMNS: usize = START_SHARED_COLS + NUM_SHARED_COLS + NUM_RANGE_CHECK_COLS;
+pub const NUM_ARITH_COLUMNS: usize = START_SHARED_COLS + NUM_SHARED_COLS + 2;

evm/src/byte_packing/byte_packing_stark.rs

@@ -47,12 +47,12 @@ use plonky2::util::transpose;
 use super::NUM_BYTES;
 use crate::byte_packing::columns::{
     index_bytes, value_bytes, ADDR_CONTEXT, ADDR_SEGMENT, ADDR_VIRTUAL, BYTE_INDICES_COLS, IS_READ,
-    NUM_COLUMNS, RANGE_COUNTER, RC_COLS, SEQUENCE_END, TIMESTAMP,
+    NUM_COLUMNS, RANGE_COUNTER, RC_FREQUENCIES, SEQUENCE_END, TIMESTAMP,
 };
 use crate::constraint_consumer::{ConstraintConsumer, RecursiveConstraintConsumer};
 use crate::cross_table_lookup::Column;
 use crate::evaluation_frame::{StarkEvaluationFrame, StarkFrame};
-use crate::lookup::{eval_lookups, eval_lookups_circuit, permuted_cols};
+use crate::lookup::Lookup;
 use crate::stark::Stark;
 use crate::witness::memory::MemoryAddress;
 
@@ -240,11 +240,18 @@ impl<F: RichField + Extendable<D>, const D: usize> BytePackingStark<F, D> {
         // For each column c in cols, generate the range-check
         // permutations and put them in the corresponding range-check
         // columns rc_c and rc_c+1.
-        for (i, rc_c) in (0..NUM_BYTES).zip(RC_COLS.step_by(2)) {
-            let c = value_bytes(i);
-            let (col_perm, table_perm) = permuted_cols(&cols[c], &cols[RANGE_COUNTER]);
-            cols[rc_c].copy_from_slice(&col_perm);
-            cols[rc_c + 1].copy_from_slice(&table_perm);
+        for col in 0..NUM_BYTES {
+            for i in 0..n_rows {
+                let c = value_bytes(col);
+                let x = cols[c][i].to_canonical_u64() as usize;
+                assert!(
+                    x < BYTE_RANGE_MAX,
+                    "column value {} exceeds the max range value {}",
+                    x,
+                    BYTE_RANGE_MAX
+                );
+                cols[RC_FREQUENCIES][x] += F::ONE;
+            }
         }
     }
 
@@ -296,11 +303,6 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for BytePackingSt
         FE: FieldExtension<D2, BaseField = F>,
         P: PackedField<Scalar = FE>,
     {
-        // Range check all the columns
-        for col in RC_COLS.step_by(2) {
-            eval_lookups(vars, yield_constr, col, col + 1);
-        }
-
         let local_values: &[P; NUM_COLUMNS] = vars.get_local_values().try_into().unwrap();
         let next_values: &[P; NUM_COLUMNS] = vars.get_next_values().try_into().unwrap();
 
@@ -409,11 +411,6 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for BytePackingSt
         vars: &Self::EvaluationFrameTarget,
         yield_constr: &mut RecursiveConstraintConsumer<F, D>,
     ) {
-        // Range check all the columns
-        for col in RC_COLS.step_by(2) {
-            eval_lookups_circuit(builder, vars, yield_constr, col, col + 1);
-        }
-
         let local_values: &[ExtensionTarget<D>; NUM_COLUMNS] =
             vars.get_local_values().try_into().unwrap();
         let next_values: &[ExtensionTarget<D>; NUM_COLUMNS] =
@@ -556,6 +553,14 @@ impl<F: RichField + Extendable<D>, const D: usize> Stark<F, D> for BytePackingSt
     fn constraint_degree(&self) -> usize {
         3
     }
+
+    fn lookups(&self) -> Vec<Lookup> {
+        vec![Lookup {
+            columns: (value_bytes(0)..value_bytes(0) + NUM_BYTES).collect(),
+            table_column: RANGE_COUNTER,
+            frequencies_column: RC_FREQUENCIES,
+        }]
+    }
 }
 
 #[cfg(test)]

evm/src/byte_packing/columns.rs

@@ -39,7 +39,6 @@ pub(crate) const fn value_bytes(i: usize) -> usize {
 // The two permutations associated to the byte in column i will be in
 // columns RC_COLS[2i] and RC_COLS[2i+1].
 pub(crate) const RANGE_COUNTER: usize = BYTES_VALUES_START + NUM_BYTES;
-pub(crate) const NUM_RANGE_CHECK_COLS: usize = 1 + 2 * NUM_BYTES;
-pub(crate) const RC_COLS: Range<usize> = RANGE_COUNTER + 1..RANGE_COUNTER + NUM_RANGE_CHECK_COLS;
+pub(crate) const RC_FREQUENCIES: usize = RANGE_COUNTER + 1;
 
-pub(crate) const NUM_COLUMNS: usize = RANGE_COUNTER + NUM_RANGE_CHECK_COLS;
+pub(crate) const NUM_COLUMNS: usize = RANGE_COUNTER + 2;