From 7235b884846f840dae0e7f8d099552c416a71993 Mon Sep 17 00:00:00 2001 From: chriseth Date: Mon, 9 Oct 2023 16:39:30 +0200 Subject: [PATCH] Make Identity more flexible. --- ast/src/analyzed/display.rs | 8 ++--- ast/src/analyzed/mod.rs | 20 ++++++------- ast/src/analyzed/visitor.rs | 6 ++-- ast/src/parsed/display.rs | 14 --------- ast/src/parsed/mod.rs | 20 +++++++++---- ast/src/parsed/visitor.rs | 6 ++-- .../json_exporter/expression_counter.rs | 27 ++++++----------- executor/src/witgen/generator.rs | 9 +++--- executor/src/witgen/global_constraints.rs | 6 ++-- executor/src/witgen/identity_processor.rs | 18 ++++++++---- executor/src/witgen/machines/block_machine.rs | 19 ++++++------ .../machines/double_sorted_witness_machine.rs | 11 ++++--- .../witgen/machines/fixed_lookup_machine.rs | 7 +++-- .../src/witgen/machines/machine_extractor.rs | 15 ++++++---- executor/src/witgen/machines/mod.rs | 9 +++--- .../witgen/machines/sorted_witness_machine.rs | 16 +++++----- executor/src/witgen/processor.rs | 13 +++++---- executor/src/witgen/vm_processor.rs | 14 ++++----- halo2/src/circuit_builder.rs | 6 ++-- parser/src/powdr.lalrpop | 2 +- pil_analyzer/src/pil_analyzer.rs | 29 +++++++++---------- 21 files changed, 136 insertions(+), 139 deletions(-) diff --git a/ast/src/analyzed/display.rs b/ast/src/analyzed/display.rs index e7ac24fc9..6b020f49a 100644 --- a/ast/src/analyzed/display.rs +++ b/ast/src/analyzed/display.rs @@ -7,8 +7,6 @@ use std::fmt::{Display, Formatter, Result}; use itertools::Itertools; -use crate::parsed::display::format_expressions; - use super::*; impl Display for Analyzed { @@ -102,7 +100,7 @@ impl Display for RepeatedArray { } } -impl Display for Identity { +impl Display for Identity> { fn fmt(&self, f: &mut Formatter<'_>) -> Result { match self.kind { IdentityKind::Polynomial => { @@ -120,7 +118,7 @@ impl Display for Identity { } } -impl Display for SelectedExpressions { +impl Display for SelectedExpressions { fn fmt(&self, f: &mut Formatter<'_>) -> Result { write!( f, @@ -129,7 +127,7 @@ impl Display for SelectedExpressions { .as_ref() .map(|s| format!("{s} ")) .unwrap_or_default(), - format_expressions(&self.expressions) + self.expressions.iter().format(", ") ) } } diff --git a/ast/src/analyzed/mod.rs b/ast/src/analyzed/mod.rs index 20376db86..9c37d3c76 100644 --- a/ast/src/analyzed/mod.rs +++ b/ast/src/analyzed/mod.rs @@ -9,11 +9,11 @@ use std::ops::ControlFlow; use number::DegreeType; -use crate::parsed; use crate::parsed::utils::expr_any; use crate::parsed::visitor::ExpressionVisitable; pub use crate::parsed::BinaryOperator; pub use crate::parsed::UnaryOperator; +use crate::parsed::{self, SelectedExpressions}; #[derive(Debug)] pub enum StatementIdentifier { @@ -29,7 +29,7 @@ pub struct Analyzed { pub constants: HashMap, pub definitions: HashMap>)>, pub public_declarations: HashMap, - pub identities: Vec>, + pub identities: Vec>>, /// The order in which definitions and identities /// appear in the source. pub source_order: Vec, @@ -308,24 +308,26 @@ pub struct PublicDeclaration { } #[derive(Debug, PartialEq, Eq, Clone)] -pub struct Identity { +pub struct Identity { /// The ID is specific to the identity kind. pub id: u64, pub kind: IdentityKind, pub source: SourceRef, /// For a simple polynomial identity, the selector contains /// the actual expression (see expression_for_poly_id). - pub left: SelectedExpressions, - pub right: SelectedExpressions, + pub left: SelectedExpressions, + pub right: SelectedExpressions, } -impl Identity { +impl Identity { /// Returns the expression in case this is a polynomial identity. - pub fn expression_for_poly_id(&self) -> &Expression { + pub fn expression_for_poly_id(&self) -> &Expr { assert_eq!(self.kind, IdentityKind::Polynomial); self.left.selector.as_ref().unwrap() } +} +impl Identity> { pub fn contains_next_ref(&self) -> bool { self.left.contains_next_ref() || self.right.contains_next_ref() } @@ -339,9 +341,7 @@ pub enum IdentityKind { Connect, } -pub type SelectedExpressions = parsed::SelectedExpressions; - -impl SelectedExpressions { +impl SelectedExpressions> { /// @returns true if the expression contains a reference to a next value of a /// (witness or fixed) column pub fn contains_next_ref(&self) -> bool { diff --git a/ast/src/analyzed/visitor.rs b/ast/src/analyzed/visitor.rs index 9d7d2094c..11ea2d3d3 100644 --- a/ast/src/analyzed/visitor.rs +++ b/ast/src/analyzed/visitor.rs @@ -50,10 +50,10 @@ impl ExpressionVisitable> for Analyzed { } } -impl ExpressionVisitable> for Identity { +impl> ExpressionVisitable for Identity { fn visit_expressions_mut(&mut self, f: &mut F, o: VisitOrder) -> ControlFlow where - F: FnMut(&mut parsed::Expression) -> ControlFlow, + F: FnMut(&mut Expr) -> ControlFlow, { self.left .selector @@ -67,7 +67,7 @@ impl ExpressionVisitable> for Identity { fn visit_expressions(&self, f: &mut F, o: VisitOrder) -> ControlFlow where - F: FnMut(&parsed::Expression) -> ControlFlow, + F: FnMut(&Expr) -> ControlFlow, { self.left .selector diff --git a/ast/src/parsed/display.rs b/ast/src/parsed/display.rs index ca229465c..24c16eb5f 100644 --- a/ast/src/parsed/display.rs +++ b/ast/src/parsed/display.rs @@ -416,20 +416,6 @@ impl Display for FunctionDefinition { } } -impl Display for SelectedExpressions { - fn fmt(&self, f: &mut Formatter<'_>) -> Result { - write!( - f, - "{}{{ {} }}", - self.selector - .as_ref() - .map(|s| format!("{s} ")) - .unwrap_or_default(), - format_expressions(&self.expressions) - ) - } -} - pub fn format_expressions(expressions: &[Expression]) -> String { format!("{}", expressions.iter().format(", ")) } diff --git a/ast/src/parsed/mod.rs b/ast/src/parsed/mod.rs index 3098f9995..d96cf9ab2 100644 --- a/ast/src/parsed/mod.rs +++ b/ast/src/parsed/mod.rs @@ -28,8 +28,16 @@ pub enum PilStatement { PolynomialConstantDefinition(usize, String, FunctionDefinition), PolynomialCommitDeclaration(usize, Vec>, Option>), PolynomialIdentity(usize, Expression), - PlookupIdentity(usize, SelectedExpressions, SelectedExpressions), - PermutationIdentity(usize, SelectedExpressions, SelectedExpressions), + PlookupIdentity( + usize, + SelectedExpressions>, + SelectedExpressions>, + ), + PermutationIdentity( + usize, + SelectedExpressions>, + SelectedExpressions>, + ), ConnectIdentity(usize, Vec>, Vec>), ConstantDefinition(usize, String, Expression), MacroDefinition( @@ -43,12 +51,12 @@ pub enum PilStatement { } #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Clone)] -pub struct SelectedExpressions> { - pub selector: Option>, - pub expressions: Vec>, +pub struct SelectedExpressions { + pub selector: Option, + pub expressions: Vec, } -impl Default for SelectedExpressions { +impl Default for SelectedExpressions { fn default() -> Self { Self { selector: Default::default(), diff --git a/ast/src/parsed/visitor.rs b/ast/src/parsed/visitor.rs index 626e4187e..9059daa45 100644 --- a/ast/src/parsed/visitor.rs +++ b/ast/src/parsed/visitor.rs @@ -256,10 +256,10 @@ impl ExpressionVisitable>> for Pi } } -impl ExpressionVisitable> for SelectedExpressions { +impl> ExpressionVisitable for SelectedExpressions { fn visit_expressions_mut(&mut self, f: &mut F, o: VisitOrder) -> ControlFlow where - F: FnMut(&mut Expression) -> ControlFlow, + F: FnMut(&mut Expr) -> ControlFlow, { self.selector .as_mut() @@ -270,7 +270,7 @@ impl ExpressionVisitable> for SelectedExpressions(&self, f: &mut F, o: VisitOrder) -> ControlFlow where - F: FnMut(&Expression) -> ControlFlow, + F: FnMut(&Expr) -> ControlFlow, { self.selector .as_ref() diff --git a/backend/src/pilstark/json_exporter/expression_counter.rs b/backend/src/pilstark/json_exporter/expression_counter.rs index 3b4c4d772..af161c53d 100644 --- a/backend/src/pilstark/json_exporter/expression_counter.rs +++ b/backend/src/pilstark/json_exporter/expression_counter.rs @@ -1,8 +1,11 @@ use std::collections::HashMap; -use ast::analyzed::{ - Analyzed, Expression, Identity, PolynomialType, PublicDeclaration, SelectedExpressions, - StatementIdentifier, Symbol, SymbolKind, +use ast::{ + analyzed::{ + Analyzed, Identity, PolynomialType, PublicDeclaration, StatementIdentifier, Symbol, + SymbolKind, + }, + parsed::SelectedExpressions, }; /// Computes expression IDs for each intermediate polynomial. @@ -32,7 +35,7 @@ trait ExpressionCounter { fn expression_count(&self) -> usize; } -impl ExpressionCounter for Identity { +impl ExpressionCounter for Identity { fn expression_count(&self) -> usize { self.left.expression_count() + self.right.expression_count() } @@ -50,20 +53,8 @@ impl ExpressionCounter for PublicDeclaration { } } -impl ExpressionCounter for SelectedExpressions { +impl ExpressionCounter for SelectedExpressions { fn expression_count(&self) -> usize { - self.selector.expression_count() + self.expressions.expression_count() - } -} - -impl ExpressionCounter for Vec> { - fn expression_count(&self) -> usize { - self.len() - } -} - -impl ExpressionCounter for Option> { - fn expression_count(&self) -> usize { - (self.is_some()).into() + self.selector.is_some() as usize + self.expressions.len() } } diff --git a/executor/src/witgen/generator.rs b/executor/src/witgen/generator.rs index 5121b88b7..c511e4420 100644 --- a/executor/src/witgen/generator.rs +++ b/executor/src/witgen/generator.rs @@ -1,4 +1,5 @@ -use ast::analyzed::{Identity, IdentityKind, PolyID, PolynomialReference, SelectedExpressions}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, PolynomialReference}; +use ast::parsed::SelectedExpressions; use number::FieldElement; use std::collections::{HashMap, HashSet}; @@ -15,7 +16,7 @@ use super::{EvalResult, FixedData, MutableState}; pub struct Generator<'a, T: FieldElement> { fixed_data: &'a FixedData<'a, T>, - identities: Vec<&'a Identity>, + identities: Vec<&'a Identity>>, witnesses: HashSet, global_range_constraints: WitnessColumnMap>>, data: Vec>, @@ -28,7 +29,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for Generator<'a, T> { _fixed_lookup: &mut FixedLookup, _kind: IdentityKind, _left: &[AffineExpression<&'a PolynomialReference, T>], - _right: &'a SelectedExpressions, + _right: &'a SelectedExpressions>, _machines: Machines<'a, '_, T>, ) -> Option> { unimplemented!() @@ -50,7 +51,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for Generator<'a, T> { impl<'a, T: FieldElement> Generator<'a, T> { pub fn new( fixed_data: &'a FixedData<'a, T>, - identities: &[&'a Identity], + identities: &[&'a Identity>], witnesses: HashSet, global_range_constraints: &WitnessColumnMap>>, ) -> Self { diff --git a/executor/src/witgen/global_constraints.rs b/executor/src/witgen/global_constraints.rs index 146e48e66..c20ea99da 100644 --- a/executor/src/witgen/global_constraints.rs +++ b/executor/src/witgen/global_constraints.rs @@ -35,7 +35,7 @@ impl<'a, T: FieldElement> RangeConstraintSet<&PolynomialReference, T> pub struct GlobalConstraints<'a, T: FieldElement> { pub known_witness_constraints: WitnessColumnMap>>, - pub retained_identities: Vec<&'a Identity>, + pub retained_identities: Vec<&'a Identity>>, } /// Determines global constraints on witness and fixed columns. @@ -44,7 +44,7 @@ pub struct GlobalConstraints<'a, T: FieldElement> { /// TODO at some point, we should check that they still hold. pub fn determine_global_constraints<'a, T: FieldElement>( fixed_data: &'a FixedData, - identities: Vec<&'a Identity>, + identities: Vec<&'a Identity>>, ) -> GlobalConstraints<'a, T> { let mut known_constraints = BTreeMap::new(); // For these columns, we know that they are not only constrained to those bits @@ -134,7 +134,7 @@ fn process_fixed_column(fixed: &[T]) -> Option<(RangeConstraint /// no further information than the range constraint. fn propagate_constraints( mut known_constraints: BTreeMap>, - identity: &Identity, + identity: &Identity>, full_span: &BTreeSet, ) -> (BTreeMap>, bool) { let mut remove = false; diff --git a/executor/src/witgen/identity_processor.rs b/executor/src/witgen/identity_processor.rs index e308230fd..76579baf4 100644 --- a/executor/src/witgen/identity_processor.rs +++ b/executor/src/witgen/identity_processor.rs @@ -1,6 +1,9 @@ use std::{collections::HashMap, sync::Mutex}; -use ast::analyzed::{Expression, Identity, IdentityKind, PolynomialReference, SelectedExpressions}; +use ast::{ + analyzed::{Expression, Identity, IdentityKind, PolynomialReference}, + parsed::SelectedExpressions, +}; use itertools::{Either, Itertools}; use lazy_static::lazy_static; use number::FieldElement; @@ -86,7 +89,7 @@ impl<'a, 'b, T: FieldElement> IdentityProcessor<'a, 'b, T> { /// Returns the updates. pub fn process_identity( &mut self, - identity: &'a Identity, + identity: &'a Identity>, rows: &RowPair<'_, 'a, T>, ) -> EvalResult<'a, T> { let result = match identity.kind { @@ -106,7 +109,7 @@ impl<'a, 'b, T: FieldElement> IdentityProcessor<'a, 'b, T> { fn process_polynomial_identity( &self, - identity: &'a Identity, + identity: &'a Identity>, rows: &RowPair, ) -> EvalResult<'a, T> { match rows.evaluate(identity.expression_for_poly_id()) { @@ -117,7 +120,7 @@ impl<'a, 'b, T: FieldElement> IdentityProcessor<'a, 'b, T> { fn process_plookup( &mut self, - identity: &'a Identity, + identity: &'a Identity>, rows: &RowPair<'_, 'a, T>, ) -> EvalResult<'a, T> { if let Some(left_selector) = &identity.left.selector { @@ -187,7 +190,7 @@ impl<'a, 'b, T: FieldElement> IdentityProcessor<'a, 'b, T> { pub fn process_link( &mut self, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, current_rows: &RowPair<'_, 'a, T>, ) -> EvalResult<'a, T> { // sanity check that the right hand side selector is active @@ -246,7 +249,10 @@ lazy_static! { Mutex::new(Default::default()); } -fn report_identity_solving(identity: &Identity, result: &EvalResult) { +fn report_identity_solving( + identity: &Identity>, + result: &EvalResult, +) { let success = result.as_ref().map(|r| r.is_complete()).unwrap_or_default() as u64; let mut stat = STATISTICS.lock().unwrap(); stat.entry((identity.id, identity.kind)) diff --git a/executor/src/witgen/machines/block_machine.rs b/executor/src/witgen/machines/block_machine.rs index 1425b8e30..b58e5924b 100644 --- a/executor/src/witgen/machines/block_machine.rs +++ b/executor/src/witgen/machines/block_machine.rs @@ -12,9 +12,8 @@ use crate::witgen::Constraints; use crate::witgen::{ machines::Machine, range_constraints::RangeConstraint, EvalError, EvalValue, IncompleteCause, }; -use ast::analyzed::{ - Expression, Identity, IdentityKind, PolyID, PolynomialReference, SelectedExpressions, -}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, PolynomialReference}; +use ast::parsed::SelectedExpressions; use number::{DegreeType, FieldElement}; enum ProcessResult<'a, T: FieldElement> { @@ -39,9 +38,9 @@ pub struct BlockMachine<'a, T: FieldElement> { block_size: usize, /// The right-hand side of the connecting identity, needed to identify /// when this machine is responsible. - selected_expressions: SelectedExpressions, + selected_expressions: SelectedExpressions>, /// The internal identities - identities: Vec<&'a Identity>, + identities: Vec<&'a Identity>>, /// The row factory row_factory: RowFactory<'a, T>, /// The data of the machine. @@ -57,8 +56,8 @@ pub struct BlockMachine<'a, T: FieldElement> { impl<'a, T: FieldElement> BlockMachine<'a, T> { pub fn try_new( fixed_data: &'a FixedData<'a, T>, - connecting_identities: &[&'a Identity], - identities: &[&'a Identity], + connecting_identities: &[&'a Identity>], + identities: &[&'a Identity>], witness_cols: &HashSet, global_range_constraints: &WitnessColumnMap>>, ) -> Option { @@ -140,7 +139,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for BlockMachine<'a, T> { fixed_lookup: &'b mut FixedLookup, kind: IdentityKind, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, machines: Machines<'a, 'b, T>, ) -> Option> { if *right != self.selected_expressions || kind != IdentityKind::Plookup { @@ -252,7 +251,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { &mut self, fixed_lookup: &'b mut FixedLookup, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, machines: Machines<'a, 'b, T>, ) -> EvalResult<'a, T> { log::trace!("Start processing block machine '{}'", self.name()); @@ -351,7 +350,7 @@ impl<'a, T: FieldElement> BlockMachine<'a, T> { &self, identity_processor: &mut IdentityProcessor<'a, 'b, T>, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, sequence_iterator: &mut ProcessingSequenceIterator, ) -> Result, EvalError> { // Make the block two rows larger than the block size, it includes the last row of the previous block diff --git a/executor/src/witgen/machines/double_sorted_witness_machine.rs b/executor/src/witgen/machines/double_sorted_witness_machine.rs index f414e4e19..bf2313f91 100644 --- a/executor/src/witgen/machines/double_sorted_witness_machine.rs +++ b/executor/src/witgen/machines/double_sorted_witness_machine.rs @@ -1,6 +1,7 @@ use std::collections::{BTreeMap, HashMap, HashSet}; use std::iter::once; +use ast::parsed::SelectedExpressions; use itertools::Itertools; use num_traits::Zero; @@ -12,9 +13,7 @@ use crate::witgen::{EvalResult, FixedData}; use crate::witgen::{EvalValue, IncompleteCause}; use number::{DegreeType, FieldElement}; -use ast::analyzed::{ - Expression, Identity, IdentityKind, PolyID, PolynomialReference, Reference, SelectedExpressions, -}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, PolynomialReference, Reference}; /// TODO make this generic @@ -43,7 +42,7 @@ impl DoubleSortedWitnesses { pub fn try_new( fixed_data: &FixedData, - _identities: &[&Identity], + _identities: &[&Identity>], witness_cols: &HashSet, ) -> Option { // get the namespaces and column names @@ -100,7 +99,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for DoubleSortedWitnesses { _fixed_lookup: &mut FixedLookup, kind: IdentityKind, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, _machines: Machines<'a, '_, T>, ) -> Option> { if kind != IdentityKind::Permutation @@ -174,7 +173,7 @@ impl DoubleSortedWitnesses { fn process_plookup_internal<'a>( &mut self, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &SelectedExpressions, + right: &SelectedExpressions>, ) -> EvalResult<'a, T> { // We blindly assume the lookup is of the form // OP { ADDR, STEP, X } is m_is_write { m_addr, m_step, m_value } diff --git a/executor/src/witgen/machines/fixed_lookup_machine.rs b/executor/src/witgen/machines/fixed_lookup_machine.rs index 7e5e8c95b..fc06f9fad 100644 --- a/executor/src/witgen/machines/fixed_lookup_machine.rs +++ b/executor/src/witgen/machines/fixed_lookup_machine.rs @@ -2,7 +2,8 @@ use std::collections::{BTreeMap, HashMap, HashSet}; use std::mem; use std::num::NonZeroUsize; -use ast::analyzed::{Identity, IdentityKind, PolyID, PolynomialReference, SelectedExpressions}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, PolynomialReference}; +use ast::parsed::SelectedExpressions; use itertools::Itertools; use number::FieldElement; @@ -162,7 +163,7 @@ pub struct FixedLookup { impl FixedLookup { pub fn try_new( _fixed_data: &FixedData, - identities: &[&Identity], + identities: &[&Identity>], witness_names: &HashSet<&str>, ) -> Option { if identities.is_empty() && witness_names.is_empty() { @@ -177,7 +178,7 @@ impl FixedLookup { fixed_data: &FixedData, kind: IdentityKind, left: &[AffineExpression<&'b PolynomialReference, T>], - right: &'b SelectedExpressions, + right: &'b SelectedExpressions>, ) -> Option> { // This is a matching machine if it is a plookup and the RHS is fully constant. if kind != IdentityKind::Plookup diff --git a/executor/src/witgen/machines/machine_extractor.rs b/executor/src/witgen/machines/machine_extractor.rs index 7363524e2..bf7236f05 100644 --- a/executor/src/witgen/machines/machine_extractor.rs +++ b/executor/src/witgen/machines/machine_extractor.rs @@ -9,15 +9,16 @@ use super::KnownMachine; use crate::witgen::{ column_map::WitnessColumnMap, generator::Generator, range_constraints::RangeConstraint, }; -use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, Reference, SelectedExpressions}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, Reference}; use ast::parsed::visitor::ExpressionVisitable; +use ast::parsed::SelectedExpressions; use itertools::Itertools; use number::FieldElement; pub struct ExtractionOutput<'a, T: FieldElement> { pub fixed_lookup: FixedLookup, pub machines: Vec>, - pub base_identities: Vec<&'a Identity>, + pub base_identities: Vec<&'a Identity>>, pub base_witnesses: HashSet, } @@ -26,7 +27,7 @@ pub struct ExtractionOutput<'a, T: FieldElement> { /// that are not "internal" to the machines. pub fn split_out_machines<'a, T: FieldElement>( fixed: &'a FixedData<'a, T>, - identities: Vec<&'a Identity>, + identities: Vec<&'a Identity>>, global_range_constraints: &WitnessColumnMap>>, ) -> ExtractionOutput<'a, T> { let fixed_lookup = FixedLookup::try_new(fixed, &[], &Default::default()).unwrap(); @@ -140,7 +141,7 @@ pub fn split_out_machines<'a, T: FieldElement>( fn all_row_connected_witnesses( mut witnesses: HashSet, all_witnesses: &HashSet, - identities: &[&Identity], + identities: &[&Identity>], ) -> HashSet { loop { let count = witnesses.len(); @@ -173,7 +174,7 @@ fn all_row_connected_witnesses( } /// Extracts all references to names from an identity. -pub fn refs_in_identity(identity: &Identity) -> HashSet { +pub fn refs_in_identity(identity: &Identity>) -> HashSet { let mut refs: HashSet = Default::default(); identity.pre_visit_expressions(&mut |expr| { ref_of_expression(expr).map(|id| refs.insert(id)); @@ -182,7 +183,9 @@ pub fn refs_in_identity(identity: &Identity) -> HashSet { } /// Extracts all references to names from selected expressions. -pub fn refs_in_selected_expressions(selexpr: &SelectedExpressions) -> HashSet { +pub fn refs_in_selected_expressions( + selexpr: &SelectedExpressions>, +) -> HashSet { let mut refs: HashSet = Default::default(); selexpr.pre_visit_expressions(&mut |expr| { ref_of_expression(expr).map(|id| refs.insert(id)); diff --git a/executor/src/witgen/machines/mod.rs b/executor/src/witgen/machines/mod.rs index 761404f11..4bb0f555e 100644 --- a/executor/src/witgen/machines/mod.rs +++ b/executor/src/witgen/machines/mod.rs @@ -1,14 +1,15 @@ use std::collections::HashMap; -use ast::analyzed::IdentityKind; +use ast::analyzed::Expression; use ast::analyzed::PolynomialReference; -use ast::analyzed::SelectedExpressions; +use ast::parsed::SelectedExpressions; use number::FieldElement; use self::block_machine::BlockMachine; use self::double_sorted_witness_machine::DoubleSortedWitnesses; pub use self::fixed_lookup_machine::FixedLookup; use self::sorted_witness_machine::SortedWitnesses; +use ast::analyzed::IdentityKind; use super::affine_expression::AffineExpression; use super::generator::Generator; @@ -36,7 +37,7 @@ pub trait Machine<'a, T: FieldElement>: Send + Sync { fixed_lookup: &'b mut FixedLookup, kind: IdentityKind, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, machines: Machines<'a, 'b, T>, ) -> Option>; @@ -72,7 +73,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for KnownMachine<'a, T> { fixed_lookup: &'b mut FixedLookup, kind: IdentityKind, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, machines: Machines<'a, 'b, T>, ) -> Option> { self.get() diff --git a/executor/src/witgen/machines/sorted_witness_machine.rs b/executor/src/witgen/machines/sorted_witness_machine.rs index 0e3fc3857..92e7de27f 100644 --- a/executor/src/witgen/machines/sorted_witness_machine.rs +++ b/executor/src/witgen/machines/sorted_witness_machine.rs @@ -1,5 +1,6 @@ use std::collections::{BTreeMap, HashMap, HashSet}; +use ast::parsed::SelectedExpressions; use itertools::Itertools; use super::super::affine_expression::AffineExpression; @@ -12,9 +13,7 @@ use crate::witgen::{ symbolic_evaluator::SymbolicEvaluator, }; use crate::witgen::{EvalValue, IncompleteCause}; -use ast::analyzed::{ - Expression, Identity, IdentityKind, PolyID, PolynomialReference, Reference, SelectedExpressions, -}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, PolynomialReference, Reference}; use number::FieldElement; /// A machine that can support a lookup in a set of columns that are sorted @@ -34,7 +33,7 @@ pub struct SortedWitnesses { impl SortedWitnesses { pub fn try_new( fixed_data: &FixedData, - identities: &[&Identity], + identities: &[&Identity>], witnesses: &HashSet, ) -> Option { if identities.len() != 1 { @@ -58,7 +57,10 @@ impl SortedWitnesses { } } -fn check_identity(fixed_data: &FixedData, id: &Identity) -> Option { +fn check_identity( + fixed_data: &FixedData, + id: &Identity>, +) -> Option { // Looking for NOTLAST { A' - A } in { POSITIVE } if id.kind != IdentityKind::Plookup || id.right.selector.is_some() @@ -125,7 +127,7 @@ impl<'a, T: FieldElement> Machine<'a, T> for SortedWitnesses { _fixed_lookup: &mut FixedLookup, kind: IdentityKind, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, _machines: Machines<'a, '_, T>, ) -> Option> { if kind != IdentityKind::Plookup || right.selector.is_some() { @@ -182,7 +184,7 @@ impl SortedWitnesses { &mut self, fixed_data: &FixedData, left: &[AffineExpression<&'a PolynomialReference, T>], - right: &SelectedExpressions, + right: &SelectedExpressions>, rhs: Vec<&PolynomialReference>, ) -> EvalResult<'a, T> { let key_index = rhs diff --git a/executor/src/witgen/processor.rs b/executor/src/witgen/processor.rs index 5d8a88fda..6e067314d 100644 --- a/executor/src/witgen/processor.rs +++ b/executor/src/witgen/processor.rs @@ -1,6 +1,9 @@ use std::{collections::HashSet, marker::PhantomData}; -use ast::analyzed::{Identity, PolyID, PolynomialReference, SelectedExpressions}; +use ast::{ + analyzed::{Expression, Identity, PolyID, PolynomialReference}, + parsed::SelectedExpressions, +}; use number::FieldElement; use crate::witgen::Constraint; @@ -25,11 +28,11 @@ pub struct OuterQuery<'a, T: FieldElement> { /// This will be mutated while processing the block. left: Left<'a, T>, /// The right-hand side of the outer query. - right: &'a SelectedExpressions, + right: &'a SelectedExpressions>, } impl<'a, T: FieldElement> OuterQuery<'a, T> { - pub fn new(left: Left<'a, T>, right: &'a SelectedExpressions) -> Self { + pub fn new(left: Left<'a, T>, right: &'a SelectedExpressions>) -> Self { Self { left, right } } } @@ -46,7 +49,7 @@ pub struct Processor<'a, 'b, 'c, T: FieldElement, CalldataAvailable> { /// The rows that are being processed. data: Vec>, /// The list of identities - identities: &'c [&'a Identity], + identities: &'c [&'a Identity>], /// The identity processor identity_processor: &'c mut IdentityProcessor<'a, 'b, T>, /// The fixed data (containing information about all columns) @@ -65,7 +68,7 @@ impl<'a, 'b, 'c, T: FieldElement> Processor<'a, 'b, 'c, T, WithoutCalldata> { row_offset: u64, data: Vec>, identity_processor: &'c mut IdentityProcessor<'a, 'b, T>, - identities: &'c [&'a Identity], + identities: &'c [&'a Identity>], fixed_data: &'a FixedData<'a, T>, row_factory: RowFactory<'a, T>, witness_cols: &'c HashSet, diff --git a/executor/src/witgen/vm_processor.rs b/executor/src/witgen/vm_processor.rs index 39d493f8a..25542d9eb 100644 --- a/executor/src/witgen/vm_processor.rs +++ b/executor/src/witgen/vm_processor.rs @@ -1,4 +1,4 @@ -use ast::analyzed::{Identity, IdentityKind, PolyID, PolynomialReference}; +use ast::analyzed::{Expression, Identity, IdentityKind, PolyID, PolynomialReference}; use itertools::Itertools; use number::{DegreeType, FieldElement}; use parser_util::lines::indent; @@ -23,18 +23,18 @@ enum ProcessingPhase { /// A list of identities with a flag whether it is complete. struct CompletableIdentities<'a, T: FieldElement> { - identities_with_complete: Vec<(&'a Identity, bool)>, + identities_with_complete: Vec<(&'a Identity>, bool)>, } impl<'a, T: FieldElement> CompletableIdentities<'a, T> { - fn new(identities: impl Iterator>) -> Self { + fn new(identities: impl Iterator>>) -> Self { Self { identities_with_complete: identities.map(|identity| (identity, false)).collect(), } } /// Yields immutable references to the identity and mutable references to the complete flag. - fn iter_mut(&mut self) -> impl Iterator, &mut bool)> { + fn iter_mut(&mut self) -> impl Iterator>, &mut bool)> { self.identities_with_complete .iter_mut() .map(|(identity, complete)| (*identity, complete)) @@ -47,10 +47,10 @@ pub struct VmProcessor<'a, T: FieldElement> { fixed_data: &'a FixedData<'a, T>, /// The subset of identities that contains a reference to the next row /// (precomputed once for performance reasons) - identities_with_next_ref: Vec<&'a Identity>, + identities_with_next_ref: Vec<&'a Identity>>, /// The subset of identities that does not contain a reference to the next row /// (precomputed once for performance reasons) - identities_without_next_ref: Vec<&'a Identity>, + identities_without_next_ref: Vec<&'a Identity>>, data: Vec>, last_report: DegreeType, last_report_time: Instant, @@ -59,7 +59,7 @@ pub struct VmProcessor<'a, T: FieldElement> { impl<'a, T: FieldElement> VmProcessor<'a, T> { pub fn new( fixed_data: &'a FixedData<'a, T>, - identities: &[&'a Identity], + identities: &[&'a Identity>], witnesses: HashSet, data: Vec>, ) -> Self { diff --git a/halo2/src/circuit_builder.rs b/halo2/src/circuit_builder.rs index b1c12c4ef..fcfc5e6ab 100644 --- a/halo2/src/circuit_builder.rs +++ b/halo2/src/circuit_builder.rs @@ -1,4 +1,4 @@ -use ast::parsed::BinaryOperator; +use ast::parsed::{BinaryOperator, SelectedExpressions}; use num_bigint::BigUint; use polyexen::expr::{ColumnKind, ColumnQuery, Expr, PlonkVar}; use polyexen::plaf::backends::halo2::PlafH2Circuit; @@ -6,7 +6,7 @@ use polyexen::plaf::{ ColumnFixed, ColumnWitness, Columns, Info, Lookup, Plaf, Poly, Shuffle, Witness, }; -use ast::analyzed::{Analyzed, Expression, IdentityKind, Reference, SelectedExpressions}; +use ast::analyzed::{Analyzed, Expression, IdentityKind, Reference}; use num_traits::One; use number::{BigInt, FieldElement}; @@ -89,7 +89,7 @@ pub(crate) fn analyzed_to_circuit( // build Plaf polys. ------------------------------------------------------------------------- - let apply_selectors_to_set = |set: &SelectedExpressions| { + let apply_selectors_to_set = |set: &SelectedExpressions>| { let selector = set .selector .clone() diff --git a/parser/src/powdr.lalrpop b/parser/src/powdr.lalrpop index 632b13ec7..723b90bd3 100644 --- a/parser/src/powdr.lalrpop +++ b/parser/src/powdr.lalrpop @@ -140,7 +140,7 @@ PlookupIdentity: PilStatement = { <@L> "in" => PilStatement::PlookupIdentity(<>) } -SelectedExpressions: SelectedExpressions = { +SelectedExpressions: SelectedExpressions> = { "{" "}" => SelectedExpressions{<>}, Expression => SelectedExpressions{selector: None, expressions: vec![<>]}, } diff --git a/pil_analyzer/src/pil_analyzer.rs b/pil_analyzer/src/pil_analyzer.rs index 6763ea2ef..0eb2d548b 100644 --- a/pil_analyzer/src/pil_analyzer.rs +++ b/pil_analyzer/src/pil_analyzer.rs @@ -7,14 +7,14 @@ use analysis::MacroExpander; use ast::parsed::visitor::ExpressionVisitable; use ast::parsed::{ self, ArrayExpression, ArrayLiteral, FunctionDefinition, LambdaExpression, MatchArm, - MatchPattern, PilStatement, PolynomialName, + MatchPattern, PilStatement, PolynomialName, SelectedExpressions, }; use number::{DegreeType, FieldElement}; use ast::analyzed::{ Analyzed, Expression, FunctionValueDefinition, Identity, IdentityKind, PolynomialReference, - PolynomialType, PublicDeclaration, Reference, RepeatedArray, SelectedExpressions, SourceRef, - StatementIdentifier, Symbol, SymbolKind, + PolynomialType, PublicDeclaration, Reference, RepeatedArray, SourceRef, StatementIdentifier, + Symbol, SymbolKind, }; use crate::evaluator::Evaluator; @@ -39,7 +39,7 @@ struct PILAnalyzer { constants: HashMap, definitions: HashMap>)>, public_declarations: HashMap, - identities: Vec>, + identities: Vec>>, /// The order in which definitions and identities /// appear in the source. source_order: Vec, @@ -513,8 +513,8 @@ impl<'a, T: FieldElement> ExpressionProcessor<'a, T> { pub fn process_selected_expression( &mut self, - expr: ::ast::parsed::SelectedExpressions, - ) -> SelectedExpressions { + expr: SelectedExpressions>, + ) -> SelectedExpressions> { SelectedExpressions { selector: expr.selector.map(|e| self.process_expression(e)), expressions: self.process_expressions(expr.expressions), @@ -550,18 +550,15 @@ impl<'a, T: FieldElement> ExpressionProcessor<'a, T> { } } - pub fn process_expressions( - &mut self, - exprs: Vec<::ast::parsed::Expression>, - ) -> Vec> { + pub fn process_expressions(&mut self, exprs: Vec>) -> Vec> { exprs .into_iter() .map(|e| self.process_expression(e)) .collect() } - pub fn process_expression(&mut self, expr: ::ast::parsed::Expression) -> Expression { - use ast::parsed::Expression as PExpression; + pub fn process_expression(&mut self, expr: parsed::Expression) -> Expression { + use parsed::Expression as PExpression; match expr { PExpression::Constant(name) => Expression::Constant(name), PExpression::Reference(poly) => { @@ -675,7 +672,9 @@ impl<'a, T: FieldElement> ExpressionProcessor<'a, T> { } } -pub fn inline_intermediate_polynomials(analyzed: &Analyzed) -> Vec> { +pub fn inline_intermediate_polynomials( + analyzed: &Analyzed, +) -> Vec>> { substitute_intermediate( analyzed.identities.clone(), &analyzed @@ -697,9 +696,9 @@ pub fn inline_intermediate_polynomials(analyzed: &Analyzed) -> Vec( - identities: impl IntoIterator>, + identities: impl IntoIterator>>, intermediate_polynomials: &HashMap>, -) -> Vec> { +) -> Vec>> { identities .into_iter() .scan(HashMap::default(), |cache, mut identity| {