feat: rand feature

baby-bear/Cargo.toml

@@ -6,14 +6,19 @@ license = "MIT OR Apache-2.0"
 
 [dependencies]
 p3-field = { path = "../field" }
-rand = "0.8.5"
+rand = { version = "0.8.5", optional = true }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
+lazy_static = "1.4"
+succinct-zkvm = { git="https://github.com/succinctlabs/vm.git", branch="kevjue/recursive_verifier_profiler" }
 
 [dev-dependencies]
 p3-field-testing = { path = "../field-testing" }
 criterion = "0.5.1"
 rand_chacha = "0.3.1"
 
+[features]
+rand = ["dep:rand"]
+
 [[bench]]
 name = "inverse"
 harness = false

baby-bear/src/aarch64_neon.rs

@@ -6,7 +6,10 @@ use core::mem::transmute;
 use core::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};
 
 use p3_field::{AbstractField, Field, PackedField};
+
+#[cfg(feature = "rand")]
 use rand::distributions::{Distribution, Standard};
+#[cfg(feature = "rand")]
 use rand::Rng;
 
 use crate::BabyBear;
@@ -540,6 +543,7 @@ impl Sub<PackedBabyBearNeon> for BabyBear {
     }
 }
 
+#[cfg(feature = "perf")]
 impl Distribution<PackedBabyBearNeon> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> PackedBabyBearNeon {

baby-bear/src/baby_bear.rs

@@ -1,15 +1,28 @@
 use core::fmt::{self, Debug, Display, Formatter};
 use core::iter::{Product, Sum};
 use core::ops::{Add, AddAssign, Div, Mul, MulAssign, Neg, Sub, SubAssign};
+use std::collections::HashMap;
 
 use p3_field::{
     exp_1725656503, exp_u64_by_squaring, AbstractField, Field, PrimeField, PrimeField32,
     PrimeField64, TwoAdicField,
 };
+
+use lazy_static::lazy_static;
+use succinct_zkvm::{io, unconstrained};
+use std::sync::Mutex;
+
+#[cfg(feature = "rand")]
 use rand::distributions::{Distribution, Standard};
+#[cfg(feature = "rand")]
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
+lazy_static! {
+    // pub static ref IN_HASH: Mutex<bool> = Mutex::new(false);
+    // pub static ref FUNC_COUNTS: Mutex<HashMap<String, u32>> = Mutex::new(HashMap::new());
+}
+
 /// The Baby Bear prime
 const P: u32 = 0x78000001;
 
@@ -76,6 +89,7 @@ impl Debug for BabyBear {
     }
 }
 
+#[cfg(feature = "rand")]
 impl Distribution<BabyBear> for Standard {
     #[inline]
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> BabyBear {
@@ -199,10 +213,25 @@ impl Field for BabyBear {
             return None;
         }
 
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {
+        //     println!("cycle-tracker-start: BabyBear_inv");
+        // }
+        // drop(in_hash);
+        // println!("cycle-tracker-start: BabyBear_inv");
+
+
         // From Fermat's little theorem, in a prime field `F_p`, the inverse of `a` is `a^(p-2)`.
         // Here p-2 = 2013265919 = 1110111111111111111111111111111_2.
         // Uses 30 Squares + 7 Multiplications => 37 Operations total.
 
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {
+        //     println!("cycle-tracker-end: BabyBear_inv");
+        // }
+        // drop(in_hash);
+        // println!("cycle-tracker-end: BabyBear_inv");
+
         let p1 = *self;
         let p100000000 = p1.exp_power_of_2(8);
         let p100000001 = p100000000 * p1;
@@ -303,12 +332,51 @@ impl Add for BabyBear {
 
     #[inline]
     fn add(self, rhs: Self) -> Self {
-        let mut sum = self.value + rhs.value;
-        let (corr_sum, over) = sum.overflowing_sub(P);
-        if !over {
-            sum = corr_sum;
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {
+        //     println!("cycle-tracker-start: BabyBear_add");
+        // }
+        // let mut func_counts = FUNC_COUNTS.lock().unwrap();
+        // *func_counts
+        // .entry("add".to_string())
+        // .or_insert(0) += 1;
+        #[cfg(target_os = "zkvm")]
+        {
+            // unconstrained!
+            {
+                let mut sum = self.value + rhs.value;
+                let (corr_sum, over) = sum.overflowing_sub(P);
+                if !over {
+                    sum = corr_sum;
+                }
+
+                unconstrained!
+                {
+                    io::hint_slice(&sum.to_le_bytes());
+                }
+            }
+
+            let mut bytes: [u8; 4] = [0; 4];
+            io::read_hint_slice(&mut bytes);
+            Self { value: u32::from_le_bytes(bytes) }
+        }
+
+        // if !*in_hash {
+        //     println!("cycle-tracker-end: BabyBear_add");
+        // }
+        // drop(in_hash);
+        // drop(func_counts);
+
+        #[cfg(not(target_os = "zkvm"))]
+        {
+            let mut sum = self.value + rhs.value;
+            let (corr_sum, over) = sum.overflowing_sub(P);
+            if !over {
+                sum = corr_sum;
+            }
+
+            Self { value: sum }
         }
-        Self { value: sum }
     }
 }
 
@@ -331,10 +399,48 @@ impl Sub for BabyBear {
 
     #[inline]
     fn sub(self, rhs: Self) -> Self {
-        let (mut diff, over) = self.value.overflowing_sub(rhs.value);
-        let corr = if over { P } else { 0 };
-        diff = diff.wrapping_add(corr);
-        BabyBear { value: diff }
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {
+        //     println!("cycle-tracker-start: BabyBear_sub");
+        // }
+        // let mut func_counts = FUNC_COUNTS.lock().unwrap();
+        // *func_counts
+        // .entry("sub".to_string())
+        // .or_insert(0) += 1;
+
+        #[cfg(target_os = "zkvm")]
+        {
+            // unconstrained!
+            {
+                let (mut diff, over) = self.value.overflowing_sub(rhs.value);
+                let corr = if over { P } else { 0 };
+                diff = diff.wrapping_add(corr);
+
+                unconstrained!
+                {
+                    io::hint_slice(&diff.to_le_bytes());
+                }
+            }
+
+            let mut bytes: [u8; 4] = [0; 4];
+            io::read_hint_slice(&mut bytes);
+            Self {value: u32::from_le_bytes(bytes)}
+        }
+
+        // if !*in_hash {
+        //     println!("cycle-tracker-end: BabyBear_sub");
+        // }
+        // drop(in_hash);
+        // drop(func_counts);
+
+        #[cfg(not(target_os = "zkvm"))]
+        {
+            let (mut diff, over) = self.value.overflowing_sub(rhs.value);
+            let corr = if over { P } else { 0 };
+            diff = diff.wrapping_add(corr);
+
+            Self { value: diff }
+        }
     }
 }
 
@@ -359,9 +465,45 @@ impl Mul for BabyBear {
 
     #[inline]
     fn mul(self, rhs: Self) -> Self {
-        let long_prod = self.value as u64 * rhs.value as u64;
-        Self {
-            value: monty_reduce(long_prod),
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {
+        //     println!("cycle-tracker-start: BabyBear_mul");
+        // }
+        // let mut func_counts = FUNC_COUNTS.lock().unwrap();
+        // *func_counts
+        // .entry("mul".to_string())
+        // .or_insert(0) += 1;
+
+        #[cfg(target_os = "zkvm")]
+        {
+            // unconstrained!
+            {
+                let long_prod = self.value as u64 * rhs.value as u64;
+                let value = monty_reduce(long_prod);
+
+                unconstrained!
+                {
+                    io::hint_slice(&value.to_le_bytes());
+                }
+            }
+
+            let mut bytes: [u8; 4] = [0; 4];
+            io::read_hint_slice(&mut bytes);
+            Self {value: u32::from_le_bytes(bytes)}
+        }
+        // if !*in_hash {
+        //     println!("cycle-tracker-end: BabyBear_mul");
+        // }
+        // drop(in_hash);
+        // drop(func_counts);
+
+        #[cfg(not(target_os = "zkvm"))]
+        {
+            let long_prod = self.value as u64 * rhs.value as u64;
+            let ret = Self {
+                value: monty_reduce(long_prod),
+            };
+            ret
         }
     }
 }
@@ -386,7 +528,19 @@ impl Div for BabyBear {
     #[allow(clippy::suspicious_arithmetic_impl)]
     #[inline]
     fn div(self, rhs: Self) -> Self {
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {        
+        //     println!("cycle-tracker-start: BabyBear_div");
+        // }
+        // drop(in_hash);
+
         self * rhs.inverse()
+
+        // let in_hash = IN_HASH.lock().unwrap();
+        // if !*in_hash {        
+        //     println!("cycle-tracker-end: BabyBear_div");
+        // }
+        // drop(in_hash);
     }
 }
 

baby-bear/src/lib.rs

@@ -1,5 +1,3 @@
-#![no_std]
-
 extern crate alloc;
 
 mod baby_bear;

brakedown/Cargo.toml

@@ -8,8 +8,8 @@ license = "MIT OR Apache-2.0"
 p3-code = { path = "../code" }
 p3-field = { path = "../field" }
 p3-lde = { path = "../lde" }
-p3-matrix = { path = "../matrix" }
-p3-mersenne-31 = { path = "../mersenne-31" }
+p3-matrix = { path = "../matrix", features = ["rand"] }
+p3-mersenne-31 = { path = "../mersenne-31", features = ["rand"] }
 p3-reed-solomon = { path = "../reed-solomon" }
 rand = "0.8.5"
 rand_chacha = "0.3.1"

field/Cargo.toml

@@ -8,5 +8,8 @@ license = "MIT OR Apache-2.0"
 p3-util = { path = "../util" }
 
 itertools = "0.12.0"
-rand = "0.8.5"
+rand = { version = "0.8.5", optional = true }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
+
+[features]
+rand = ["dep:rand"]

field/src/extension/binomial_extension.rs

@@ -6,7 +6,9 @@ use core::iter::{Product, Sum};
 use core::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 use itertools::Itertools;
+#[cfg(feature = "rand")]
 use rand::distributions::Standard;
+#[cfg(feature = "rand")]
 use rand::prelude::Distribution;
 use serde::{Deserialize, Serialize};
 
@@ -518,6 +520,7 @@ where
     }
 }
 
+#[cfg(feature = "rand")]
 impl<F: BinomiallyExtendable<D>, const D: usize> Distribution<BinomialExtensionField<F, D>>
     for Standard
 where

fri/src/lib.rs

@@ -1,7 +1,5 @@
 //! An implementation of the FRI low-degree test (LDT).
 
-#![no_std]
-
 extern crate alloc;
 
 mod config;

fri/src/two_adic_pcs.rs

@@ -452,7 +452,7 @@ impl<F: Field, EF: ExtensionField<F>> PowersReducer<F, EF> {
     fn new(base: EF, max_width: usize) -> Self {
         let powers: Vec<EF> = base
             .powers()
-            .take(max_width.next_multiple_of(F::Packing::WIDTH))
+            .take(max_width + (max_width % F::Packing::WIDTH))
             .collect();
 
         let transposed_packed: Vec<Vec<F::Packing>> = transpose_vec(

goldilocks/Cargo.toml

@@ -7,7 +7,7 @@ license = "MIT OR Apache-2.0"
 [dependencies]
 p3-field = { path = "../field" }
 p3-util = { path = "../util" }
-rand = "0.8.5"
+rand = { version = "0.8.5", optional = true }
 serde = { version = "1.0", default-features = false, features = ["derive"] }
 
 [dev-dependencies]

goldilocks/src/lib.rs

@@ -15,7 +15,10 @@ use p3_field::{
     TwoAdicField,
 };
 use p3_util::{assume, branch_hint};
+
+#[cfg(feature = "rand")]
 use rand::distributions::{Distribution, Standard};
+#[cfg(feature = "rand")]
 use rand::Rng;
 use serde::{Deserialize, Serialize};
 
@@ -73,6 +76,7 @@ impl Debug for Goldilocks {
     }
 }
 
+#[cfg(feature = "rand")]
 impl Distribution<Goldilocks> for Standard {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> Goldilocks {
         loop {

matrix/Cargo.toml

@@ -8,9 +8,12 @@ license = "MIT OR Apache-2.0"
 p3-field = { path = "../field" }
 p3-maybe-rayon = { path = "../maybe-rayon" }
 p3-util = { path = "../util" }
-rand = "0.8.5"
+rand = { version = "0.8.5", optional = true }
 serde = { version = "1.0", features = ["derive"] }
 
+[features]
+rand = ["dep:rand"]
+
 [dev-dependencies]
 criterion = "0.5.1"