Merge branch 'main' into cleaning

Author: TomWambsgans

Cargo.lock

@@ -1,5 +1,5 @@
 [package]
-name = "lean-multisig"
+name = "modular-precompiles"
 version.workspace = true
 edition.workspace = true
 

Cargo.toml

@@ -16,6 +16,9 @@ const TWO_POW_UNIVARIATE_SKIPS: usize = 1 << UNIVARIATE_SKIPS;
 
 pub const LOG_SMALLEST_DECOMPOSITION_CHUNK: usize = 12; // TODO optimize
 
+const DOT_PRODUCT_UNIVARIATE_SKIPS: usize = 1;
+const TWO_POW_DOT_PRODUCT_UNIVARIATE_SKIPS: usize = 1 << DOT_PRODUCT_UNIVARIATE_SKIPS;
+
 pub fn whir_config_builder() -> WhirConfigBuilder {
     WhirConfigBuilder {
         folding_factor: FoldingFactor::new(7, 4),

crates/lean_prover/src/lib.rs

@@ -1,3 +1,5 @@
+use std::array;
+
 use crate::common::*;
 use crate::*;
 use air::prove_air;
@@ -8,7 +10,6 @@ use multilinear_toolkit::prelude::*;
 use p3_air::Air;
 use p3_util::{log2_ceil_usize, log2_strict_usize};
 use poseidon_circuit::{PoseidonGKRLayers, prove_poseidon_gkr};
-use std::array;
 use sub_protocols::*;
 use tracing::info_span;
 use utils::{build_prover_state, padd_with_zero_to_next_power_of_two};

crates/lean_prover/src/prove_execution.rs

@@ -0,0 +1,85 @@
+use lean_vm::{DIMENSION, EF, WitnessDotProduct};
+use multilinear_toolkit::prelude::*;
+
+pub fn build_dot_product_columns(
+    witness: &[WitnessDotProduct],
+    min_n_rows: usize,
+) -> (Vec<Vec<EF>>, usize) {
+    let (
+        mut flag,
+        mut len,
+        mut index_a,
+        mut index_b,
+        mut index_res,
+        mut value_a,
+        mut value_b,
+        mut res,
+        mut computation,
+    ) = (
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+        Vec::new(),
+    );
+    for dot_product in witness {
+        assert!(dot_product.len > 0);
+
+        // computation
+        {
+            computation.extend(EF::zero_vec(dot_product.len));
+            let new_size = computation.len();
+            computation[new_size - 1] =
+                dot_product.slice_0[dot_product.len - 1] * dot_product.slice_1[dot_product.len - 1];
+            for i in 0..dot_product.len - 1 {
+                computation[new_size - 2 - i] = computation[new_size - 1 - i]
+                    + dot_product.slice_0[dot_product.len - 2 - i]
+                        * dot_product.slice_1[dot_product.len - 2 - i];
+            }
+        }
+
+        flag.push(EF::ONE);
+        flag.extend(EF::zero_vec(dot_product.len - 1));
+        len.extend(((1..=dot_product.len).rev()).map(EF::from_usize));
+        index_a.extend(
+            (0..dot_product.len).map(|i| EF::from_usize(dot_product.addr_0 + i * DIMENSION)),
+        );
+        index_b.extend(
+            (0..dot_product.len).map(|i| EF::from_usize(dot_product.addr_1 + i * DIMENSION)),
+        );
+        index_res.extend(vec![EF::from_usize(dot_product.addr_res); dot_product.len]);
+        value_a.extend(dot_product.slice_0.clone());
+        value_b.extend(dot_product.slice_1.clone());
+        res.extend(vec![dot_product.res; dot_product.len]);
+    }
+
+    let padding_len = flag.len().next_power_of_two().max(min_n_rows) - flag.len();
+    flag.extend(vec![EF::ONE; padding_len]);
+    len.extend(vec![EF::ONE; padding_len]);
+    index_a.extend(EF::zero_vec(padding_len));
+    index_b.extend(EF::zero_vec(padding_len));
+    index_res.extend(EF::zero_vec(padding_len));
+    value_a.extend(EF::zero_vec(padding_len));
+    value_b.extend(EF::zero_vec(padding_len));
+    res.extend(EF::zero_vec(padding_len));
+    computation.extend(EF::zero_vec(padding_len));
+
+    (
+        vec![
+            flag,
+            len,
+            index_a,
+            index_b,
+            index_res,
+            value_a,
+            value_b,
+            res,
+            computation,
+        ],
+        padding_len,
+    )
+}

crates/lean_prover/witness_generation/src/dot_product.rs

@@ -43,3 +43,9 @@ pub const POSEIDON_24_NULL_HASH_PTR: usize = 5;
 
 /// Normal pointer to start of program input
 pub const NONRESERVED_PROGRAM_INPUT_START: usize = 6 * 8;
+
+/// Precompiles Indexes
+pub const TABLE_INDEX_POSEIDONS_16: usize = 1; // should be != 0
+pub const TABLE_INDEX_POSEIDONS_24: usize = 2;
+pub const TABLE_INDEX_DOT_PRODUCTS: usize = 3;
+pub const TABLE_INDEX_MULTILINEAR_EVAL: usize = 4;