Struct twenty_first::shared_math::mpolynomial::MPolynomial

source ·

pub struct MPolynomial<T: FiniteField> {
    pub variable_count: usize,
    pub coefficients: HashMap<Vec<u8>, T>,
}

Fields

variable_count: usizecoefficients: HashMap<Vec<u8>, T>

Implementations

source

pub fn from_constant(element: FF, variable_count: usize) -> Self

Returns an MPolynomial instance over variable_count variables that evaluates to element everywhere. I.e. P(x,y..,z) = element

Note that in this encoding P(x,y) == P(x,w) but P(x,y) != P(x,y,z).

source

pub fn variables(variable_count: usize) -> Vec<Self>

Returns a vector of multivariate polynomials that each represent a function of one indeterminate variable to the first power. For example, let p = variables(3, 1.into()) represents the functions

p[0] = $f(x,y,z) = x$
p[1] =$f(x,y,z) = y$
p[2] =$f(x,y,z) = z$

and let p = variables(5, 1.into()) represents the functions

p[0] = $p(a,b,c,d,e) = a$
p[1] = $p(a,b,c,d,e) = b$
p[2] = $p(a,b,c,d,e) = c$
p[3] = $p(a,b,c,d,e) = d$
p[4] = $p(a,b,c,d,e) = e$

source

pub fn precalculate_symbolic_exponents(
 mpols: &[Self],
 point: &[Polynomial<FF>],
 exponents_memoization: &mut HashMap<Vec<u8>, Polynomial<FF>>
) -> Result<(), Box<dyn Error>>

source

pub fn evaluate(&self, point: &[FF]) -> FF

source

pub fn extract_exponents_list(
mpols: &[Self]
) -> Result<Vec<Vec<u8>>, Box<dyn Error>>

source

pub fn precalculate_scalar_mod_pows(
limit: u8,
point: &[FF]
) -> HashMap<(usize, u8), FF>

Get a hash map with precalculated values for point[i]^j Only exponents 2 and above are stored.

source

pub fn precalculate_scalar_exponents(
 point: &[FF],
 precalculated_mod_pows: &HashMap<(usize, u8), FF>,
 exponents_list: &[Vec<u8>]
) -> Result<HashMap<Vec<u8>, FF>, Box<dyn Error>>

source

pub fn evaluate_with_precalculation(
 &self,
 point: &[FF],
 intermediate_results: &HashMap<Vec<u8>, FF>
) -> FF

source

pub fn evaluate_symbolic_with_memoization_precalculated(
 &self,
 point: &[Polynomial<FF>],
 exponents_memoization: &mut HashMap<Vec<u8>, Polynomial<FF>>
) -> Polynomial<FF>

source

pub fn evaluate_symbolic_with_memoization(
 &self,
 point: &[Polynomial<FF>],
 mod_pow_memoization: &mut HashMap<(usize, u8), Polynomial<FF>>,
 mul_memoization: &mut HashMap<(Polynomial<FF>, (usize, u8)), Polynomial<FF>>,
 exponents_memoization: &mut HashMap<Vec<u8>, Polynomial<FF>>
) -> Polynomial<FF>

source

pub fn evaluate_symbolic(&self, point: &[Polynomial<FF>]) -> Polynomial<FF>

source

pub fn lift(
 univariate_polynomial: Polynomial<FF>,
 variable_index: usize,
 variable_count: usize
) -> Self

lift Creates a multivariate polynomial from a univariate one.

source

pub fn scalar_mul(&self, factor: FF) -> Self

source

pub fn scalar_mul_mut(&mut self, factor: FF)

source

pub fn pow(&self, pow: u8) -> Self

source

pub fn square(&self) -> Self

source

pub fn max_exponent(&self) -> u8

Return the highest number present in the list of list of exponents For P(x,y) = x^4*y^3, 4 would be returned.

source

pub fn degree(&self) -> Degree

Calculate the “total degree” of a multivariate polynomial.

The total degree is defined as the highest combined degree of any term where the combined degree is the sum of all the term’s variable exponents.

As a convention, the polynomial f(x) = 0 has degree -1.

source

pub fn normalize(&mut self)

Removes exponents whose coefficients are 0.

source

pub fn symbolic_degree_bound(&self, max_degrees: &[i64]) -> Degree

During symbolic evaluation, i.e., when substituting a univariate polynomial for one of the variables, the total degree of the resulting polynomial can be upper bounded. This bound is the total_degree_bound, and can be calculated across all terms. Only the constant zero polynomial P(x,..) = 0 has a negative degree and it is always -1. All other constant polynomials have degree 0.

max_degrees: the max degrees for each of the univariate polynomials.
total_degree_bound: the max resulting degree from the substitution.