Implement trace generator for fibonacci.

crates/prover/src/core/prover/mod.rs

@@ -477,6 +477,10 @@ mod tests {
         ) -> ColumnVec<CircleEvaluation<CpuBackend, BaseField, BitReversedOrder>> {
             vec![]
         }
+
+        fn to_component(self) -> impl Component {
+            self
+        }
     }
 
     impl ComponentProver<CpuBackend> for TestComponent {

crates/prover/src/examples/fibonacci/component.rs

@@ -18,7 +18,7 @@ use crate::core::prover::BASE_TRACE;
 use crate::core::utils::bit_reverse_index;
 use crate::core::{ColumnVec, InteractionElements, LookupValues};
 use crate::trace_generation::registry::ComponentRegistry;
-use crate::trace_generation::ComponentTraceGenerator;
+use crate::trace_generation::{ComponentGen, ComponentTraceGenerator};
 
 pub struct FibonacciComponent {
     pub log_size: u32,
@@ -130,16 +130,46 @@ impl Component for FibonacciComponent {
     }
 }
 
-impl ComponentTraceGenerator<CpuBackend> for FibonacciComponent {
-    type ComponentInputs = ();
+pub struct FibonacciInput(pub u32, pub BaseField);
 
-    fn add_inputs(&mut self, _inputs: &Self::ComponentInputs) {}
+impl ComponentGen for FibonacciInput {}
+
+pub struct FibonacciTraceGenerator {
+    input_is_set: bool,
+}
+
+impl ComponentTraceGenerator<CpuBackend> for FibonacciTraceGenerator {
+    type ComponentInputs = FibonacciInput;
+
+    fn add_inputs(&mut self, inputs: &Self::ComponentInputs) {
+        assert!(
+            !self.input_is_set,
+            "Fibonacci input already set."
+        );
+        self.log_size = Some(inputs.0);
+        self.claim = Some(inputs.1);
+    }
 
     fn write_trace(
         _component_id: &str,
         _registry: &mut ComponentRegistry,
     ) -> ColumnVec<CircleEvaluation<CpuBackend, BaseField, BitReversedOrder>> {
-        vec![]
+        let trace_domain = CanonicCoset::new(self.log_size);
+        // TODO(AlonH): Consider using Vec::new instead of Vec::with_capacity throughout file.
+        let mut trace = Vec::with_capacity(trace_domain.size());
+
+        // Fill trace with fibonacci squared.
+        let mut a = BaseField::one();
+        let mut b = BaseField::one();
+        for _ in 0..trace_domain.size() {
+            trace.push(a);
+            let tmp = a.square() + b.square();
+            a = b;
+            b = tmp;
+        }
+
+        // Returns as a CircleEvaluation.
+        vec![CircleEvaluation::new_canonical_ordered(trace_domain, trace)]
     }
 
     fn write_interaction_trace(
@@ -149,6 +179,14 @@ impl ComponentTraceGenerator<CpuBackend> for FibonacciComponent {
     ) -> ColumnVec<CircleEvaluation<CpuBackend, BaseField, BitReversedOrder>> {
         vec![]
     }
+
+    fn to_component(self) -> impl Component {
+        assert!(
+            self.log_size.is_some() && self.claim.is_some(),
+            "Fibonacci input not set."
+        );
+        FibonacciComponent::new(self.log_size.unwrap(), self.claim.unwrap())
+    }
 }
 
 impl ComponentProver<CpuBackend> for FibonacciComponent {

crates/prover/src/examples/wide_fibonacci/component.rs

@@ -285,6 +285,10 @@ impl ComponentTraceGenerator<CpuBackend> for WideFibComponent {
             })
             .collect_vec()
     }
+
+    fn to_component(self) -> impl Component {
+        self
+    }
 }
 
 // Input for the fibonacci claim.

crates/prover/src/examples/wide_fibonacci/simd.rs

@@ -180,6 +180,10 @@ impl ComponentTraceGenerator<SimdBackend> for SimdWideFibComponent {
     ) -> ColumnVec<CircleEvaluation<SimdBackend, BaseField, BitReversedOrder>> {
         vec![]
     }
+
+    fn to_component(self) -> impl Component {
+        self
+    }
 }
 
 impl ComponentProver<SimdBackend> for SimdWideFibComponent {

crates/prover/src/trace_generation/mod.rs

@@ -3,7 +3,7 @@ pub mod registry;
 use downcast_rs::{impl_downcast, Downcast};
 use registry::ComponentRegistry;
 
-use crate::core::air::AirProver;
+use crate::core::air::{AirProver, Component};
 use crate::core::backend::Backend;
 use crate::core::channel::Blake2sChannel;
 use crate::core::fields::m31::BaseField;
@@ -38,6 +38,8 @@ pub trait ComponentTraceGenerator<B: Backend> {
         trace: &ColumnVec<&CircleEvaluation<B, BaseField, BitReversedOrder>>,
         elements: &InteractionElements,
     ) -> ColumnVec<CircleEvaluation<B, BaseField, BitReversedOrder>>;
+
+    fn to_component(self) -> impl Component;
 }
 
 pub trait AirTraceVerifier {

crates/prover/src/trace_generation/registry.rs

@@ -33,13 +33,58 @@ impl ComponentRegistry {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::core::air::accumulation::PointEvaluationAccumulator;
+    use crate::core::air::Component;
     use crate::core::backend::CpuBackend;
+    use crate::core::circle::CirclePoint;
     use crate::core::fields::m31::BaseField;
+    use crate::core::fields::qm31::SecureField;
+    use crate::core::pcs::TreeVec;
     use crate::core::poly::circle::CircleEvaluation;
     use crate::core::poly::BitReversedOrder;
-    use crate::core::{ColumnVec, InteractionElements};
+    use crate::core::{ColumnVec, InteractionElements, LookupValues};
     use crate::trace_generation::ComponentTraceGenerator;
 
+    impl Component for () {
+        fn n_constraints(&self) -> usize {
+            unimplemented!()
+        }
+
+        fn max_constraint_log_degree_bound(&self) -> u32 {
+            unimplemented!()
+        }
+
+        fn n_interaction_phases(&self) -> u32 {
+            unimplemented!()
+        }
+
+        fn trace_log_degree_bounds(&self) -> TreeVec<ColumnVec<u32>> {
+            unimplemented!()
+        }
+
+        fn mask_points(
+            &self,
+            _point: CirclePoint<SecureField>,
+        ) -> TreeVec<ColumnVec<Vec<CirclePoint<SecureField>>>> {
+            unimplemented!()
+        }
+
+        fn interaction_element_ids(&self) -> Vec<String> {
+            unimplemented!()
+        }
+
+        fn evaluate_constraint_quotients_at_point(
+            &self,
+            _point: CirclePoint<SecureField>,
+            _mask: &ColumnVec<Vec<SecureField>>,
+            _evaluation_accumulator: &mut PointEvaluationAccumulator,
+            _interaction_elements: &InteractionElements,
+            _lookup_values: &LookupValues,
+        ) {
+            unimplemented!()
+        }
+    }
+
     #[derive(Default)]
     struct ComponentA {
         inputs: Vec<u32>,
@@ -68,6 +113,10 @@ mod tests {
         ) -> ColumnVec<CircleEvaluation<CpuBackend, BaseField, BitReversedOrder>> {
             unimplemented!("TestTraceGenerator::write_interaction_trace")
         }
+
+        fn to_component(self) -> impl Component {
+            unimplemented!("TestTraceGenerator::to_component")
+        }
     }
 
     #[test]