Feat/univariate logup gkr

crates/math/src/polynomial/mod.rs

@@ -22,6 +22,10 @@ pub use sparse::SparsePolynomial;
 /// Represents the polynomial c_0 + c_1 * X + c_2 * X^2 + ... + c_n * X^n
 /// as a vector of coefficients `[c_0, c_1, ... , c_n]`
 #[derive(Debug, Clone, PartialEq, Eq)]
+#[cfg_attr(
+    feature = "lambdaworks-serde-binary",
+    derive(serde::Serialize, serde::Deserialize)
+)]
 pub struct Polynomial<FE> {
     pub coefficients: Vec<FE>,
 }

crates/provers/gkr-logup/Cargo.toml

@@ -7,6 +7,10 @@ edition = "2021"
 lambdaworks-math = { workspace = true }
 lambdaworks-crypto = { workspace = true }
 lambdaworks-sumcheck = { path = "../sumcheck" }
+serde = { version = "1.0", default-features = false, features = ["derive"], optional = true }
+
+[features]
+serde = ["dep:serde", "lambdaworks-math/lambdaworks-serde-binary", "lambdaworks-crypto/serde"]
 
 [lib]
 name = "lambdaworks_gkr_logup"

crates/provers/gkr-logup/benches/batch_vs_individual.rs

@@ -46,8 +46,8 @@ fn make_logup_layer(num_vars: usize, seed: u64) -> Layer<F> {
 fn bench_individual_grand_product(num_vars: usize, n_instances: usize) {
     for i in 0..n_instances {
         let layer = make_grand_product_layer(num_vars, 42 + i as u64 * 100);
-        let mut channel = DefaultTranscript::<F>::new(&[]);
-        let _ = prove(&mut channel, layer);
+        let mut transcript = DefaultTranscript::<F>::new(&[]);
+        let _ = prove(&mut transcript, layer);
     }
 }
 
@@ -56,16 +56,16 @@ fn bench_batch_grand_product(num_vars: usize, n_instances: usize) {
     let layers: Vec<Layer<F>> = (0..n_instances)
         .map(|i| make_grand_product_layer(num_vars, 42 + i as u64 * 100))
         .collect();
-    let mut channel = DefaultTranscript::<F>::new(&[]);
-    let _ = prove_batch(&mut channel, layers);
+    let mut transcript = DefaultTranscript::<F>::new(&[]);
+    let _ = prove_batch(&mut transcript, layers);
 }
 
 /// Prove N LogUp instances individually.
 fn bench_individual_logup(num_vars: usize, n_instances: usize) {
     for i in 0..n_instances {
         let layer = make_logup_layer(num_vars, 42 + i as u64 * 100);
-        let mut channel = DefaultTranscript::<F>::new(&[]);
-        let _ = prove(&mut channel, layer);
+        let mut transcript = DefaultTranscript::<F>::new(&[]);
+        let _ = prove(&mut transcript, layer);
     }
 }
 
@@ -74,8 +74,8 @@ fn bench_batch_logup(num_vars: usize, n_instances: usize) {
     let layers: Vec<Layer<F>> = (0..n_instances)
         .map(|i| make_logup_layer(num_vars, 42 + i as u64 * 100))
         .collect();
-    let mut channel = DefaultTranscript::<F>::new(&[]);
-    let _ = prove_batch(&mut channel, layers);
+    let mut transcript = DefaultTranscript::<F>::new(&[]);
+    let _ = prove_batch(&mut transcript, layers);
 }
 
 /// Prove N instances with mixed sizes (half at num_vars, half at num_vars-2).
@@ -87,8 +87,8 @@ fn bench_individual_mixed_sizes(num_vars: usize, n_instances: usize) {
             num_vars.saturating_sub(2).max(1)
         };
         let layer = make_grand_product_layer(vars, 42 + i as u64 * 100);
-        let mut channel = DefaultTranscript::<F>::new(&[]);
-        let _ = prove(&mut channel, layer);
+        let mut transcript = DefaultTranscript::<F>::new(&[]);
+        let _ = prove(&mut transcript, layer);
     }
 }
 
@@ -104,8 +104,8 @@ fn bench_batch_mixed_sizes(num_vars: usize, n_instances: usize) {
             make_grand_product_layer(vars, 42 + i as u64 * 100)
         })
         .collect();
-    let mut channel = DefaultTranscript::<F>::new(&[]);
-    let _ = prove_batch(&mut channel, layers);
+    let mut transcript = DefaultTranscript::<F>::new(&[]);
+    let _ = prove_batch(&mut transcript, layers);
 }
 
 fn print_comparison(label: &str, individual: std::time::Duration, batch: std::time::Duration) {

crates/provers/gkr-logup/examples/logup_gkr.rs

@@ -0,0 +1,93 @@
+use lambdaworks_math::field::element::FieldElement;
+use lambdaworks_math::field::fields::fft_friendly::quartic_babybear::Degree4BabyBearExtensionField;
+
+use lambdaworks_gkr_logup::layer::Layer;
+use lambdaworks_gkr_logup::prover;
+use lambdaworks_gkr_logup::verifier::{verify, Gate};
+
+use lambdaworks_crypto::fiat_shamir::default_transcript::DefaultTranscript;
+
+type F = Degree4BabyBearExtensionField;
+type FE = FieldElement<F>;
+
+fn main() {
+    println!("=== LogUp-GKR (Multilinear MLE) ===\n");
+
+    test_logup_singles();
+    test_read_only_memory();
+
+    println!("\n=== All tests passed! ===");
+}
+
+fn test_logup_singles() {
+    println!("Test 1: LogUp Singles (ROM lookup)");
+
+    // z - access[i] denominators (multilinear MLE)
+    let z = FE::from(100u64);
+    let accesses: Vec<u64> = vec![20, 10, 20, 30, 10, 20, 40, 30];
+
+    let mle_values: Vec<FE> = accesses.iter().map(|&a| z - FE::from(a)).collect();
+
+    use lambdaworks_math::polynomial::DenseMultilinearPolynomial;
+    let mle = DenseMultilinearPolynomial::new(mle_values);
+
+    let layer = Layer::LogUpSingles { denominators: mle };
+
+    println!("  Layer n_variables: {}", layer.n_variables());
+
+    let mut transcript = DefaultTranscript::<F>::new(b"test1");
+
+    match prover::prove(&mut transcript, layer) {
+        Ok((proof, _)) => {
+            println!("  Proof generated!");
+
+            let gate = Gate::LogUp;
+            let mut transcript_verify = DefaultTranscript::<F>::new(b"test1");
+
+            match verify(gate, &proof, &mut transcript_verify) {
+                Ok(_) => println!("  ✓ LogUp Singles works!"),
+                Err(e) => println!("  ✗ Verify error: {:?}", e),
+            }
+        }
+        Err(e) => println!("  Error: {:?}", e),
+    }
+}
+
+fn test_read_only_memory() {
+    println!("\nTest 2: Read Only Memory (2 columns)");
+
+    let z = FE::from(1000u64);
+    let accesses: Vec<u64> = vec![5, 3, 5, 7, 3, 5, 9, 7];
+    let table: Vec<u64> = vec![3, 5, 7, 9, 11, 13, 15, 17];
+
+    let access_dens: Vec<FE> = accesses.iter().map(|&a| z - FE::from(a)).collect();
+    let table_dens: Vec<FE> = table.iter().map(|&t| z - FE::from(t)).collect();
+
+    use lambdaworks_math::polynomial::DenseMultilinearPolynomial;
+    let access_mle = DenseMultilinearPolynomial::new(access_dens);
+    let table_mle = DenseMultilinearPolynomial::new(table_dens);
+
+    let layer = Layer::LogUpMultiplicities {
+        numerators: table_mle,
+        denominators: access_mle,
+    };
+
+    println!("  Layer n_variables: {}", layer.n_variables());
+
+    let mut transcript = DefaultTranscript::<F>::new(b"test2");
+
+    match prover::prove(&mut transcript, layer) {
+        Ok((proof, _)) => {
+            println!("  Proof generated!");
+
+            let gate = Gate::LogUp;
+            let mut transcript_verify = DefaultTranscript::<F>::new(b"test2");
+
+            match verify(gate, &proof, &mut transcript_verify) {
+                Ok(_) => println!("  ✓ Read Only Memory works!"),
+                Err(e) => println!("  ✗ Verify error: {:?}", e),
+            }
+        }
+        Err(e) => println!("  Error: {:?}", e),
+    }
+}

crates/provers/gkr-logup/examples/read_only_memory.rs

@@ -76,9 +76,9 @@ fn main() {
     // Prove: batch both instances into a single GKR proof
     // -------------------------------------------------------
     println!("--- Proving ---");
-    let mut prover_channel = DefaultTranscript::<F>::new(&[]);
+    let mut prover_transcript = DefaultTranscript::<F>::new(&[]);
     let (proof, _artifact) =
-        prove_batch(&mut prover_channel, vec![access_layer, table_layer]).unwrap();
+        prove_batch(&mut prover_transcript, vec![access_layer, table_layer]).unwrap();
 
     println!(
         "Batch proof: {} sumcheck layers, {} instances",
@@ -91,8 +91,12 @@ fn main() {
     // Verify: batch verification
     // -------------------------------------------------------
     println!("--- Verifying ---");
-    let mut verifier_channel = DefaultTranscript::<F>::new(&[]);
-    let result = verify_batch(&[Gate::LogUp, Gate::LogUp], &proof, &mut verifier_channel);
+    let mut verifier_transcript = DefaultTranscript::<F>::new(&[]);
+    let result = verify_batch(
+        &[Gate::LogUp, Gate::LogUp],
+        &proof,
+        &mut verifier_transcript,
+    );
 
     match &result {
         Ok(artifact) => {
@@ -151,11 +155,16 @@ fn main() {
         denominators: DenseMultilinearPolynomial::new(table_dens2),
     };
 
-    let mut p_ch = DefaultTranscript::<F>::new(&[]);
-    let (bad_proof, _) = prove_batch(&mut p_ch, vec![bad_access_layer, table_layer2]).unwrap();
+    let mut prover_transcript = DefaultTranscript::<F>::new(&[]);
+    let (bad_proof, _) =
+        prove_batch(&mut prover_transcript, vec![bad_access_layer, table_layer2]).unwrap();
 
-    let mut v_ch = DefaultTranscript::<F>::new(&[]);
-    let bad_result = verify_batch(&[Gate::LogUp, Gate::LogUp], &bad_proof, &mut v_ch);
+    let mut verifier_transcript = DefaultTranscript::<F>::new(&[]);
+    let bad_result = verify_batch(
+        &[Gate::LogUp, Gate::LogUp],
+        &bad_proof,
+        &mut verifier_transcript,
+    );
 
     match &bad_result {
         Ok(_) => println!("GKR verification: PASSED (each tree is internally consistent)"),

crates/provers/gkr-logup/examples/univariate_logup_gkr.rs

@@ -0,0 +1,126 @@
+//! End-to-end example of the univariate LogUp-GKR IOP (Section 5 of ePrint 2023/1284).
+//!
+//! Demonstrates:
+//! 1. LogUp Singles: ROM lookup with univariate commitments
+//! 2. LogUp Multiplicities: table + multiplicities with univariate commitments
+//! 3. Grand Product: simple product argument with univariate commitments
+
+use lambdaworks_math::field::element::FieldElement;
+use lambdaworks_math::field::fields::fft_friendly::quartic_babybear::Degree4BabyBearExtensionField;
+
+use lambdaworks_crypto::fiat_shamir::default_transcript::DefaultTranscript;
+
+use lambdaworks_gkr_logup::univariate::domain::CyclicDomain;
+use lambdaworks_gkr_logup::univariate::iop::{prove_univariate, verify_univariate};
+use lambdaworks_gkr_logup::univariate::lagrange::UnivariateLagrange;
+use lambdaworks_gkr_logup::univariate_layer::UnivariateLayer;
+use lambdaworks_gkr_logup::verifier::Gate;
+
+type F = Degree4BabyBearExtensionField;
+type FE = FieldElement<F>;
+
+fn main() {
+    println!("=== Univariate LogUp-GKR IOP (Section 5) ===\n");
+
+    test_grand_product();
+    test_logup_singles();
+    test_logup_multiplicities();
+
+    println!("\n=== All examples passed! ===");
+}
+
+fn test_grand_product() {
+    println!("Example 1: Grand Product (univariate commitment)");
+
+    let values: Vec<FE> = (1..=8).map(|i| FE::from(i as u64)).collect();
+    let domain = CyclicDomain::new(3).unwrap();
+    let uni = UnivariateLagrange::new(values, domain).unwrap();
+
+    let layer = UnivariateLayer::GrandProduct {
+        values: uni,
+        commitment: None,
+    };
+
+    let mut prover_transcript = DefaultTranscript::<F>::new(b"grand_product_example");
+    let (proof, result) = prove_univariate(&mut prover_transcript, layer).unwrap();
+
+    println!(
+        "  Proof generated: {} GKR layers",
+        proof.gkr_proof.sumcheck_proofs.len()
+    );
+    println!("  OOD point dimension: {}", result.ood_point.len());
+    println!("  Claims to verify: {}", result.claims_to_verify.len());
+
+    let mut verifier_transcript = DefaultTranscript::<F>::new(b"grand_product_example");
+    verify_univariate(Gate::GrandProduct, &proof, &mut verifier_transcript).unwrap();
+
+    println!("  ✓ Grand Product verified!\n");
+}
+
+fn test_logup_singles() {
+    println!("Example 2: LogUp Singles (ROM lookup)");
+
+    // Simulate a ROM lookup: 8 accesses to a table
+    let z = FE::from(100u64);
+    let accesses: Vec<u64> = vec![20, 10, 20, 30, 10, 20, 40, 30];
+    let dens: Vec<FE> = accesses.iter().map(|&a| z - FE::from(a)).collect();
+
+    let domain = CyclicDomain::new(3).unwrap();
+    let uni = UnivariateLagrange::new(dens, domain).unwrap();
+
+    let layer = UnivariateLayer::LogUpSingles {
+        denominators: uni,
+        denominator_commitment: None,
+    };
+
+    let mut prover_transcript = DefaultTranscript::<F>::new(b"logup_singles_example");
+    let (proof, result) = prove_univariate(&mut prover_transcript, layer).unwrap();
+
+    println!(
+        "  Proof generated: {} GKR layers",
+        proof.gkr_proof.sumcheck_proofs.len()
+    );
+    println!("  OOD point dimension: {}", result.ood_point.len());
+    println!("  Lagrange column size: {}", proof.lagrange_column.len());
+
+    let mut verifier_transcript = DefaultTranscript::<F>::new(b"logup_singles_example");
+    verify_univariate(Gate::LogUp, &proof, &mut verifier_transcript).unwrap();
+
+    println!("  ✓ LogUp Singles verified!\n");
+}
+
+fn test_logup_multiplicities() {
+    println!("Example 3: LogUp Multiplicities (table + multiplicities)");
+
+    let z = FE::from(1000u64);
+    let table: Vec<u64> = vec![3, 5, 7, 9, 11, 13, 15, 17];
+
+    let table_dens: Vec<FE> = table.iter().map(|&t| z - FE::from(t)).collect();
+    let multiplicities: Vec<FE> = table.iter().map(|_| FE::one()).collect();
+
+    let domain = CyclicDomain::new(3).unwrap();
+    let num = UnivariateLagrange::new(multiplicities, domain.clone()).unwrap();
+    let den = UnivariateLagrange::new(table_dens, domain).unwrap();
+
+    let layer = UnivariateLayer::LogUpMultiplicities {
+        numerators: num,
+        denominators: den,
+        numerator_commitment: None,
+        denominator_commitment: None,
+    };
+
+    let mut prover_transcript = DefaultTranscript::<F>::new(b"logup_mult_example");
+    let (proof, result) = prove_univariate(&mut prover_transcript, layer).unwrap();
+
+    println!(
+        "  Proof generated: {} GKR layers",
+        proof.gkr_proof.sumcheck_proofs.len()
+    );
+    println!("  Committed columns: {}", proof.committed_columns.len());
+    println!("  OOD point dimension: {}", result.ood_point.len());
+
+    let mut verifier_transcript = DefaultTranscript::<F>::new(b"logup_mult_example");
+    verify_univariate(Gate::LogUp, &proof, &mut verifier_transcript).unwrap();
+
+    println!("  ✓ LogUp Multiplicities verified!\n");
+}