Merge branch 'main' into optimize-prover-boundary-evaluations

Cargo.toml

@@ -26,4 +26,4 @@ rstest = "0.17.0"
 
 [features]
 test_fiat_shamir = []
-
+metal = ["lambdaworks-fft/metal"]

Makefile

@@ -5,3 +5,6 @@ test:
 
 clippy:
 	cargo clippy --workspace --all-targets -- -D warnings
+
+build_metal:
+	cargo b --features metal --release

src/air/example/cairo.rs → src/air/cairo_air/air.rs

@@ -11,7 +11,7 @@ use crate::{
         context::{AirContext, ProofOptions},
         frame::Frame,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     cairo_vm::{
         cairo_mem::CairoMemory, cairo_trace::CairoTrace,
@@ -162,13 +162,46 @@ pub struct PublicInputs {
     pub num_steps: usize, // number of execution steps
 }
 
+impl PublicInputs {
+    /// Creates a Public Input from register states and memory
+    /// - In the future we should use the output of the Cairo Runner. This is not currently supported in Cairo RS
+    /// - RangeChecks are not filled, and the prover mutates them inside the prove function. This works but also should be loaded from the Cairo RS output
+    pub fn from_regs_and_mem(
+        register_states: &CairoTrace,
+        memory: &CairoMemory,
+        program_size: usize,
+    ) -> Self {
+        let mut program = vec![];
+
+        for i in 1..=program_size as u64 {
+            program.push(memory.get(&i).unwrap().clone());
+        }
+
+        let last_step = &register_states.rows[register_states.steps() - 1];
+
+        PublicInputs {
+            pc_init: FE::from(register_states.rows[0].pc),
+            ap_init: FE::from(register_states.rows[0].ap),
+            fp_init: FE::from(register_states.rows[0].fp),
+            pc_final: FieldElement::from(last_step.pc),
+            ap_final: FieldElement::from(last_step.ap),
+            range_check_min: None,
+            range_check_max: None,
+            program,
+            num_steps: register_states.steps(),
+        }
+    }
+}
 #[derive(Clone)]
 pub struct CairoAIR {
     pub context: AirContext,
     pub number_steps: usize,
 }
 
 impl CairoAIR {
+    /// Creates a new CairoAIR from proof_options
+    /// full_trace_length: Padding to 2^n
+    /// number_steps: Number of steps of the execution / register steps / rows in cairo runner trace
     pub fn new(proof_options: ProofOptions, full_trace_length: usize, number_steps: usize) -> Self {
         let context = AirContext {
             options: proof_options,
@@ -826,13 +859,13 @@ mod test {
 
     use crate::{
         air::{
-            context::ProofOptions,
-            debug::validate_trace,
-            example::cairo::{
+            cairo_air::air::{
                 add_program_in_public_input_section, CairoAIR, PublicInputs, OFF_DST, OFF_OP1,
             },
+            context::ProofOptions,
+            debug::validate_trace,
             trace::TraceTable,
-            AIR,
+            traits::AIR,
         },
         cairo_run::run::Error,
         cairo_vm::{cairo_mem::CairoMemory, cairo_trace::CairoTrace},

src/air/cairo_air/mod.rs

@@ -0,0 +1 @@
+pub mod air;

src/air/constraints/evaluator.rs

@@ -6,7 +6,7 @@ use lambdaworks_math::{
 
 use super::{boundary::BoundaryConstraints, evaluation_table::ConstraintEvaluationTable};
 use crate::{
-    air::{frame::Frame, trace::TraceTable, AIR},
+    air::{frame::Frame, trace::TraceTable, traits::AIR},
     prover::evaluate_polynomial_on_lde_domain,
     Domain,
 };

src/air/debug.rs

@@ -10,7 +10,7 @@ use crate::{
     Domain,
 };
 
-use super::AIR;
+use super::traits::AIR;
 
 /// Validates that the trace is valid with respect to the supplied AIR constraints
 pub fn validate_trace<F: IsFFTField, A: AIR<Field = F>>(

src/air/example/dummy_air.rs

@@ -4,7 +4,7 @@ use crate::{
         constraints::boundary::{BoundaryConstraint, BoundaryConstraints},
         context::AirContext,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     fri::FieldElement,
     prover::ProvingError,

src/air/example/fibonacci_2_columns.rs

@@ -4,7 +4,7 @@ use crate::{
         constraints::boundary::{BoundaryConstraint, BoundaryConstraints},
         context::AirContext,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     fri::FieldElement,
     prover::ProvingError,

src/air/example/fibonacci_f17.rs

@@ -4,7 +4,7 @@ use crate::{
         constraints::boundary::{BoundaryConstraint, BoundaryConstraints},
         context::AirContext,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     fri::FieldElement,
     prover::ProvingError,

src/air/example/fibonacci_rap.rs

@@ -6,7 +6,7 @@ use crate::{
         context::AirContext,
         frame::Frame,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     fri::FieldElement,
     prover::ProvingError,

src/air/example/mod.rs

@@ -1,4 +1,3 @@
-pub mod cairo;
 pub mod dummy_air;
 pub mod fibonacci_2_columns;
 pub mod fibonacci_f17;

src/air/example/quadratic_air.rs

@@ -4,7 +4,7 @@ use crate::{
         constraints::boundary::{BoundaryConstraint, BoundaryConstraints},
         context::AirContext,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     fri::FieldElement,
     prover::ProvingError,

src/air/example/simple_fibonacci.rs

@@ -4,7 +4,7 @@ use crate::{
         constraints::boundary::{BoundaryConstraint, BoundaryConstraints},
         context::AirContext,
         trace::TraceTable,
-        AIR,
+        traits::AIR,
     },
     fri::FieldElement,
     prover::ProvingError,

src/air/mod.rs

@@ -1,100 +1,9 @@
-use crate::prover::ProvingError;
-
-use self::{
-    constraints::boundary::BoundaryConstraints,
-    context::{AirContext, ProofOptions},
-    frame::Frame,
-    trace::TraceTable,
-};
-use lambdaworks_crypto::fiat_shamir::transcript::Transcript;
-use lambdaworks_fft::roots_of_unity::get_powers_of_primitive_root_coset;
-use lambdaworks_math::{
-    field::{element::FieldElement, traits::IsFFTField},
-    polynomial::Polynomial,
-};
-
+pub mod cairo_air;
 pub mod constraints;
 pub mod context;
 #[cfg(debug_assertions)]
 pub mod debug;
 pub mod example;
 pub mod frame;
 pub mod trace;
-
-pub trait AIR: Clone {
-    type Field: IsFFTField;
-    type RawTrace;
-    type RAPChallenges;
-    type PublicInput;
-
-    fn build_main_trace(
-        &self,
-        raw_trace: &Self::RawTrace,
-        public_input: &mut Self::PublicInput,
-    ) -> Result<TraceTable<Self::Field>, ProvingError>;
-
-    fn build_auxiliary_trace(
-        &self,
-        main_trace: &TraceTable<Self::Field>,
-        rap_challenges: &Self::RAPChallenges,
-        public_input: &Self::PublicInput,
-    ) -> TraceTable<Self::Field>;
-
-    fn build_rap_challenges<T: Transcript>(&self, transcript: &mut T) -> Self::RAPChallenges;
-
-    fn number_auxiliary_rap_columns(&self) -> usize;
-
-    fn composition_poly_degree_bound(&self) -> usize;
-
-    fn compute_transition(
-        &self,
-        frame: &Frame<Self::Field>,
-        rap_challenges: &Self::RAPChallenges,
-    ) -> Vec<FieldElement<Self::Field>>;
-    fn boundary_constraints(
-        &self,
-        rap_challenges: &Self::RAPChallenges,
-        public_input: &Self::PublicInput,
-    ) -> BoundaryConstraints<Self::Field>;
-    fn transition_divisors(&self) -> Vec<Polynomial<FieldElement<Self::Field>>> {
-        let trace_length = self.context().trace_length;
-        let roots_of_unity_order = trace_length.trailing_zeros();
-        let roots_of_unity = get_powers_of_primitive_root_coset(
-            roots_of_unity_order as u64,
-            self.context().trace_length,
-            &FieldElement::<Self::Field>::one(),
-        )
-        .unwrap();
-
-        let mut result = vec![];
-        let x_n = Polynomial::new_monomial(FieldElement::one(), trace_length);
-        let x = Polynomial::new_monomial(FieldElement::one(), 1);
-        for transition_idx in 0..self.context().num_transition_constraints {
-            // X^(trace_length) - 1
-            let roots_of_unity_vanishing_polynomial = &x_n - FieldElement::one();
-
-            let mut exemptions_polynomial = Polynomial::new_monomial(FieldElement::one(), 0);
-
-            for i in 0..self.context().transition_exemptions[transition_idx] {
-                exemptions_polynomial =
-                    exemptions_polynomial * (&x - &roots_of_unity[roots_of_unity.len() - 1 - i])
-            }
-
-            result.push(roots_of_unity_vanishing_polynomial / exemptions_polynomial);
-        }
-
-        result
-    }
-    fn context(&self) -> AirContext;
-    fn options(&self) -> ProofOptions {
-        self.context().options
-    }
-
-    fn blowup_factor(&self) -> u8 {
-        self.options().blowup_factor
-    }
-
-    fn num_transition_constraints(&self) -> usize {
-        self.context().num_transition_constraints
-    }
-}
+pub mod traits;

src/air/traits.rs

@@ -0,0 +1,96 @@
+use lambdaworks_crypto::fiat_shamir::transcript::Transcript;
+use lambdaworks_math::{
+    field::{element::FieldElement, traits::IsFFTField},
+    polynomial::Polynomial,
+};
+
+use crate::prover::ProvingError;
+
+use super::{
+    constraints::boundary::BoundaryConstraints,
+    context::{AirContext, ProofOptions},
+    frame::Frame,
+    trace::TraceTable,
+};
+use crate::get_powers_of_primitive_root_coset;
+/// AIR is a representation of the Constraints
+pub trait AIR: Clone {
+    type Field: IsFFTField;
+    type RawTrace;
+    type RAPChallenges;
+    type PublicInput;
+
+    fn build_main_trace(
+        &self,
+        raw_trace: &Self::RawTrace,
+        public_input: &mut Self::PublicInput,
+    ) -> Result<TraceTable<Self::Field>, ProvingError>;
+
+    fn build_auxiliary_trace(
+        &self,
+        main_trace: &TraceTable<Self::Field>,
+        rap_challenges: &Self::RAPChallenges,
+        public_input: &Self::PublicInput,
+    ) -> TraceTable<Self::Field>;
+
+    fn build_rap_challenges<T: Transcript>(&self, transcript: &mut T) -> Self::RAPChallenges;
+
+    fn number_auxiliary_rap_columns(&self) -> usize;
+
+    fn composition_poly_degree_bound(&self) -> usize;
+
+    fn compute_transition(
+        &self,
+        frame: &Frame<Self::Field>,
+        rap_challenges: &Self::RAPChallenges,
+    ) -> Vec<FieldElement<Self::Field>>;
+
+    fn boundary_constraints(
+        &self,
+        rap_challenges: &Self::RAPChallenges,
+        public_input: &Self::PublicInput,
+    ) -> BoundaryConstraints<Self::Field>;
+
+    fn transition_divisors(&self) -> Vec<Polynomial<FieldElement<Self::Field>>> {
+        let trace_length = self.context().trace_length;
+        let roots_of_unity_order = trace_length.trailing_zeros();
+        let roots_of_unity = get_powers_of_primitive_root_coset(
+            roots_of_unity_order as u64,
+            self.context().trace_length,
+            &FieldElement::<Self::Field>::one(),
+        )
+        .unwrap();
+
+        let mut result = vec![];
+        let x_n = Polynomial::new_monomial(FieldElement::one(), trace_length);
+        let x = Polynomial::new_monomial(FieldElement::one(), 1);
+        for transition_idx in 0..self.context().num_transition_constraints {
+            // X^(trace_length) - 1
+            let roots_of_unity_vanishing_polynomial = &x_n - FieldElement::one();
+
+            let mut exemptions_polynomial = Polynomial::new_monomial(FieldElement::one(), 0);
+
+            for i in 0..self.context().transition_exemptions[transition_idx] {
+                exemptions_polynomial =
+                    exemptions_polynomial * (&x - &roots_of_unity[roots_of_unity.len() - 1 - i])
+            }
+
+            result.push(roots_of_unity_vanishing_polynomial / exemptions_polynomial);
+        }
+
+        result
+    }
+    fn context(&self) -> AirContext;
+
+    fn options(&self) -> ProofOptions {
+        self.context().options
+    }
+
+    fn blowup_factor(&self) -> u8 {
+        self.options().blowup_factor
+    }
+
+    fn num_transition_constraints(&self) -> usize {
+        self.context().num_transition_constraints
+    }
+}

src/cairo_run/cairo_layout.rs

@@ -0,0 +1,29 @@
+pub enum CairoLayout {
+    Plain,
+    Small,
+    Dex,
+    Recursive,
+    Starknet,
+    StarknetWithKeccak,
+    RecursiveLargeOutput,
+    AllCairo,
+    AllSolidity,
+    Dynamic,
+}
+
+impl CairoLayout {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            CairoLayout::Plain => "plain",
+            CairoLayout::Small => "small",
+            CairoLayout::Dex => "dex",
+            CairoLayout::Recursive => "recursive",
+            CairoLayout::Starknet => "starknet",
+            CairoLayout::StarknetWithKeccak => "starknet_with_keccak",
+            CairoLayout::RecursiveLargeOutput => "recursive_large_output",
+            CairoLayout::AllCairo => "all_cairo",
+            CairoLayout::AllSolidity => "all_solidity",
+            CairoLayout::Dynamic => "dynamic",
+        }
+    }
+}