Enum AbstractExpression 

pub enum AbstractExpression<F: Field> {
    Constant(F),
    Selector(MleIndex<F>, Box<AbstractExpression<F>>, Box<AbstractExpression<F>>),
    Mle(NodeId),
    Sum(Box<AbstractExpression<F>>, Box<AbstractExpression<F>>),
    Product(Vec<NodeId>),
    Scaled(Box<AbstractExpression<F>>, F),
}

See [ExpressionNode] for more details. Note that this implementation is somewhat redundant with [Expression] and [ExpressionNode], but the separation allows for more flexibility with respect to this particular frontend being able to create polynomial relationships in any way it chooses, so long as those representations are compile-able into [Expression].

Variants

Constant(F)

Selector(MleIndex<F>, Box<AbstractExpression<F>>, Box<AbstractExpression<F>>)

Mle(NodeId)

Sum(Box<AbstractExpression<F>>, Box<AbstractExpression<F>>)

Product(Vec<NodeId>)

Scaled(Box<AbstractExpression<F>>, F)

Implementations

impl<F: Field> AbstractExpression<F>

pub fn traverse( &self, observer_fn: &mut impl FnMut(&AbstractExpression<F>) -> Result<()>, ) -> Result<()>

Traverses the expression and applies the observer function to all nodes.

pub fn get_sources(&self) -> Vec<NodeId>

find all the sources this expression depend on

pub fn get_num_vars( &self, num_vars_map: &HashMap<NodeId, usize>, ) -> Result<usize>

Computes the num_vars of this expression (how many rounds of sumcheck it would take to prove)

pub fn build_circuit_expr( self, circuit_map: &CircuitMap, ) -> Result<Expression<F, ExprDescription>>

Convert the abstract expression into a circuit expression, which stores information on the shape of the expression, using the CircuitMap.

pub fn select(self, rhs: Self) -> Self

See documentation for select() function within [remainder::expression::circuit_expr::ExprDescription]

pub fn select_seq<E: Clone + Into<AbstractExpression<F>>>( expressions: Vec<E>, ) -> Self

Call Self::select sequentially

pub fn binary_tree_selector<E: Into<AbstractExpression<F>>>( expressions: Vec<E>, ) -> Self

Create a nested selector Expression that selects between 2^k Expressions by creating a binary tree of Selector Expressions. The order of the leaves is the order of the input expressions. (Note that this is very different from Self::select_seq.)

pub fn pow(pow: usize, node_id: Self) -> Self

Create a product Expression that raises one expression to a given power

pub fn products(node_ids: Vec<NodeId>) -> Self

Create a product Expression that multiplies many MLEs together

pub fn mult(lhs: Self, rhs: Self) -> Self

Multiplication for expressions, DO NOT USE ON SELECTORS

pub fn mle(node_id: NodeId) -> Self

Create a mle Expression that contains one MLE

pub fn constant(constant: F) -> Self

Create a constant Expression that contains one field element

pub fn negated(expression: Self) -> Self

negates an Expression

pub fn sum(lhs: Self, rhs: Self) -> Self

Create a Sum Expression that contains two MLEs

pub fn scaled(expression: AbstractExpression<F>, scale: F) -> Self

scales an Expression by a field element

impl<F: Field> AbstractExpression<F>

fn build_circuit_node( self, node_map: &HashMap<NodeId, (usize, &CircuitLocation)>, ) -> Result<ExpressionNode<F, ExprDescription>>

fn get_node_ids(&self, node_ids: Vec<NodeId>) -> Vec<NodeId>

Trait Implementations

impl<F: Field, Rhs: Into<AbstractExpression<F>>> Add<Rhs> for &AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> Add<Rhs> for AbstractExpression<F>

implement the Add, Sub, and Mul traits for the Expression

type Output = AbstractExpression<F>

The resulting type after applying the + operator.

fn add(self, rhs: Rhs) -> Self::Output

Performs the + operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> AddAssign<Rhs> for AbstractExpression<F>

fn add_assign(&mut self, rhs: Rhs)

Performs the += operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> BitXor<Rhs> for &AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> BitXor<Rhs> for AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Rhs) -> Self::Output

Performs the ^ operation.

impl<F: Clone + Field> Clone for AbstractExpression<F>

fn clone(&self) -> AbstractExpression<F>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Debug + Field> Debug for AbstractExpression<F>

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

Formats the value using the given formatter.

impl<'de, F> Deserialize<'de> for AbstractExpression<F>

where F: Field,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<F: Field> From<&AbstractExpression<F>> for AbstractExpression<F>

fn from(val: &AbstractExpression<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<&FSNodeRef<F>> for AbstractExpression<F>

fn from(value: &FSNodeRef<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<&InputLayerNodeRef<F>> for AbstractExpression<F>

fn from(value: &InputLayerNodeRef<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<&NodeRef<F>> for AbstractExpression<F>

fn from(value: &NodeRef<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<F> for AbstractExpression<F>

fn from(f: F) -> Self

Converts to this type from the input type.

impl<F: Field> From<FSNodeRef<F>> for AbstractExpression<F>

fn from(value: FSNodeRef<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<InputLayerNodeRef<F>> for AbstractExpression<F>

fn from(value: InputLayerNodeRef<F>) -> Self

Converts to this type from the input type.

impl<F: Field> From<NodeRef<F>> for AbstractExpression<F>

fn from(value: NodeRef<F>) -> Self

Converts to this type from the input type.

impl<F: Hash + Field> Hash for AbstractExpression<F>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> Mul<Rhs> for &AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> Mul<Rhs> for AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the * operator.

fn mul(self, rhs: Rhs) -> Self::Output

Performs the * operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> MulAssign<Rhs> for AbstractExpression<F>

fn mul_assign(&mut self, rhs: Rhs)

Performs the *= operation.

impl<F: Field> Neg for &AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: Field> Neg for AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the - operator.

fn neg(self) -> Self::Output

Performs the unary - operation.

impl<F: PartialEq + Field> PartialEq for AbstractExpression<F>

fn eq(&self, other: &AbstractExpression<F>) -> 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<F> Serialize for AbstractExpression<F>

where F: Field,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> Sub<Rhs> for &AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> Sub<Rhs> for AbstractExpression<F>

type Output = AbstractExpression<F>

The resulting type after applying the - operator.

fn sub(self, rhs: Rhs) -> Self::Output

Performs the - operation.

impl<F: Field, Rhs: Into<AbstractExpression<F>>> SubAssign<Rhs> for AbstractExpression<F>

fn sub_assign(&mut self, rhs: Rhs)

Performs the -= operation.

impl<F: Eq + Field> Eq for AbstractExpression<F>

impl<F: Field> StructuralPartialEq for AbstractExpression<F>