Have type for VariablySizedColumn instead of VariablySizedColumns

powdr-labs · Jul 9, 2024 · 0c43fdf · 0c43fdf
1 parent 56fed8c
commit 0c43fdf
Show file tree

Hide file tree

Showing 15 changed files with 102 additions and 119 deletions.
diff --git a/backend/src/composite/mod.rs b/backend/src/composite/mod.rs
@@ -2,7 +2,7 @@ use std::{collections::BTreeMap, io, marker::PhantomData, path::PathBuf, sync::A
 
 use powdr_ast::analyzed::Analyzed;
 use powdr_executor::witgen::WitgenCallback;
-use powdr_number::{DegreeType, FieldElement, VariablySizedColumns};
+use powdr_number::{get_only_size_cloned, DegreeType, FieldElement, VariablySizedColumn};
 use serde::{Deserialize, Serialize};
 use split::select_machine_columns;
 
@@ -35,7 +35,7 @@ impl<F: FieldElement, B: BackendFactory<F>> BackendFactory<F> for CompositeBacke
     fn create<'a>(
         &self,
         pil: Arc<Analyzed<F>>,
-        fixed: Arc<VariablySizedColumns<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
         output_dir: Option<PathBuf>,
         setup: Option<&mut dyn std::io::Read>,
         verification_key: Option<&mut dyn std::io::Read>,
@@ -47,11 +47,8 @@ impl<F: FieldElement, B: BackendFactory<F>> BackendFactory<F> for CompositeBacke
         }
 
         // TODO: Handle multiple sizes.
-        let fixed = Arc::new(
-            fixed
-                .get_only_size_cloned()
-                .map_err(|_| Error::NoVariableDegreeAvailable)?,
-        );
+        let fixed =
+            Arc::new(get_only_size_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?);
 
         let per_machine_data = split::split_pil((*pil).clone())
             .into_iter()
@@ -71,10 +68,8 @@ impl<F: FieldElement, B: BackendFactory<F>> BackendFactory<F> for CompositeBacke
                             .map(|(symbol, _)| symbol),
                     )
                     .into_iter()
-                    .map(|(column_name, values)| {
-                        (column_name, [(values.len(), values)].into_iter().collect())
-                    })
-                    .into(),
+                    .map(|(column_name, values)| (column_name, values.into()))
+                    .collect(),
                 );
                 let backend = self.factory.create(
                     pil.clone(),

diff --git a/backend/src/estark/mod.rs b/backend/src/estark/mod.rs
@@ -16,7 +16,7 @@ use crate::{Backend, BackendFactory, BackendOptions, Error, Proof};
 use powdr_ast::analyzed::Analyzed;
 
 use powdr_executor::witgen::WitgenCallback;
-use powdr_number::{DegreeType, FieldElement, VariablySizedColumns};
+use powdr_number::{get_only_size_cloned, DegreeType, FieldElement, VariablySizedColumn};
 use serde::Serialize;
 use starky::types::{StarkStruct, Step, PIL};
 
@@ -222,18 +222,15 @@ impl<F: FieldElement> BackendFactory<F> for DumpFactory {
     fn create<'a>(
         &self,
         analyzed: Arc<Analyzed<F>>,
-        fixed: Arc<VariablySizedColumns<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
         output_dir: Option<PathBuf>,
         setup: Option<&mut dyn std::io::Read>,
         verification_key: Option<&mut dyn std::io::Read>,
         verification_app_key: Option<&mut dyn std::io::Read>,
         options: BackendOptions,
     ) -> Result<Box<dyn crate::Backend<'a, F> + 'a>, Error> {
-        let fixed = Arc::new(
-            fixed
-                .get_only_size_cloned()
-                .map_err(|_| Error::NoVariableDegreeAvailable)?,
-        );
+        let fixed =
+            Arc::new(get_only_size_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?);
         Ok(Box::new(DumpBackend(EStarkFilesCommon::create(
             &analyzed,
             fixed,

diff --git a/backend/src/estark/starky_wrapper.rs b/backend/src/estark/starky_wrapper.rs
@@ -6,7 +6,7 @@ use std::time::Instant;
 use crate::{Backend, BackendFactory, BackendOptions, Error};
 use powdr_ast::analyzed::Analyzed;
 use powdr_executor::witgen::WitgenCallback;
-use powdr_number::{FieldElement, GoldilocksField, LargeInt, VariablySizedColumns};
+use powdr_number::{get_only_size_cloned, FieldElement, GoldilocksField, LargeInt, VariablySizedColumn};
 
 use starky::{
     merklehash::MerkleTreeGL,
@@ -27,7 +27,7 @@ impl<F: FieldElement> BackendFactory<F> for Factory {
     fn create<'a>(
         &self,
         pil: Arc<Analyzed<F>>,
-        fixed: Arc<VariablySizedColumns<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
         _output_dir: Option<PathBuf>,
         setup: Option<&mut dyn std::io::Read>,
         verification_key: Option<&mut dyn std::io::Read>,
@@ -50,11 +50,8 @@ impl<F: FieldElement> BackendFactory<F> for Factory {
             return Err(Error::NoVariableDegreeAvailable);
         }
 
-        let fixed = Arc::new(
-            fixed
-                .get_only_size_cloned()
-                .map_err(|_| Error::NoVariableDegreeAvailable)?,
-        );
+        let fixed =
+            Arc::new(get_only_size_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?);
 
         let proof_type: ProofType = ProofType::from(options);
 

diff --git a/backend/src/halo2/mod.rs b/backend/src/halo2/mod.rs
@@ -7,7 +7,7 @@ use std::sync::Arc;
 use crate::{Backend, BackendFactory, BackendOptions, Error, Proof};
 use powdr_ast::analyzed::Analyzed;
 use powdr_executor::witgen::WitgenCallback;
-use powdr_number::{DegreeType, FieldElement, VariablySizedColumns};
+use powdr_number::{get_only_size_cloned, DegreeType, FieldElement, VariablySizedColumn};
 use prover::{generate_setup, Halo2Prover};
 
 use serde::de::{self, Deserializer};
@@ -76,7 +76,7 @@ impl<F: FieldElement> BackendFactory<F> for Halo2ProverFactory {
     fn create<'a>(
         &self,
         pil: Arc<Analyzed<F>>,
-        fixed: Arc<VariablySizedColumns<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
         _output_dir: Option<PathBuf>,
         setup: Option<&mut dyn io::Read>,
         verification_key: Option<&mut dyn io::Read>,
@@ -87,11 +87,8 @@ impl<F: FieldElement> BackendFactory<F> for Halo2ProverFactory {
             return Err(Error::NoVariableDegreeAvailable);
         }
         let proof_type = ProofType::from(options);
-        let fixed = Arc::new(
-            fixed
-                .get_only_size_cloned()
-                .map_err(|_| Error::NoVariableDegreeAvailable)?,
-        );
+        let fixed =
+            Arc::new(get_only_size_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?);
         let mut halo2 = Box::new(Halo2Prover::new(pil, fixed, setup, proof_type)?);
         if let Some(vk) = verification_key {
             halo2.add_verification_key(vk);
@@ -190,7 +187,7 @@ impl<F: FieldElement> BackendFactory<F> for Halo2MockFactory {
     fn create<'a>(
         &self,
         pil: Arc<Analyzed<F>>,
-        fixed: Arc<VariablySizedColumns<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
         _output_dir: Option<PathBuf>,
         setup: Option<&mut dyn io::Read>,
         verification_key: Option<&mut dyn io::Read>,
@@ -207,11 +204,8 @@ impl<F: FieldElement> BackendFactory<F> for Halo2MockFactory {
             return Err(Error::NoAggregationAvailable);
         }
 
-        let fixed = Arc::new(
-            fixed
-                .get_only_size_cloned()
-                .map_err(|_| Error::NoVariableDegreeAvailable)?,
-        );
+        let fixed =
+            Arc::new(get_only_size_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?);
 
         Ok(Box::new(Halo2Mock { pil, fixed }))
     }

diff --git a/backend/src/lib.rs b/backend/src/lib.rs
@@ -10,7 +10,7 @@ mod composite;
 
 use powdr_ast::analyzed::Analyzed;
 use powdr_executor::witgen::WitgenCallback;
-use powdr_number::{DegreeType, FieldElement, VariablySizedColumns};
+use powdr_number::{DegreeType, FieldElement, VariablySizedColumn};
 use std::{io, path::PathBuf, sync::Arc};
 use strum::{Display, EnumString, EnumVariantNames};
 
@@ -134,7 +134,7 @@ pub trait BackendFactory<F: FieldElement> {
     fn create<'a>(
         &self,
         pil: Arc<Analyzed<F>>,
-        fixed: Arc<VariablySizedColumns<F>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<F>)>>,
         output_dir: Option<PathBuf>,
         setup: Option<&mut dyn io::Read>,
         verification_key: Option<&mut dyn io::Read>,

diff --git a/backend/src/plonky3/mod.rs b/backend/src/plonky3/mod.rs
@@ -2,7 +2,9 @@ use std::{io, path::PathBuf, sync::Arc};
 
 use powdr_ast::analyzed::Analyzed;
 use powdr_executor::witgen::WitgenCallback;
-use powdr_number::{FieldElement, GoldilocksField, LargeInt, VariablySizedColumns};
+use powdr_number::{
+    get_only_size_cloned, FieldElement, GoldilocksField, LargeInt, VariablySizedColumn,
+};
 use powdr_plonky3::Plonky3Prover;
 
 use crate::{Backend, BackendFactory, BackendOptions, Error, Proof};
@@ -13,7 +15,7 @@ impl<T: FieldElement> BackendFactory<T> for Factory {
     fn create<'a>(
         &self,
         pil: Arc<Analyzed<T>>,
-        fixed: Arc<VariablySizedColumns<T>>,
+        fixed: Arc<Vec<(String, VariablySizedColumn<T>)>>,
         _output_dir: Option<PathBuf>,
         setup: Option<&mut dyn io::Read>,
         verification_key: Option<&mut dyn io::Read>,
@@ -34,11 +36,8 @@ impl<T: FieldElement> BackendFactory<T> for Factory {
             return Err(Error::NoVariableDegreeAvailable);
         }
 
-        let fixed = Arc::new(
-            fixed
-                .get_only_size_cloned()
-                .map_err(|_| Error::NoVariableDegreeAvailable)?,
-        );
+        let fixed =
+            Arc::new(get_only_size_cloned(&fixed).map_err(|_| Error::NoVariableDegreeAvailable)?);
 
         let mut p3 = Box::new(Plonky3Prover::new(pil, fixed));
 

diff --git a/executor/src/constant_evaluator/mod.rs b/executor/src/constant_evaluator/mod.rs
@@ -11,7 +11,7 @@ use powdr_ast::{
         IndexAccess,
     },
 };
-use powdr_number::{BigInt, BigUint, DegreeType, FieldElement, VariablySizedColumns};
+use powdr_number::{BigInt, BigUint, DegreeType, FieldElement, VariablySizedColumn};
 use powdr_pil_analyzer::evaluator::{self, Definitions, SymbolLookup, Value};
 use rayon::prelude::{IntoParallelIterator, ParallelIterator};
 
@@ -20,7 +20,7 @@ use rayon::prelude::{IntoParallelIterator, ParallelIterator};
 /// @returns the names (in source order) and the values for the columns.
 /// Arrays of columns are flattened, the name of the `i`th array element
 /// is `name[i]`.
-pub fn generate<T: FieldElement>(analyzed: &Analyzed<T>) -> VariablySizedColumns<T> {
+pub fn generate<T: FieldElement>(analyzed: &Analyzed<T>) -> Vec<(String, VariablySizedColumn<T>)> {
     let mut fixed_cols = HashMap::new();
     for (poly, value) in analyzed.constant_polys_in_source_order() {
         if let Some(value) = value {
@@ -37,8 +37,8 @@ pub fn generate<T: FieldElement>(analyzed: &Analyzed<T>) -> VariablySizedColumns
     fixed_cols
         .into_iter()
         .sorted_by_key(|(_, (id, _))| *id)
-        .map(|(name, (_, values))| (name, [(values.len(), values)].into_iter().collect()))
-        .into()
+        .map(|(name, (_, values))| (name, values.into()))
+        .collect()
 }
 
 fn generate_values<T: FieldElement>(
@@ -169,7 +169,7 @@ impl<'a, T: FieldElement> SymbolLookup<'a, T> for CachedSymbols<'a, T> {
 
 #[cfg(test)]
 mod test {
-    use powdr_number::GoldilocksField;
+    use powdr_number::{get_only_size, GoldilocksField};
     use powdr_pil_analyzer::analyze_string;
     use pretty_assertions::assert_eq;
     use test_log::test;
@@ -190,7 +190,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 8);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants,
             vec![("F.LAST".to_string(), &convert(vec![0, 0, 0, 0, 0, 0, 0, 1]))]
@@ -207,7 +207,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 8);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants,
             vec![(
@@ -227,7 +227,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 8);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants,
             vec![(
@@ -252,7 +252,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 8);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants,
             vec![("F.X".to_string(), &convert(vec![8, 5, 5, 10, 5, 3, 5, 5]))]
@@ -269,7 +269,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 8);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants,
             vec![("F.X".to_string(), &convert(vec![7, 7, 7, 9, 9, 9, 9, 9]))]
@@ -287,7 +287,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 8);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants,
             vec![(
@@ -314,7 +314,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 10);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(constants.len(), 4);
         assert_eq!(
             constants[0],
@@ -360,7 +360,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 10);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(constants.len(), 3);
         assert_eq!(
             constants[0],
@@ -392,7 +392,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 10);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(constants.len(), 1);
         assert_eq!(
             constants[0],
@@ -428,7 +428,7 @@ mod test {
         let analyzed = analyze_string(src);
         assert_eq!(analyzed.degree(), 6);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants[0],
             ("F.or".to_string(), &convert([0, 1, 1, 1, 1, 1].to_vec()))
@@ -533,7 +533,7 @@ mod test {
         let analyzed = analyze_string::<GoldilocksField>(src);
         assert_eq!(analyzed.degree(), 4);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants[0],
             ("F.X".to_string(), &convert([21, 22, 23, 24].to_vec()))
@@ -557,7 +557,7 @@ mod test {
         let analyzed = analyze_string::<GoldilocksField>(src);
         assert_eq!(analyzed.degree(), 4);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants[0],
             ("F.x".to_string(), &convert([1, 2, 4, 8].to_vec()))
@@ -578,7 +578,7 @@ mod test {
         let analyzed = analyze_string::<GoldilocksField>(src);
         assert_eq!(analyzed.degree(), 4);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         // Semantics of p % q involving negative numbers:
         // sgn(p) * |p| % |q|
         assert_eq!(
@@ -599,7 +599,7 @@ mod test {
         let analyzed = analyze_string::<GoldilocksField>(src);
         assert_eq!(analyzed.degree(), 4);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants[0],
             ("F.y[0]".to_string(), &convert([0, 1, 2, 3].to_vec()))
@@ -624,7 +624,7 @@ mod test {
         let analyzed = analyze_string::<GoldilocksField>(src);
         assert_eq!(analyzed.degree(), 4);
         let constants = generate(&analyzed);
-        let constants = constants.get_only_size().unwrap();
+        let constants = get_only_size(&constants).unwrap();
         assert_eq!(
             constants[0],
             ("F.a".to_string(), &convert([14, 15, 16, 17].to_vec()))