feat: setting column size factor manually (#274)

src/column.rs

@@ -793,6 +793,7 @@ impl<'a> Iterator for ValueBackingIter<'a> {
 pub struct Register {
     pub handle: Option<Handle>,
     pub magma: Magma,
+    pub length_multiplier: usize,
     #[serde(skip_serializing, skip_deserializing, default)]
     backing: Option<ValueBacking>,
     width: usize,
@@ -1163,10 +1164,16 @@ impl ColumnSet {
         self._cols.iter()
     }
 
-    pub(crate) fn new_register(&mut self, handle: Handle, magma: Magma) -> RegisterID {
+    pub(crate) fn new_register(
+        &mut self,
+        handle: Handle,
+        magma: Magma,
+        length_multiplier: usize,
+    ) -> RegisterID {
         self.registers.push(Register {
             handle: Some(handle),
             magma,
+            length_multiplier,
             backing: None,
             width: crate::constants::col_count_magma(magma),
         });
@@ -1219,15 +1226,19 @@ impl ColumnSet {
     }
 
     pub fn insert_column_and_register(&mut self, mut column: Column) -> Result<ColumnRef> {
-        column.register = Some(self.new_register(column.handle.clone(), column.t));
+        let length_multiplier = column.intrinsic_size_factor.unwrap_or(1);
+        column.register =
+            Some(self.new_register(column.handle.clone(), column.t, length_multiplier));
         self.insert_column(column)
     }
 
     pub fn maybe_insert_column_and_register(&mut self, mut column: Column) -> Option<ColumnRef> {
         if self.cols.contains_key(&column.handle) {
             None
         } else {
-            column.register = Some(self.new_register(column.handle.clone(), column.t));
+            let length_multiplier = column.intrinsic_size_factor.unwrap_or(1);
+            column.register =
+                Some(self.new_register(column.handle.clone(), column.t, length_multiplier));
             self.maybe_insert_column(column)
         }
     }

src/compiler/generator.rs

@@ -434,9 +434,11 @@ impl ConstraintSet {
 
         // module-global columns all have their own register
         for c in pool.root {
+            let col = self.columns.column(&c).unwrap();
             let reg = self.columns.new_register(
                 self.handle(&c).to_owned(),
-                self.columns.column(&c).unwrap().t,
+                col.t,
+                col.intrinsic_size_factor.unwrap_or(1),
             );
             self.columns.assign_register(&c, reg).unwrap();
         }
@@ -459,9 +461,9 @@ impl ConstraintSet {
                             .filter_map(|v| v.get(i))
                             .map(|r| self.handle(r).name.to_owned())
                             .join("_xor_");
-                        let reg = self
-                            .columns
-                            .new_register(Handle::new(module, names), *magma);
+                        let reg =
+                            self.columns
+                                .new_register(Handle::new(module, names), *magma, *size);
                         for cols in sets.values() {
                             if let Some(col_id) = cols.get(i) {
                                 self.columns.assign_register(col_id, reg).unwrap();
@@ -494,7 +496,11 @@ impl ConstraintSet {
                     | Computation::CyclicFrom { target, .. }
                     | Computation::Composite { target, .. } => {
                         let col = self.columns.column(&target).unwrap();
-                        let reg = self.columns.new_register(col.handle.clone(), col.t);
+                        let reg = self.columns.new_register(
+                            col.handle.clone(),
+                            col.t,
+                            col.intrinsic_size_factor.unwrap_or(1),
+                        );
                         self.columns.assign_register(&target, reg).unwrap();
                     }
                     Computation::Sorted { froms, tos, .. } => {
@@ -504,7 +510,11 @@ impl ConstraintSet {
                                 .entry(self.columns.column(f).unwrap().register.unwrap())
                                 .or_insert_with(|| {
                                     let col = self.columns.column(t).unwrap();
-                                    self.columns.new_register(col.handle.clone(), col.t)
+                                    self.columns.new_register(
+                                        col.handle.clone(),
+                                        col.t,
+                                        col.intrinsic_size_factor.unwrap_or(1),
+                                    )
                                 });
                             self.columns.assign_register(t, *reg).unwrap();
                         }
@@ -522,7 +532,11 @@ impl ConstraintSet {
                             .chain(delta_bytes.iter())
                         {
                             let col = self.columns.column(r).unwrap();
-                            let reg = self.columns.new_register(col.handle.clone(), col.t);
+                            let reg = self.columns.new_register(
+                                col.handle.clone(),
+                                col.t,
+                                col.intrinsic_size_factor.unwrap_or(1),
+                            );
                             self.columns.assign_register(r, reg).unwrap();
                         }
                     }

src/compiler/mod.rs

@@ -70,11 +70,13 @@ pub fn make<S1: AsRef<str>, S2: AsRef<str>>(
                         padding_value,
                         base,
                         must_prove,
+                        length_multiplier,
                         ..
                     } => {
                         let column = Column::builder()
                             .handle(handle.as_handle().clone())
                             .and_padding_value(padding_value.to_owned())
+                            .and_intrinsic_size_factor(length_multiplier.to_owned())
                             .kind(k.to_nil())
                             .t(symbol.t().m())
                             .must_prove(*must_prove)

src/compiler/node.rs

@@ -212,6 +212,7 @@ pub enum Expression {
         kind: Kind<Box<Node>>,
         must_prove: bool,
         padding_value: Option<i64>,
+        length_multiplier: Option<usize>,
         base: Base,
     },
     ArrayColumn {
@@ -304,6 +305,7 @@ impl Node {
         base: Option<Base>,
         kind: Option<Kind<Box<Node>>>,
         padding_value: Option<i64>,
+        length_multiplier: Option<usize>,
         must_prove: Option<bool>,
         t: Option<Magma>,
     ) -> Node {
@@ -327,6 +329,7 @@ impl Node {
                     kind: kind.unwrap_or(Kind::Computed),
                     must_prove: must_prove.unwrap_or(false),
                     padding_value,
+                    length_multiplier,
                     base: base.unwrap_or_else(|| t.unwrap_or(Magma::native()).into()),
                 },
                 _t: Some(Type::Column(t.unwrap_or(Magma::native()))),

src/compiler/parser/definitions.rs

@@ -47,6 +47,7 @@ fn reduce(e: &AstNode, ctx: &mut Scope, settings: &CompileSettings) -> Result<()
             t,
             kind,
             padding_value,
+            length_multiplier,
             must_prove,
             base,
         } => {
@@ -63,6 +64,7 @@ fn reduce(e: &AstNode, ctx: &mut Scope, settings: &CompileSettings) -> Result<()
                     Kind::Expression(_) => Kind::Computed,
                 })
                 .and_padding_value(*padding_value)
+                .and_length_multiplier(*length_multiplier)
                 .t(t.m())
                 .must_prove(*must_prove)
                 .base(*base)

src/compiler/parser/mod.rs

@@ -172,6 +172,8 @@ pub enum Token {
         kind: Kind<Box<AstNode>>,
         /// the value to pad the column with; defaults to 0 if None
         padding_value: Option<i64>,
+        /// the length multiplier for this column; defaults to 1 if None
+        length_multiplier: Option<usize>,
         /// if set, generate constraint to prove the column type
         must_prove: bool,
         /// which numeric base should be used to display column values; this is a purely aesthetic setting

src/compiler/parser/parser.rs

@@ -188,6 +188,7 @@ struct ColumnAttributes {
     must_prove: bool,
     range: OnceCell<Box<Domain<AstNode>>>,
     padding_value: OnceCell<i64>,
+    length_multiplier: OnceCell<usize>,
     base: OnceCell<Base>,
     computation: Option<AstNode>,
 }
@@ -220,6 +221,7 @@ fn parse_column_attributes(source: AstNode) -> Result<ColumnAttributes> {
         Array,
         Computation,
         PaddingValue,
+        LengthMultiplier,
         Base,
     }
     let re_type = regex_lite::Regex::new(
@@ -257,6 +259,8 @@ fn parse_column_attributes(source: AstNode) -> Result<ColumnAttributes> {
                         ":padding" => ColumnParser::PaddingValue,
                         // how to display the column values in debug
                         ":display" => ColumnParser::Base,
+                        // a specific length multiplier
+                        ":length" => ColumnParser::LengthMultiplier,
                         _ => {
                             if let Some(caps) = re_type.captures(kw) {
                                 let raw_magma = if let Some(integer) = caps.name("Integer") {
@@ -339,6 +343,19 @@ fn parse_column_attributes(source: AstNode) -> Result<ColumnAttributes> {
                 })?;
                 ColumnParser::Begin
             }
+            ColumnParser::LengthMultiplier => {
+                attributes
+                    .length_multiplier
+                    .set(x.as_u64()? as usize)
+                    .map_err(|_| {
+                        anyhow!(
+                            "invalid length multiplier for column {} ({})",
+                            attributes.name,
+                            x.as_i64().unwrap()
+                        )
+                    })?;
+                ColumnParser::Begin
+            }
             ColumnParser::Base => {
                 let base = if let Token::Keyword(ref kw) = x.class {
                     kw.as_str().try_into()?
@@ -363,6 +380,7 @@ fn parse_column_attributes(source: AstNode) -> Result<ColumnAttributes> {
         ColumnParser::Array => bail!("incomplete :array definition"),
         ColumnParser::Computation => bail!("incomplate :comp definition"),
         ColumnParser::PaddingValue => bail!("incomplete :padding definition"),
+        ColumnParser::LengthMultiplier => bail!("incomplete :length definition"),
         ColumnParser::Base => bail!("incomplete :display definition"),
     }
     Ok(attributes)
@@ -411,6 +429,7 @@ fn parse_defcolumns<I: Iterator<Item = Result<AstNode>>>(
                                 .map(|c| Kind::Expression(Box::new(c)))
                                 .unwrap_or(Kind::Commitment),
                             padding_value: column_attributes.padding_value.get().cloned(),
+                            length_multiplier: column_attributes.length_multiplier.get().cloned(),
                             must_prove: column_attributes.must_prove,
                             base,
                         }