Move ScriptExpr && Add Fraction && Add SelectorExpr

Cargo.toml

@@ -8,5 +8,5 @@ members = [
     "segment",
     "common",
     "uni-stark"
-]
+, "script_expr"]
 

script_expr/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "script_expr"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+bitcoin-script-stack = {git = "https://github.com/bitlayer-org/rust-bitcoin-script-stack.git"}
+bitcoin-script = { git = "https://github.com/bitlayer-org/rust-bitcoin-script" }
+bitcoin = { git = "https://github.com/bitlayer-org/rust-bitcoin", branch = "bf-stark" }
+bitcoin-scriptexec = { git = "https://github.com/bitlayer-org/rust-bitcoin-scriptexec" }
+p3-air = { git = "https://github.com/Plonky3/Plonky3.git" }
+p3-field = { git = "https://github.com/Plonky3/Plonky3.git" }
+p3-challenger = { git = "https://github.com/Plonky3/Plonky3.git" }
+p3-commit ={ git = "https://github.com/Plonky3/Plonky3.git" }
+p3-dft = { git = "https://github.com/Plonky3/Plonky3.git" }
+p3-matrix = { git = "https://github.com/Plonky3/Plonky3.git" }
+p3-maybe-rayon = { git = "https://github.com/Plonky3/Plonky3.git" }
+p3-util = { git = "https://github.com/Plonky3/Plonky3.git" }
+primitives = { path = "../primitives" }
+scripts = {path = "../scripts"}
+common ={ path = "../common" }
+
+[dev-dependencies]
+p3-baby-bear = { git = "https://github.com/Plonky3/Plonky3.git" }

uni-stark/src/expr/field_script_expr.rs → script_expr/src/field_script_expr.rs

@@ -7,6 +7,7 @@ use core::cell::Cell;
 use core::fmt::Debug;
 use core::iter::{Product, Sum};
 use core::ops::{Add, AddAssign, Mul, MulAssign, Neg, Sub, SubAssign};
+use std::ops::Div;
 
 use bitcoin_script_stack::stack::{StackTracker, StackVariable};
 use common::AbstractField;
@@ -22,8 +23,8 @@ use scripts::u31_lib::{
 use super::num_script_expr::NumScriptExpression;
 use super::variable::{ValueVariable, Variable};
 use super::Expression;
-use crate::expr::script_helper::{index_to_rou, value_exp_n};
-use crate::SymbolicExpression::{self, *};
+use crate::script_helper::{index_to_rou, value_exp_n};
+use crate::Fraction;
 
 pub enum FieldScriptExpression<F: BfField> {
     ValueVariable {
@@ -587,49 +588,6 @@ impl<F: BfField> Expression for FieldScriptExpression<F> {
     }
 }
 
-impl<F: BfField> From<&SymbolicExpression<F>> for FieldScriptExpression<F> {
-    fn from(value: &SymbolicExpression<F>) -> Self {
-        match value {
-            SymbolicExpression::Variable(v) => FieldScriptExpression::InputVariable {
-                sv: v.into(),
-                debug: Cell::new(false),
-                var: StackVariable::null(),
-            },
-            SymbolicExpression::IsFirstRow => FieldScriptExpression::one(),
-            SymbolicExpression::IsLastRow => FieldScriptExpression::one(),
-            SymbolicExpression::IsTransition => FieldScriptExpression::one(),
-            SymbolicExpression::Constant(f) => FieldScriptExpression::Constant {
-                f: f.clone(),
-                debug: Cell::new(false),
-                var: StackVariable::null(),
-            },
-            SymbolicExpression::Add { x, y, .. } => FieldScriptExpression::Add {
-                x: Arc::new(Box::new(FieldScriptExpression::from(&*x.clone()))),
-                y: Arc::new(Box::new(FieldScriptExpression::from(&*y.clone()))),
-                debug: Cell::new(false),
-                var: StackVariable::null(),
-            },
-            SymbolicExpression::Sub { x, y, .. } => FieldScriptExpression::Sub {
-                x: Arc::new(Box::new(FieldScriptExpression::from(&*x.clone()))),
-                y: Arc::new(Box::new(FieldScriptExpression::from(&*y.clone()))),
-                debug: Cell::new(false),
-                var: StackVariable::null(),
-            },
-            SymbolicExpression::Neg { x, .. } => FieldScriptExpression::Neg {
-                x: Arc::new(Box::new(FieldScriptExpression::from(&*x.clone()))),
-                debug: Cell::new(false),
-                var: StackVariable::null(),
-            },
-            SymbolicExpression::Mul { x, y, .. } => FieldScriptExpression::Mul {
-                x: Arc::new(Box::new(FieldScriptExpression::from(&*x.clone()))),
-                y: Arc::new(Box::new(FieldScriptExpression::from(&*y.clone()))),
-                debug: Cell::new(false),
-                var: StackVariable::null(),
-            },
-        }
-    }
-}
-
 impl<F: BfField> Default for FieldScriptExpression<F> {
     fn default() -> Self {
         Self::zero()
@@ -967,6 +925,14 @@ impl<F: BfField> Mul<F> for FieldScriptExpression<F> {
     }
 }
 
+impl<F: BfField> Div for FieldScriptExpression<F> {
+    type Output = Fraction<F>;
+
+    fn div(self, rhs: Self) -> Fraction<F> {
+        Fraction::<F>::new(self, rhs)
+    }
+}
+
 impl<F: BfField> MulAssign for FieldScriptExpression<F> {
     fn mul_assign(&mut self, rhs: Self) {
         *self = self.clone() * rhs;
@@ -1009,29 +975,8 @@ mod tests {
     use scripts::u31_lib::{u31ext_equalverify, BabyBear4};
 
     use super::{Expression, FieldScriptExpression, Variable, *};
-    use crate::SymbolicAirBuilder;
     type EF = BinomialExtensionField<BabyBear, 4>;
 
-    #[test]
-    fn test_symbolic_expr_constraints() {
-        let air_width: usize = 2;
-        let mut builder = SymbolicAirBuilder::<BabyBear>::new(0, air_width, 0);
-        let main_values = builder.main();
-        let (local, next) = (main_values.row_slice(0), main_values.row_slice(1));
-        let mut when_transition = builder.when_transition();
-        // a' <- b
-        when_transition.assert_eq(local[0], local[1]);
-
-        // b' <- a + b
-        when_transition.assert_eq(local[0] + local[1], next[1]);
-
-        let cs = builder.constraints();
-        let script_exp: Vec<FieldScriptExpression<BabyBear>> = cs
-            .iter()
-            .map(|cons| FieldScriptExpression::from(cons))
-            .collect();
-    }
-
     #[test]
     fn test_field_expr_expconst() {
         {

script_expr/src/fraction_expr.rs

@@ -0,0 +1,71 @@
+use std::ops::Add;
+use std::sync::Arc;
+
+use primitives::field::BfField;
+
+use super::FieldScriptExpression;
+use crate::Expression;
+
+pub struct Fraction<F: BfField> {
+    numerator: FieldScriptExpression<F>,
+    denominator: FieldScriptExpression<F>,
+}
+
+impl<F: BfField> Fraction<F> {
+    pub(crate) fn new(
+        numerator: FieldScriptExpression<F>,
+        denominator: FieldScriptExpression<F>,
+    ) -> Self {
+        Self {
+            numerator,
+            denominator,
+        }
+    }
+
+    fn get_numerator(&self) -> FieldScriptExpression<F> {
+        self.numerator.clone()
+    }
+
+    fn get_demonitor(&self) -> FieldScriptExpression<F> {
+        self.denominator.clone()
+    }
+
+    fn mul_expr(self, other: FieldScriptExpression<F>) -> Fraction<F> {
+        Fraction::new(self.numerator * other, self.denominator)
+    }
+
+    fn mul_fraction(self, other: Self) -> Fraction<F> {
+        Fraction::new(
+            self.numerator * other.numerator,
+            self.denominator * other.denominator,
+        )
+    }
+
+    fn add_expr(self, other: FieldScriptExpression<F>) -> Fraction<F> {
+        Fraction::new(
+            self.numerator + other * self.denominator.clone(),
+            self.denominator,
+        )
+    }
+
+    fn add_fraction(self, other: Self) -> Fraction<F> {
+        Fraction::new(
+            self.numerator * other.denominator.clone() + other.numerator * self.denominator.clone(),
+            self.denominator * other.denominator,
+        )
+    }
+
+    fn sub_expr(self, other: FieldScriptExpression<F>) -> Fraction<F> {
+        Fraction::new(
+            self.numerator - other * self.denominator.clone(),
+            self.denominator,
+        )
+    }
+
+    fn sub_fraction(self, other: Self) -> Fraction<F> {
+        Fraction::new(
+            self.numerator * other.denominator.clone() - other.numerator * self.denominator.clone(),
+            self.denominator * other.denominator,
+        )
+    }
+}

script_expr/src/lagrange.rs

@@ -0,0 +1,36 @@
+use common::TwoAdicField;
+use p3_field::ExtensionField;
+use primitives::field::BfField;
+
+use super::FieldScriptExpression;
+
+pub struct LagrangeSelectorsExpr<F: BfField> {
+    pub is_first_row: FieldScriptExpression<F>,
+    pub is_last_row: FieldScriptExpression<F>,
+    pub is_transition: FieldScriptExpression<F>,
+    pub z_h: FieldScriptExpression<F>,
+}
+
+pub fn selectors_at_point_expr<Ext: ExtensionField<Val> + BfField, Val: TwoAdicField + BfField>(
+    shift: Val,
+    point: Ext,
+    log_n: usize,
+) -> LagrangeSelectorsExpr<Ext> {
+    let unshifted_point = point * shift.inverse();
+    let mut unshifted_point_expr = FieldScriptExpression::<Ext>::default();
+    if shift == Val::one() {
+        unshifted_point_expr = FieldScriptExpression::<Ext>::from(unshifted_point);
+    } else {
+        unshifted_point_expr = FieldScriptExpression::from(point)
+            .mul_base(FieldScriptExpression::from(shift.inverse()));
+    }
+    let z_h = unshifted_point.exp_power_of_2(log_n) - Ext::one(); // (x-w^0)...(x-w^n-1)
+    let z_h_expr = unshifted_point_expr.exp_constant(2 ^ log_n as u32);
+    LagrangeSelectorsExpr {
+        is_first_row: (z_h / (unshifted_point - Ext::one())).into(), // hint
+        is_last_row: (z_h / (unshifted_point - Val::two_adic_generator(log_n).inverse())).into(), // hint
+        is_transition: unshifted_point_expr
+            .sub_base(Val::two_adic_generator(log_n).inverse().into()),
+        z_h: z_h_expr, //
+    }
+}

uni-stark/src/expr/mod.rs → script_expr/src/lib.rs

@@ -1,3 +1,5 @@
+extern crate alloc;
+
 use alloc::boxed::Box;
 use alloc::collections::BTreeMap;
 use alloc::sync::Arc;
@@ -9,17 +11,19 @@ use num_script_expr::NumScriptExpression;
 use primitives::field::BfField;
 use scripts::treepp::*;
 
-use crate::SymbolicExpression::{self, *};
-
 mod script_builder;
-pub use script_builder::*;
 mod variable;
 pub use variable::{ValueVariable, Variable};
 mod num_script_expr;
-// pub use num_script_expr::*;
+pub use num_script_expr::*;
 mod field_script_expr;
 pub use field_script_expr::*;
 mod script_helper;
+pub use script_builder::*;
+mod fraction_expr;
+pub use fraction_expr::*;
+mod lagrange;
+pub use lagrange::*;
 
 pub struct Executor<F: BfField> {
     to_exec_expr: FieldScriptExpression<F>,

uni-stark/src/expr/num_script_expr.rs → script_expr/src/num_script_expr.rs

@@ -14,7 +14,7 @@ use scripts::treepp::*;
 
 use super::variable::{ValueVariable, Variable};
 use super::{Expression, FieldScriptExpression};
-use crate::expr::script_helper::value_to_bits_format;
+use crate::script_helper::value_to_bits_format;
 
 pub enum NumScriptExpression {
     InputVariable {

uni-stark/src/expr/script_builder.rs → script_expr/src/script_builder.rs

@@ -9,16 +9,15 @@ use primitives::field::BfField;
 use scripts::treepp::*;
 
 use super::{FieldScriptExpression, ValueVariable, Variable};
-use crate::SymbolicExpression::{self, *};
 
 pub struct ScriptConstraintBuilder<F: BfField> {
     pub main: RowMajorMatrix<ValueVariable<F>>,
     pub public_values: Vec<Variable>,
-    pub is_first_row: F,
-    pub is_last_row: F,
-    pub is_transition: F,
+    pub is_first_row: FieldScriptExpression<F>,
+    pub is_last_row: FieldScriptExpression<F>,
+    pub is_transition: FieldScriptExpression<F>,
     pub constraints: Vec<FieldScriptExpression<F>>,
-    pub alpha: F,
+    pub alpha: FieldScriptExpression<F>,
 }
 
 impl<F: BfField> ScriptConstraintBuilder<F> {
@@ -30,6 +29,26 @@ impl<F: BfField> ScriptConstraintBuilder<F> {
         is_last_row: F,
         is_transition: F,
         alpha: F,
+    ) -> Self {
+        Self::new_with_expr(
+            local,
+            next,
+            num_public_values,
+            FieldScriptExpression::from(is_first_row),
+            FieldScriptExpression::from(is_last_row),
+            FieldScriptExpression::from(is_transition),
+            FieldScriptExpression::from(alpha),
+        )
+    }
+
+    pub fn new_with_expr(
+        local: Vec<F>,
+        next: Vec<F>,
+        num_public_values: usize,
+        is_first_row: FieldScriptExpression<F>,
+        is_last_row: FieldScriptExpression<F>,
+        is_transition: FieldScriptExpression<F>,
+        alpha: FieldScriptExpression<F>,
     ) -> Self {
         let width = local.len();
         let main_variables: Vec<ValueVariable<F>> = [local, next]
@@ -64,7 +83,7 @@ impl<F: BfField> ScriptConstraintBuilder<F> {
     pub fn get_accmulator_expr(&self) -> FieldScriptExpression<F> {
         let mut acc = self.constraints[0].clone();
         for i in 1..self.constraints.len() {
-            acc = acc * self.alpha + self.constraints[i].clone();
+            acc = acc * self.alpha.clone() + self.constraints[i].clone();
         }
         acc
     }
@@ -132,16 +151,16 @@ impl<F: BfField> AirBuilder for ScriptConstraintBuilder<F> {
     }
 
     fn is_first_row(&self) -> Self::Expr {
-        Self::Expr::from(self.is_first_row)
+        self.is_first_row.clone()
     }
 
     fn is_last_row(&self) -> Self::Expr {
-        Self::Expr::from(self.is_last_row)
+        self.is_last_row.clone()
     }
 
     fn is_transition_window(&self, size: usize) -> Self::Expr {
         if size == 2 {
-            Self::Expr::from(self.is_transition)
+            self.is_transition.clone()
         } else {
             panic!("uni-stark only supports a window size of 2")
         }

uni-stark/src/expr/script_helper.rs → script_expr/src/script_helper.rs

@@ -1,4 +1,3 @@
-
 use alloc::vec::Vec;
 use alloc::{format, vec};
 
@@ -11,7 +10,6 @@ use scripts::u31_lib::{
     BabyBear4, BabyBearU31,
 };
 
-
 /// constraint: bits <= 31
 /// input: [b_{0}, b_{1}, ..., b_{bits-1}]
 pub fn compress_bits(bits: usize) -> Script {