Returns an out-of-domain evaluation frame constructed by evaluating trace polynomials for all columns at points z and z * g, where g is the generator

Returns an out-of-domain point drawn uniformly at random from the public coin.

Returns values for all periodic columns used in the computation. These values will be used to compute column values at specific states of the computa

Returns a set of positions in the LDE domain against which the evaluations of trace and constraint composition polynomials should be queried. The pos

Computes a node to which all Merkle paths aggregated in this proof resolve. # Errors Returns an error if: No indexes were provided (i.e., `indexes` i

Returns a reference to a row at the specified index.

Returns an estimate of how many bytes are needed to represent self. The default implementation returns zero.

HELPER FUNCTIONS ================================================================================================

Determines a nonce, which when hashed with the current seed of the public coin results in a new seed with the number of leading zeros equal to the gri

Transmutes a slice of `n` elements into a slice of `n` / `N` elements, each of which is an array of `N` elements. This function just re-interprets th

Transforms this composition polynomial into a vector of individual column polynomials.

CONSTRAINT COMPOSITION -------------------------------------------------------------------------------------------- Divides constraint evaluation colu

Returns a list of FRI layer commitments written by the prover into this channel.

Returns the generator of the low-degree extension domain for an instance of the computation described by this AIR. The generator is the $n$th root of

Returns the size of the LDE domain for the computation described by this proof.

Returns a list of transition constraint degree descriptors for the main trace segment of a computation. This list will be identical to the list passe

Returns transition constraint info for constraints applied against the main trace segment of a computation grouped by constraint degree.

Returns an iterator over the polynomials of the main trace segment.

Returns the number of columns in the main segment of this trace.

Maps positions in the evaluation domain to indexes of commitment Merkle tree.

EVALUATOR -------------------------------------------------------------------------------------------- Computes a linear combination of evaluations re

Divides each polynomial in the list by the corresponding divisor, and computes the coefficient-wise sum of all resulting polynomials.

Multiplies a sequence of values by a scalar and accumulates the results. More precisely, computes `a[i]` + `b[i]` * `c` for all `i` and saves result

Returns a polynomial resulting from multiplying a given polynomial by a scalar value. Specifically, multiplies every coefficient of polynomial `p` by

Returns the total number of assertions defined for a computation. The number of assertions consists of the assertions placed against the main segment

Returns number of columns in this table.

Returns number of bits in the base field modulus for the computation described by this context. The modulus is assumed to be encoded in little-endian

Returns the number of partitions used during proof generation.

Returns number of partitions used during FRI proof generation. For non-distributed proof generation, number of partitions is usually set to 1.

Returns the number of transition constraints for a computation. The number of transition constraints is defined by the total number of transition con

Returns LDE domain offset.

Returns the size of the DEEP composition polynomial.

Returns the size of each polynomial - i.e. size of a vector needed to hold a polynomial.

Returns whether the logging level is set to [Verbose](LoggingLevel::Verbose) or above. This is used to trigger the printing of underlying commands st

Returns a vector of value of the specified type and the specified length generated pseudo-randomly from the specified `seed`. # Panics Panics if: A v

Reads an evaluation frame from the set of provided auxiliary segments. This expects that `aux_segments` contains at least one entry. This is probably

Reads current and next rows from the auxiliary trace segment into the specified frame.

Returns constraint evaluation commitment sent by the prover.

Returns constraint evaluations at the specified positions of the LDE domain. This also checks if the constraint evaluations are valid against the cons

Returns FRI query values at the specified positions from the current FRI layer and advances layer pointer by one. This also checks if the values are

Returns evaluations of composition polynomial columns at z^m, where z is the out-of-domain point, and m is the number of composition polynomial column

Returns trace polynomial evaluations at out-of-domain points z and z * g, where g is the generator of the LDE domain. For computations requiring mult

Returns query proof-of-work nonce sent by the prover.

Returns execution trace commitments sent by the prover. For computations requiring multiple trace segment, the returned slice will contain a commitme

Returns a polynomial with all leading ZERO coefficients removed. # Examples ``` # use winter_math::polynom::*; # use winter_math::{fields::{f128::Bas

Saves the evaluations of constraint composition polynomial columns at the out-of-domain point. This also reseeds the public coin wit the hash of the e

Saves the evaluations of trace polynomials over the out-of-domain evaluation frame. This also reseeds the public coin with the hashes of the evaluatio

Executes a single-threaded version of the FFT algorithm on the provided values. The evaluation is done in-place, meaning the function does not alloca

Updates constraint evaluation portion of this out-of-domain frame. # Panics Panics if: Constraint evaluations have already been set. `evaluations` is

Updates the trace state portion of this out-of-domain frame. # Panics Panics if evaluation frame has already been set.

Returns the interval at which the assertion repeats in the execution trace. For single value assertions, this will be 0.

Returns a polynomial resulting from dividing a polynomial by a polynomial of special form. Specifically, divides polynomial `p` by polynomial (x^`a`

VALIDATION -------------------------------------------------------------------------------------------- Checks if this trace is valid against the spec

Panics if the assertion cannot be placed against an execution trace of the specified width.

Returns asserted values. For single value and periodic assertions this will be a slice containing one value.

Returns whether the logging level is set to [VeryVerbose](LoggingLevel::VeryVerbose). This is used to trigger verbose mode of the underlying commands

REMAINDER DEGREE VERIFICATION ================================================================================================ Returns Ok(true) if val

Serializes `self` and writes the resulting bytes into the `target`.

Extended Euclidean Algorithm for unsigned integers. Returns the Bézout coefficients.

Computes (P(x) - value) * k and saves the result into the accumulator.

Returns a polynomial resulting from adding two polynomials together. Polynomials `a` and `b` are expected to be in the coefficient form, and the retu