Enum DynProofExpr 

pub enum DynProofExpr {
    Column(ColumnExpr),
    And(AndExpr),
    Or(OrExpr),
    Not(NotExpr),
    Literal(LiteralExpr),
    Placeholder(PlaceholderExpr),
    Equals(EqualsExpr),
    Inequality(InequalityExpr),
    Add(AddExpr),
    Subtract(SubtractExpr),
    Multiply(MultiplyExpr),
    Cast(CastExpr),
    ScalingCast(ScalingCastExpr),
}

Enum of AST column expression types that implement ProofExpr. Is itself a ProofExpr.

Variants

Column(ColumnExpr)

Column

And(AndExpr)

Provable logical AND expression

Or(OrExpr)

Provable logical OR expression

Not(NotExpr)

Provable logical NOT expression

Literal(LiteralExpr)

Provable CONST expression

Placeholder(PlaceholderExpr)

Provable placeholder expression

Equals(EqualsExpr)

Provable AST expression for an equals expression

Inequality(InequalityExpr)

Provable AST expression for an inequality expression

Add(AddExpr)

Provable numeric + expression

Subtract(SubtractExpr)

Provable numeric - expression

Multiply(MultiplyExpr)

Provable numeric * expression

Cast(CastExpr)

Provable CAST expression

ScalingCast(ScalingCastExpr)

Provable expression for casting numeric expressions to decimal expressions

Implementations

impl DynProofExpr

pub fn new_column(column_ref: ColumnRef) -> Self

Create column expression

pub fn try_new_and(lhs: DynProofExpr, rhs: DynProofExpr) -> AnalyzeResult<Self>

Create logical AND expression

pub fn try_new_or(lhs: DynProofExpr, rhs: DynProofExpr) -> AnalyzeResult<Self>

Create logical OR expression

pub fn try_new_not(expr: DynProofExpr) -> AnalyzeResult<Self>

Create logical NOT expression

pub fn new_literal(value: LiteralValue) -> Self

Create CONST expression

pub fn try_new_placeholder( id: usize, column_type: ColumnType, ) -> AnalyzeResult<Self>

Create placeholder expression

pub fn try_new_equals( lhs: DynProofExpr, rhs: DynProofExpr, ) -> AnalyzeResult<Self>

Create a new equals expression

pub fn try_new_inequality( lhs: DynProofExpr, rhs: DynProofExpr, is_lt: bool, ) -> AnalyzeResult<Self>

Create a new inequality expression

pub fn try_new_add(lhs: DynProofExpr, rhs: DynProofExpr) -> AnalyzeResult<Self>

Create a new add expression

pub fn try_new_subtract( lhs: DynProofExpr, rhs: DynProofExpr, ) -> AnalyzeResult<Self>

Create a new subtract expression

pub fn try_new_multiply( lhs: DynProofExpr, rhs: DynProofExpr, ) -> AnalyzeResult<Self>

Create a new multiply expression

pub fn try_new_cast( from_column: DynProofExpr, to_datatype: ColumnType, ) -> AnalyzeResult<Self>

Create a new cast expression

pub fn try_new_scaling_cast( from_expr: DynProofExpr, to_datatype: ColumnType, ) -> AnalyzeResult<Self>

Create a new decimal scale cast expression

Trait Implementations

impl Clone for DynProofExpr

fn clone(&self) -> DynProofExpr

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for DynProofExpr

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for DynProofExpr

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<ColumnExpr> for DynProofExpr

fn from(v: ColumnExpr) -> DynProofExpr

Converts to this type from the input type.

impl PartialEq for DynProofExpr

fn eq(&self, other: &DynProofExpr) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl ProofExpr for DynProofExpr

fn data_type(&self) -> ColumnType

Get the data type of the expression

fn first_round_evaluate<'a, S: Scalar>( &self, __enum_dispatch_arg_0: &'a Bump, __enum_dispatch_arg_1: &Table<'a, S>, __enum_dispatch_arg_2: &[LiteralValue], ) -> PlaceholderResult<Column<'a, S>>

This returns the result of evaluating the expression on the given table, and returns a column of values. This result slice is guaranteed to have length table_length. Implementations must ensure that the returned slice has length table_length.

fn final_round_evaluate<'a, S: Scalar>( &self, __enum_dispatch_arg_0: &mut FinalRoundBuilder<'a, S>, __enum_dispatch_arg_1: &'a Bump, __enum_dispatch_arg_2: &Table<'a, S>, __enum_dispatch_arg_3: &[LiteralValue], ) -> PlaceholderResult<Column<'a, S>>

Evaluate the expression, add components needed to prove it, and return thet resulting column of values

fn verifier_evaluate<S: Scalar>( &self, __enum_dispatch_arg_0: &mut impl VerificationBuilder<S>, __enum_dispatch_arg_1: &IndexMap<Ident, S, BuildHasherDefault<AHasher>>, __enum_dispatch_arg_2: S, __enum_dispatch_arg_3: &[LiteralValue], ) -> Result<S, ProofError>

Compute the evaluation of a multilinear extension from this expression at the random sumcheck point and adds components needed to verify the expression to [VerificationBuilder<S>]

fn get_column_references( &self, __enum_dispatch_arg_0: &mut IndexSet<ColumnRef, BuildHasherDefault<AHasher>>, )

Insert in the [IndexSet] columns all the column references in the BoolExpr or forwards the call to some subsequent bool_expr

impl Serialize for DynProofExpr

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TryInto<ColumnExpr> for DynProofExpr

type Error = &'static str

The type returned in the event of a conversion error.

fn try_into(self) -> Result<ColumnExpr, <Self as TryInto<ColumnExpr>>::Error>

Performs the conversion.

impl StructuralPartialEq for DynProofExpr