diff --git a/kimchi/src/circuits/berkeley_columns.rs b/kimchi/src/circuits/berkeley_columns.rs index e9a6ce4339..2bf4fc87fb 100644 --- a/kimchi/src/circuits/berkeley_columns.rs +++ b/kimchi/src/circuits/berkeley_columns.rs @@ -21,10 +21,10 @@ use crate::{ circuits::{ - domains::EvaluationDomains, + domains::{Domain, EvaluationDomains}, expr::{ CacheId, ColumnEnvironment, ColumnEvaluations, ConstantExpr, ConstantTerm, Constants, - Domain, Expr, ExprError, FormattedOutput, + Expr, ExprError, FormattedOutput, }, gate::{CurrOrNext, GateType}, lookup::{index::LookupSelectors, lookups::LookupPattern}, diff --git a/kimchi/src/circuits/domains.rs b/kimchi/src/circuits/domains.rs index 308a7bf092..114e2a5226 100644 --- a/kimchi/src/circuits/domains.rs +++ b/kimchi/src/circuits/domains.rs @@ -1,21 +1,34 @@ +//! This module describes the evaluation domains that can be used by the +//! polynomials. + use ark_ff::FftField; -use ark_poly::{EvaluationDomain, Radix2EvaluationDomain as Domain}; +use ark_poly::{EvaluationDomain, Radix2EvaluationDomain}; use serde::{Deserialize, Serialize}; use serde_with::serde_as; use crate::error::DomainCreationError; +/// The different multiplicaive domain sizes that can be used by the polynomials. +/// We do support up to 8 times the size of the original domain for now. +#[derive(Clone, Copy, Debug, PartialEq, FromPrimitive, ToPrimitive)] +pub enum Domain { + D1 = 1, + D2 = 2, + D4 = 4, + D8 = 8, +} + #[serde_as] #[derive(Debug, Clone, Copy, Serialize, Deserialize)] pub struct EvaluationDomains { #[serde_as(as = "o1_utils::serialization::SerdeAs")] - pub d1: Domain, // size n + pub d1: Radix2EvaluationDomain, // size n #[serde_as(as = "o1_utils::serialization::SerdeAs")] - pub d2: Domain, // size 2n + pub d2: Radix2EvaluationDomain, // size 2n #[serde_as(as = "o1_utils::serialization::SerdeAs")] - pub d4: Domain, // size 4n + pub d4: Radix2EvaluationDomain, // size 4n #[serde_as(as = "o1_utils::serialization::SerdeAs")] - pub d8: Domain, // size 8n + pub d8: Radix2EvaluationDomain, // size 8n } impl EvaluationDomains { @@ -24,30 +37,26 @@ impl EvaluationDomains { /// `g`, the generator of `d4` is `g^2`, the generator of `d2` is `g^4`, and /// the generator of `d1` is `g^8`. pub fn create(n: usize) -> Result { - let n = Domain::::compute_size_of_domain(n) + let n = Radix2EvaluationDomain::::compute_size_of_domain(n) .ok_or(DomainCreationError::DomainSizeFailed(n))?; - let d1 = Domain::::new(n).ok_or(DomainCreationError::DomainConstructionFailed( - "d1".to_string(), - n, - ))?; + let d1 = Radix2EvaluationDomain::::new(n).ok_or( + DomainCreationError::DomainConstructionFailed("d1".to_string(), n), + )?; // we also create domains of larger sizes // to efficiently operate on polynomials in evaluation form. // (in evaluation form, the domain needs to grow as the degree of a // polynomial grows) - let d2 = Domain::::new(2 * n).ok_or(DomainCreationError::DomainConstructionFailed( - "d2".to_string(), - 2 * n, - ))?; - let d4 = Domain::::new(4 * n).ok_or(DomainCreationError::DomainConstructionFailed( - "d4".to_string(), - 4 * n, - ))?; - let d8 = Domain::::new(8 * n).ok_or(DomainCreationError::DomainConstructionFailed( - "d8".to_string(), - 8 * n, - ))?; + let d2 = Radix2EvaluationDomain::::new(2 * n).ok_or( + DomainCreationError::DomainConstructionFailed("d2".to_string(), 2 * n), + )?; + let d4 = Radix2EvaluationDomain::::new(4 * n).ok_or( + DomainCreationError::DomainConstructionFailed("d4".to_string(), 4 * n), + )?; + let d8 = Radix2EvaluationDomain::::new(8 * n).ok_or( + DomainCreationError::DomainConstructionFailed("d8".to_string(), 8 * n), + )?; // ensure the relationship between the three domains in case the // library's behavior changes diff --git a/kimchi/src/circuits/expr.rs b/kimchi/src/circuits/expr.rs index 246f0321ed..a80a741cee 100644 --- a/kimchi/src/circuits/expr.rs +++ b/kimchi/src/circuits/expr.rs @@ -3,6 +3,7 @@ use crate::{ berkeley_columns, berkeley_columns::BerkeleyChallengeTerm, constraints::FeatureFlags, + domains::Domain, gate::CurrOrNext, lookup::lookups::{LookupPattern, LookupPatterns}, polynomials::{ @@ -992,14 +993,6 @@ where } } -#[derive(Clone, Copy, Debug, PartialEq, FromPrimitive, ToPrimitive)] -pub enum Domain { - D1 = 1, - D2 = 2, - D4 = 4, - D8 = 8, -} - #[derive(Clone)] enum EvalResult<'a, F: FftField> { Constant(F), diff --git a/msm/src/column_env.rs b/msm/src/column_env.rs index 9937492d87..808ac598ba 100644 --- a/msm/src/column_env.rs +++ b/msm/src/column_env.rs @@ -4,8 +4,8 @@ use ark_poly::{Evaluations, Radix2EvaluationDomain}; use crate::{logup, logup::LookupTableID, witness::Witness}; use kimchi::circuits::{ berkeley_columns::{BerkeleyChallengeTerm, BerkeleyChallenges}, - domains::EvaluationDomains, - expr::{ColumnEnvironment as TColumnEnvironment, Constants, Domain}, + domains::{Domain, EvaluationDomains}, + expr::{ColumnEnvironment as TColumnEnvironment, Constants}, }; /// The collection of polynomials (all in evaluation form) and constants diff --git a/o1vm/src/pickles/column_env.rs b/o1vm/src/pickles/column_env.rs index da0b378793..801965689e 100644 --- a/o1vm/src/pickles/column_env.rs +++ b/o1vm/src/pickles/column_env.rs @@ -1,15 +1,16 @@ use ark_ff::FftField; use ark_poly::{Evaluations, Radix2EvaluationDomain}; -use crate::interpreters::mips::{column::N_MIPS_SEL_COLS, witness::SCRATCH_SIZE}; +use crate::{ + interpreters::mips::{column::N_MIPS_SEL_COLS, witness::SCRATCH_SIZE}, + pickles::proof::WitnessColumns, +}; use kimchi::circuits::{ berkeley_columns::{BerkeleyChallengeTerm, BerkeleyChallenges}, - domains::EvaluationDomains, - expr::{ColumnEnvironment as TColumnEnvironment, Constants, Domain}, + domains::{Domain, EvaluationDomains}, + expr::{ColumnEnvironment as TColumnEnvironment, Constants}, }; -use super::proof::WitnessColumns; - type Evals = Evaluations>; /// The collection of polynomials (all in evaluation form) and constants