Include SHL/SHR in the arithmetic CTL

evm/src/all_stark.rs

@@ -108,7 +108,10 @@ pub(crate) fn all_cross_table_lookups<F: Field>() -> Vec<CrossTableLookup<F>> {
 
 fn ctl_arithmetic<F: Field>() -> CrossTableLookup<F> {
     CrossTableLookup::new(
-        vec![cpu_stark::ctl_arithmetic_rows()],
+        vec![
+            cpu_stark::ctl_arithmetic_base_rows(),
+            cpu_stark::ctl_arithmetic_shift_rows(),
+        ],
         arithmetic_stark::ctl_arithmetic_rows(),
     )
 }

evm/src/cpu/cpu_stark.rs

@@ -60,11 +60,14 @@ fn ctl_data_binops<F: Field>(ops: &[usize]) -> Vec<Column<F>> {
 
 /// Create the vector of Columns corresponding to the three inputs and
 /// one output of a ternary operation.
-fn ctl_data_ternops<F: Field>(ops: &[usize]) -> Vec<Column<F>> {
+/// If `is_shift` is `true`, we offset the memory_channels indices used for the inputs
+/// by 1. It will only be valid if the associated filter is one of the two shift flags.
+fn ctl_data_ternops<F: Field>(ops: &[usize], is_shift: bool) -> Vec<Column<F>> {
+    let offset = is_shift as usize;
     let mut res = Column::singles(ops).collect_vec();
-    res.extend(Column::singles(COL_MAP.mem_channels[0].value));
-    res.extend(Column::singles(COL_MAP.mem_channels[1].value));
-    res.extend(Column::singles(COL_MAP.mem_channels[2].value));
+    res.extend(Column::singles(COL_MAP.mem_channels[offset].value));
+    res.extend(Column::singles(COL_MAP.mem_channels[offset + 1].value));
+    res.extend(Column::singles(COL_MAP.mem_channels[offset + 2].value));
     res.extend(Column::singles(
         COL_MAP.mem_channels[NUM_GP_CHANNELS - 1].value,
     ));
@@ -79,7 +82,7 @@ pub fn ctl_filter_logic<F: Field>() -> Column<F> {
     Column::sum([COL_MAP.op.and, COL_MAP.op.or, COL_MAP.op.xor])
 }
 
-pub fn ctl_arithmetic_rows<F: Field>() -> TableWithColumns<F> {
+pub fn ctl_arithmetic_base_rows<F: Field>() -> TableWithColumns<F> {
     const OPS: [usize; 14] = [
         COL_MAP.op.add,
         COL_MAP.op.sub,
@@ -101,7 +104,42 @@ pub fn ctl_arithmetic_rows<F: Field>() -> TableWithColumns<F> {
     // (also `ops` is used as the operation filter). The list of
     // operations includes binary operations which will simply ignore
     // the third input.
-    TableWithColumns::new(Table::Cpu, ctl_data_ternops(&OPS), Some(Column::sum(OPS)))
+    TableWithColumns::new(
+        Table::Cpu,
+        ctl_data_ternops(&OPS, false),
+        Some(Column::sum(OPS)),
+    )
+}
+
+pub fn ctl_arithmetic_shift_rows<F: Field>() -> TableWithColumns<F> {
+    const OPS: [usize; 14] = [
+        COL_MAP.op.add,
+        COL_MAP.op.sub,
+        // SHL is interpreted as MUL on the arithmetic side
+        COL_MAP.op.shl,
+        COL_MAP.op.lt,
+        COL_MAP.op.gt,
+        COL_MAP.op.addfp254,
+        COL_MAP.op.mulfp254,
+        COL_MAP.op.subfp254,
+        COL_MAP.op.addmod,
+        COL_MAP.op.mulmod,
+        COL_MAP.op.submod,
+        // SHR is interpreted as DIV on the arithmetic side
+        COL_MAP.op.shr,
+        COL_MAP.op.mod_,
+        COL_MAP.op.byte,
+    ];
+    // Create the CPU Table whose columns are those with the three
+    // inputs and one output of the ternary operations listed in `ops`
+    // (also `ops` is used as the operation filter). The list of
+    // operations includes binary operations which will simply ignore
+    // the third input.
+    TableWithColumns::new(
+        Table::Cpu,
+        ctl_data_ternops(&OPS, true),
+        Some(Column::sum([COL_MAP.op.shl, COL_MAP.op.shr])),
+    )
 }
 
 pub const MEM_CODE_CHANNEL_IDX: usize = 0;

evm/src/cpu/shift.rs

@@ -54,7 +54,7 @@ pub(crate) fn eval_packed<P: PackedField>(
     // (in the case of left shift) or DIV (in the case of right shift)
     // in the arithmetic table. Specifically, the mapping is
     //
-    // 0 -> 0  (value to be shifted is the same)
+    // 1 -> 0  (value to be shifted is the same)
     // 2 -> 1  (two_exp becomes the multiplicand (resp. divisor))
     // last -> last  (output is the same)
 }