From 5e1a65387289bf18a6da5de377f14866d00f3f68 Mon Sep 17 00:00:00 2001
From: Shuang Wu <shuangwu@192.168.1.229>
Date: Fri, 20 Sep 2024 17:27:02 +0300
Subject: [PATCH] fibonacci sequence generated from Powdr is proved by stwo
 successful, sequence length is 6. stwo use data parallel structure to prove,
 which means it can prove many fibonacci instance (32 in code) at the same
 time, now I just get the fibonacci sequence from powdr, copy it to 32
 identical instances, then use stwo to prove, many manul process still #1783

---
 backend/src/stwo/circuit_builder.rs | 85 +++++++++++++++++++++++++++++
 backend/src/stwo/prover.rs          |  9 ++-
 2 files changed, 91 insertions(+), 3 deletions(-)

diff --git a/backend/src/stwo/circuit_builder.rs b/backend/src/stwo/circuit_builder.rs
index 98bffbf56..f4493d682 100644
--- a/backend/src/stwo/circuit_builder.rs
+++ b/backend/src/stwo/circuit_builder.rs
@@ -147,4 +147,89 @@ pub fn generate_stwo_trace<T>(witness: &[(String, Vec<T>)], log_n_instances: u32
       
 
         
+}
+
+pub fn generate_parallel_stwo_trace_by_witness_repitition<T: Clone>(witness: &[(String, Vec<T>)], log_n_instances: u32
+)-> ColumnVec<CircleEvaluation<SimdBackend, BaseField, BitReversedOrder>> {
+
+    let trace: Vec<PackedBaseField> = witness
+    .iter()
+    .flat_map(|(_, vec)| {
+        vec.iter().flat_map(|mersenne| {
+
+            let ptr = mersenne as *const T as *const u32;
+
+            let value = unsafe {
+                *ptr // Dereference the pointer to get the u32 value
+            };
+
+            // Repeat the value 32 times
+            let repeated = vec![value; 32];
+
+            // Split the repeated vector into two chunks of 16 elements each
+            let chunk1: [u32; N_LANES] = repeated[0..16]
+                .try_into()
+                .expect("Chunk should be of size N_LANES");
+            let chunk2: [u32; N_LANES] = repeated[16..32]
+                .try_into()
+                .expect("Chunk should be of size N_LANES");
+
+            // Convert chunks to PackedBaseField
+            // Note: We use unsafe block because PackedBaseField::load is unsafe
+            unsafe {
+                vec![
+                    PackedBaseField::load(chunk1.as_ptr()),
+                    PackedBaseField::load(chunk2.as_ptr()),
+                ]
+            }
+        })
+    })
+    .collect(); // Collect the flattened iterator into a Vec<PackedBaseField>
+
+
+        println!("from generate stwo trace trace");
+        println!("{:?}", trace);
+
+        let mut trace_stwo= (0..6)//fibonacci length
+        .map(|_| Col::<SimdBackend, BaseField>::zeros(1 << log_n_instances))
+        .collect_vec();
+
+        
+        // column x
+        trace_stwo[0].data[0]= trace[0];
+        trace_stwo[0].data[1]= trace[1];
+
+        println!("from generate stwo trace trace 64 ......");
+        println!("{:?}", trace[64]);
+
+        println!("from generate stwo trace trace 65 ......");
+        println!("{:?}", trace[65]);
+
+        trace_stwo[1].data[0]= trace[64];
+        trace_stwo[1].data[1]= trace[65];
+
+        trace_stwo[2].data[0]= trace[66];
+        trace_stwo[2].data[1]= trace[67];
+
+        trace_stwo[3].data[0]= trace[68];
+        trace_stwo[3].data[1]= trace[69];
+
+        trace_stwo[4].data[0]= trace[70];
+        trace_stwo[4].data[1]= trace[71];
+
+        trace_stwo[5].data[0]= trace[72];
+        trace_stwo[5].data[1]= trace[73];
+
+        println!("from generate stwo trace trace_stwo repititions");
+        println!("{:?}", trace_stwo);
+
+        let domain = CanonicCoset::new(5).circle_domain();
+        trace_stwo
+        .into_iter()
+        .map(|eval| CircleEvaluation::<SimdBackend, BaseField, BitReversedOrder>::new(domain, eval))
+        .collect_vec()  
+
+      
+
+        
 }
diff --git a/backend/src/stwo/prover.rs b/backend/src/stwo/prover.rs
index c9ea637b1..c796b2970 100644
--- a/backend/src/stwo/prover.rs
+++ b/backend/src/stwo/prover.rs
@@ -18,6 +18,7 @@ use powdr_executor::witgen::WitgenCallback;
 use powdr_number::{DegreeType, FieldElement, KnownField};
 use super::circuit_builder::PowdrCircuit;
 use super::circuit_builder::generate_stwo_trace;
+use super::circuit_builder::generate_parallel_stwo_trace_by_witness_repitition;
 use super::circuit_builder::WideFibonacciComponent;
 use super::circuit_builder::WideFibonacciEval;
 
@@ -135,7 +136,7 @@ impl<F: FieldElement> StwoProver<F> {
     ) {
 
         const LOG_N_INSTANCES: u32 = 5;
-        const FIB_SEQUENCE_LENGTH: usize=32;
+        const FIB_SEQUENCE_LENGTH: usize=6;
 
        
 
@@ -159,10 +160,12 @@ impl<F: FieldElement> StwoProver<F> {
         let circuit = PowdrCircuit::new(&self.analyzed)
              .with_witgen_callback(witgen_callback)
              .with_witness(witness);
+        print!("witness from powdr {:?}", witness );
 
-        let trace = generate_stwo_trace(witness,LOG_N_INSTANCES);
+        //let trace = generate_stwo_trace(witness,LOG_N_INSTANCES);
+        let trace=generate_parallel_stwo_trace_by_witness_repitition(witness, LOG_N_INSTANCES);
 
-        println!("this is from the generate stwo trace in circle domain \n {:?}",generate_stwo_trace(witness,LOG_N_INSTANCES));
+        println!("this is from the generate stwo trace in repitition \n {:?}",generate_parallel_stwo_trace_by_witness_repitition(witness,LOG_N_INSTANCES));
 
         let mut tree_builder = commitment_scheme.tree_builder();
         tree_builder.extend_evals(trace);