Merge pull request #32 from AztecProtocol/md/integrate-logup

feat: bb logup

asm_to_pil/src/vm_to_constrained.rs

@@ -144,6 +144,7 @@ impl<T: FieldElement> ASMPILConverter<T> {
                                     ),
                                     PilStatement::PolynomialIdentity(
                                         0,
+                                        None,
                                         lhs - (Expression::from(T::one())
                                             - next_reference("first_step"))
                                             * direct_reference(pc_update_name),
@@ -154,10 +155,14 @@ impl<T: FieldElement> ASMPILConverter<T> {
                             ReadOnly => {
                                 let not_reset: Expression<T> =
                                     Expression::from(T::one()) - direct_reference("instr__reset");
-                                vec![PilStatement::PolynomialIdentity(0, not_reset * (lhs - rhs))]
+                                vec![PilStatement::PolynomialIdentity(
+                                    0,
+                                    None,
+                                    not_reset * (lhs - rhs),
+                                )]
                             }
                             _ => {
-                                vec![PilStatement::PolynomialIdentity(0, lhs - rhs)]
+                                vec![PilStatement::PolynomialIdentity(0, None, lhs - rhs)]
                             }
                         }
                     })
@@ -389,7 +394,7 @@ impl<T: FieldElement> ASMPILConverter<T> {
                 });
 
                 for mut statement in body {
-                    if let PilStatement::PolynomialIdentity(_start, expr) = statement {
+                    if let PilStatement::PolynomialIdentity(_start, _attr, expr) = statement {
                         match extract_update(expr) {
                             (Some(var), expr) => {
                                 let reference = direct_reference(&instruction_flag);
@@ -406,12 +411,13 @@ impl<T: FieldElement> ASMPILConverter<T> {
                             }
                             (None, expr) => self.pil.push(PilStatement::PolynomialIdentity(
                                 0,
+                                None,
                                 direct_reference(&instruction_flag) * expr.clone(),
                             )),
                         }
                     } else {
                         match &mut statement {
-                            PilStatement::PermutationIdentity(_, left, _)
+                            PilStatement::PermutationIdentity(_, _, left, _)
                             | PilStatement::PlookupIdentity(_, left, _) => {
                                 assert!(
                                     left.selector.is_none(),
@@ -715,6 +721,7 @@ impl<T: FieldElement> ASMPILConverter<T> {
             .sum();
         self.pil.push(PilStatement::PolynomialIdentity(
             0,
+            None,
             direct_reference(register) - assign_constraint,
         ));
     }

ast/src/analyzed/display.rs

@@ -149,7 +149,13 @@ impl<T: Display> Display for Identity<Expression<T>> {
                 }
             }
             IdentityKind::Plookup => write!(f, "{} in {};", self.left, self.right),
-            IdentityKind::Permutation => write!(f, "{} is {};", self.left, self.right),
+            IdentityKind::Permutation => write!(
+                f,
+                "#[{}] {} is {};",
+                self.attribute.clone().unwrap_or_default(),
+                self.left,
+                self.right
+            ),
             IdentityKind::Connect => write!(f, "{} connect {};", self.left, self.right),
         }
     }

ast/src/analyzed/mod.rs

@@ -226,6 +226,7 @@ impl<T> Analyzed<T> {
         self.identities.push(Identity {
             id,
             kind: IdentityKind::Polynomial,
+            attribute: None, // TODO(md): None for the meantime as we do not have tagged identities, will be updated in following pr
             source,
             left: SelectedExpressions {
                 selector: Some(identity),
@@ -504,6 +505,7 @@ pub struct Identity<Expr> {
     /// The ID is specific to the identity kind.
     pub id: u64,
     pub kind: IdentityKind,
+    pub attribute: Option<String>,
     pub source: SourceRef,
     /// For a simple polynomial identity, the selector contains
     /// the actual expression (see expression_for_poly_id).

ast/src/parsed/display.rs

@@ -383,15 +383,20 @@ impl<T: Display> Display for PilStatement<T> {
                     value.as_ref().map(|v| format!("{v}")).unwrap_or_default()
                 )
             }
-            PilStatement::PolynomialIdentity(_, expression) => {
+            PilStatement::PolynomialIdentity(_, _attr, expression) => {
                 if let Expression::BinaryOperation(left, BinaryOperator::Sub, right) = expression {
                     write!(f, "{left} = {right};")
                 } else {
                     write!(f, "{expression} = 0;")
                 }
             }
             PilStatement::PlookupIdentity(_, left, right) => write!(f, "{left} in {right};"),
-            PilStatement::PermutationIdentity(_, left, right) => write!(f, "{left} is {right};"),
+            PilStatement::PermutationIdentity(
+                _, //
+                _, //
+                left,
+                right,
+            ) => write!(f, "{left} is {right};"), //
             PilStatement::ConnectIdentity(_, left, right) => write!(
                 f,
                 "{{ {} }} connect {{ {} }};",

ast/src/parsed/mod.rs

@@ -34,14 +34,15 @@ pub enum PilStatement<T> {
     PolynomialConstantDeclaration(usize, Vec<PolynomialName<T>>),
     PolynomialConstantDefinition(usize, String, FunctionDefinition<T>),
     PolynomialCommitDeclaration(usize, Vec<PolynomialName<T>>, Option<FunctionDefinition<T>>),
-    PolynomialIdentity(usize, Expression<T>),
+    PolynomialIdentity(usize, Option<String>, Expression<T>),
     PlookupIdentity(
         usize,
         SelectedExpressions<Expression<T>>,
         SelectedExpressions<Expression<T>>,
     ),
     PermutationIdentity(
         usize,
+        Option<String>,
         SelectedExpressions<Expression<T>>,
         SelectedExpressions<Expression<T>>,
     ),
@@ -50,6 +51,11 @@ pub enum PilStatement<T> {
     Expression(usize, Expression<T>),
 }
 
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
+pub struct Attribute {
+    pub name: Option<String>,
+}
+
 #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)]
 pub struct SelectedExpressions<Expr> {
     pub selector: Option<Expr>,

ast/src/parsed/visitor.rs

@@ -193,7 +193,12 @@ impl<T> ExpressionVisitable<Expression<T, NamespacedPolynomialReference>> for Pi
         match self {
             PilStatement::Expression(_, e) => e.visit_expressions_mut(f, o),
             PilStatement::PlookupIdentity(_, left, right)
-            | PilStatement::PermutationIdentity(_, left, right) => [left, right]
+            | PilStatement::PermutationIdentity(
+                _, //
+                _, //
+                left,
+                right,
+            ) => [left, right] //
                 .into_iter()
                 .try_for_each(|e| e.visit_expressions_mut(f, o)),
             PilStatement::ConnectIdentity(_start, left, right) => left
@@ -203,7 +208,7 @@ impl<T> ExpressionVisitable<Expression<T, NamespacedPolynomialReference>> for Pi
 
             PilStatement::Namespace(_, _, e)
             | PilStatement::PolynomialDefinition(_, _, e)
-            | PilStatement::PolynomialIdentity(_, e)
+            | PilStatement::PolynomialIdentity(_, _, e)
             | PilStatement::PublicDeclaration(_, _, _, None, e)
             | PilStatement::ConstantDefinition(_, _, e)
             | PilStatement::LetStatement(_, _, Some(e)) => e.visit_expressions_mut(f, o),
@@ -230,7 +235,12 @@ impl<T> ExpressionVisitable<Expression<T, NamespacedPolynomialReference>> for Pi
         match self {
             PilStatement::Expression(_, e) => e.visit_expressions(f, o),
             PilStatement::PlookupIdentity(_, left, right)
-            | PilStatement::PermutationIdentity(_, left, right) => [left, right]
+            | PilStatement::PermutationIdentity(
+                _, //
+                _, //
+                left,
+                right,
+            ) => [left, right] //
                 .into_iter()
                 .try_for_each(|e| e.visit_expressions(f, o)),
             PilStatement::ConnectIdentity(_start, left, right) => left
@@ -240,7 +250,7 @@ impl<T> ExpressionVisitable<Expression<T, NamespacedPolynomialReference>> for Pi
 
             PilStatement::Namespace(_, _, e)
             | PilStatement::PolynomialDefinition(_, _, e)
-            | PilStatement::PolynomialIdentity(_, e)
+            | PilStatement::PolynomialIdentity(_, _, e)
             | PilStatement::PublicDeclaration(_, _, _, None, e)
             | PilStatement::ConstantDefinition(_, _, e)
             | PilStatement::LetStatement(_, _, Some(e)) => e.visit_expressions(f, o),