Refactor folders and Air Trait location (#25)

* Refactor

* add is empty

* Fmt commentary

* Remove print

* Enable test

* Pelito refactor

* Pelito refactor

* Refactor folders

* Refactor folders + Air Trait

* Apply formatting

---------

Co-authored-by: Mariano Nicolini <mariano.nicolini.91@gmail.com>

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,
@@ -859,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

@@ -5,7 +5,7 @@ use lambdaworks_math::{
 };
 
 use super::{boundary::BoundaryConstraints, evaluation_table::ConstraintEvaluationTable};
-use crate::air::{frame::Frame, trace::TraceTable, AIR};
+use crate::air::{frame::Frame, trace::TraceTable, traits::AIR};
 use std::iter::zip;
 
 pub struct ConstraintEvaluator<'poly, F: IsFFTField, A: AIR> {

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/fri/mod.rs

@@ -1,7 +1,7 @@
 pub mod fri_commitment;
 pub mod fri_decommit;
 mod fri_functions;
-use crate::air::AIR;
+use crate::air::traits::AIR;
 use crate::fri::fri_commitment::FriLayer;
 use crate::{transcript_to_field, transcript_to_usize, Domain};
 use lambdaworks_crypto::hash::sha3::Sha3Hasher;

src/lib.rs

@@ -6,7 +6,7 @@ pub mod proof;
 pub mod prover;
 pub mod verifier;
 
-use air::AIR;
+use air::traits::AIR;
 use lambdaworks_crypto::fiat_shamir::transcript::Transcript;
 use lambdaworks_fft::roots_of_unity::get_powers_of_primitive_root_coset;
 use lambdaworks_math::field::{

src/prover.rs

@@ -1,9 +1,10 @@
 use super::{
-    air::{constraints::evaluator::ConstraintEvaluator, frame::Frame, trace::TraceTable, AIR},
+    air::{constraints::evaluator::ConstraintEvaluator, frame::Frame, trace::TraceTable},
     fri::fri_commit_phase,
     sample_z_ood,
 };
 use crate::{
+    air::traits::AIR,
     batch_sample_challenges,
     fri::{fri_decommit::FriDecommitment, fri_query_phase, HASHER},
     proof::{DeepPolynomialOpenings, StarkProof},

src/verifier.rs

@@ -1,10 +1,9 @@
 use super::{
-    air::{constraints::evaluator::ConstraintEvaluator, AIR},
-    fri::fri_decommit::FriDecommitment,
+    air::constraints::evaluator::ConstraintEvaluator, fri::fri_decommit::FriDecommitment,
     sample_z_ood,
 };
 use crate::{
-    batch_sample_challenges, fri::HASHER, proof::StarkProof, transcript_to_field,
+    air::traits::AIR, batch_sample_challenges, fri::HASHER, proof::StarkProof, transcript_to_field,
     transcript_to_usize, Domain,
 };
 #[cfg(not(feature = "test_fiat_shamir"))]

tests/integration_tests.rs

@@ -2,10 +2,10 @@ use lambdaworks_math::field::fields::{
     fft_friendly::stark_252_prime_field::Stark252PrimeField, u64_prime_field::FE17,
 };
 use lambdaworks_math::helpers::resize_to_next_power_of_two;
-use lambdaworks_stark::air::example::cairo::PublicInputs;
+use lambdaworks_stark::air::cairo_air::air::{CairoAIR, PublicInputs};
 use lambdaworks_stark::air::example::fibonacci_rap::{fibonacci_rap_trace, FibonacciRAP};
 use lambdaworks_stark::air::example::{
-    cairo, dummy_air, fibonacci_2_columns, fibonacci_f17, quadratic_air, simple_fibonacci,
+    dummy_air, fibonacci_2_columns, fibonacci_f17, quadratic_air, simple_fibonacci,
 };
 use lambdaworks_stark::cairo_run::cairo_layout::CairoLayout;
 use lambdaworks_stark::cairo_run::run::run_program;
@@ -147,8 +147,7 @@ fn test_prove_cairo_program(file_path: &str) {
     // This should be auto calculated
     let padded_trace_length = memory.len().next_power_of_two();
 
-    let cairo_air =
-        cairo::CairoAIR::new(proof_options, padded_trace_length, register_states.steps());
+    let cairo_air = CairoAIR::new(proof_options, padded_trace_length, register_states.steps());
 
     let mut pub_inputs = PublicInputs::from_regs_and_mem(&register_states, &memory, program_size);
 
@@ -250,7 +249,7 @@ fn test_verifier_rejects_proof_of_a_slightly_different_program() {
     program_2[1] = FieldElement::from(5);
     program_2[3] = FieldElement::from(5);
 
-    let cairo_air = cairo::CairoAIR::new(proof_options, 16, program_1_raw_trace.steps());
+    let cairo_air = CairoAIR::new(proof_options, 16, program_1_raw_trace.steps());
 
     let first_step = &program_1_raw_trace.rows[0];
     let last_step = &program_1_raw_trace.rows[program_1_raw_trace.steps() - 1];
@@ -297,7 +296,7 @@ fn test_verifier_rejects_proof_with_different_range_bounds() {
         program.push(memory.get(&i).unwrap().clone());
     }
 
-    let cairo_air = cairo::CairoAIR::new(proof_options, 16, raw_trace.steps());
+    let cairo_air = CairoAIR::new(proof_options, 16, raw_trace.steps());
 
     let first_step = &raw_trace.rows[0];
     let last_step = &raw_trace.rows[raw_trace.steps() - 1];