MCPcopy Create free account

hub / github.com/VictorColomb/stark-snark-recursive-proofs / functions

Functions1,090 in github.com/VictorColomb/stark-snark-recursive-proofs

⨍ Functions 1,090◇ Types & classes 117
↓ 2 callersMethodadd_segment_elements
Adds random elements for a new auxiliary segment to this set of random elements.
winterfell/air/src/air/coefficients.rs:34
↓ 2 callersFunctionapply_mds
(state: &mut [E])
winterfell/crypto/src/hash/poseidon/poseidon.rs:133
↓ 2 callersFunctionapply_round
(state: &mut [BaseElement; STATE_WIDTH], round: usize)
winterfell/crypto/src/hash/rescue/rp62_248/mod.rs:244
↓ 2 callersFunctionapply_sbox
(state: &mut [E])
winterfell/crypto/src/hash/poseidon/poseidon.rs:96
↓ 2 callersFunctionas_base_elements
()
winterfell/math/src/field/extensions/cubic.rs:449
↓ 2 callersMethodas_bytes
(&self)
winterfell/crypto/src/hash/rescue/rp64_256/digest.rs:34
↓ 2 callersMethodblowup
Returns blowup factor which was used to extend original execution trace into trace LDE.
winterfell/prover/src/trace/trace_lde.rs:66
↓ 2 callersMethodblowup_factor
Returns a blowup factor of the evaluation domain. Specifically, if the polynomial for which the FRI protocol is executed is of degree `d` where `d` i
winterfell/fri/src/options.rs:83
↓ 2 callersFunctionbuild_coordinate_batches
(batch_size: usize)
winterfell/fri/benches/folding.rs:43
↓ 2 callersMethodbuild_fragments
Returns a vector of trace fragments each covering the number of steps specified by the `fragment_length` parameter.
winterfell/prover/src/trace/trace_table.rs:284
↓ 2 callersMethodbuild_proof
PROOF BUILDER -------------------------------------------------------------------------------------------- Builds a proof from the previously committe
winterfell/prover/src/channel.rs:173
↓ 2 callersFunctionbuild_sequence_poly
(values: &[BaseElement], trace_length: usize)
winterfell/air/src/air/tests.rs:331
↓ 2 callersMethodce_domain_generator
Returns the generator of constraint evaluation domain.
winterfell/prover/src/domain.rs:75
↓ 2 callersMethodcheck_leading_zeros
Computes hash(`seed` || `value`) and returns the number of leading zeros in the resulting value if it is interpreted as an integer in big-endian byte
winterfell/crypto/src/random/mod.rs:164
↓ 2 callersMethodcolumns
Returns an iterator over the columns of this matrix.
winterfell/prover/src/matrix.rs:129
↓ 2 callersMethodcommit_to_rows
Returns a commitment to this matrix. The commitment is built as follows: Each row of the matrix is hashed into a single digest of the specified hash
winterfell/prover/src/matrix.rs:218
↓ 2 callersMethodcommit_trace
Commits the prover the extended execution trace.
winterfell/prover/src/channel.rs:73
↓ 2 callersMethoddegree
Returns the degree of the composition polynomial.
winterfell/prover/src/composer/mod.rs:50
↓ 2 callersMethoddomain_offset
Returns offset of the domain over which FRI protocol is executed by this prover.
winterfell/fri/src/prover/mod.rs:136
↓ 2 callersMethodevaluate_aux_transition
( &self, main_frame: &EvaluationFrame<E::BaseField>, aux_frame: &EvaluationFrame<E>,
winterfell/prover/src/constraints/evaluator.rs:294
↓ 2 callersMethodevaluate_main
Evaluates boundary constraints against the main segment of an execution trace at the specified step of constraint evaluation domain. Specifically, `s
winterfell/prover/src/constraints/boundary.rs:93
↓ 2 callersMethodevaluate_main_transition
( &self, main_frame: &EvaluationFrame<E::BaseField>, x: E::BaseField, step: us
winterfell/prover/src/constraints/evaluator.rs:264
↓ 2 callersMethodevaluate_transition
( &self, _frame: &EvaluationFrame<E>, _periodic_values: &[E], _result: &mut [E
winterfell/prover/src/tests/mod.rs:114
↓ 2 callersFunctionfill_zero_roots
(xs: &[E], result: &mut [E])
winterfell/math/src/polynom/mod.rs:644
↓ 2 callersMethodfinalize
(&self)
winterfell/crypto/src/hash/blake/mod.rs:123
↓ 2 callersFunctionfold_positions
POSITION FOLDING ================================================================================================ Maps positions in the source domain,
winterfell/fri/src/folding/mod.rs:159
↓ 2 callersMethodfolding_factor
Returns the factor by which the degree of a polynomial is reduced with each FRI layer. In combination with `max_remainder_size` this property defines
winterfell/fri/src/options.rs:66
↓ 2 callersFunctionfull_round
(state: &mut Vec<BaseElement>, i: usize)
winterfell/crypto/src/hash/poseidon/poseidon.rs:69
↓ 2 callersMethodget_aux_assertions
( &self, aux_rand_elements: &AuxTraceRandElements<E>, )
winterfell/air/src/air/mod.rs:283
↓ 2 callersMethodget_aux_segment_width
Returns the number of columns in the auxiliary trace segment at the specified index.
winterfell/air/src/air/trace_info.rs:259
↓ 2 callersMethodget_aux_trace_segment_random_elements
Returns a vector of field elements required for construction of an auxiliary trace segment with the specified index. The elements are drawn uniformly
winterfell/air/src/air/mod.rs:486
↓ 2 callersMethodget_column
Returns a reference to the column at the specified index.
winterfell/prover/src/matrix.rs:96
↓ 2 callersMethodget_column
Returns the entire trace column at the specified index.
winterfell/prover/src/trace/trace_table.rs:330
↓ 2 callersMethodget_constraint_composition_coefficients
Returns coefficients needed for random linear combination during construction of constraint composition polynomial.
winterfell/air/src/air/mod.rs:511
↓ 2 callersMethodget_main_segment
Returns a reference to [Matrix] representing the main trace segment.
winterfell/prover/src/trace/trace_lde.rs:101
↓ 2 callersMethodget_proof_options
(&self)
circom-prover/src/lib.rs:479
↓ 2 callersMethodget_pub_inputs
(&self, trace: &Self::Trace)
examples/sum/src/prover.rs:40
↓ 2 callersMethodget_trace_info
Returns trace info for the computation described by this proof.
winterfell/air/src/proof/mod.rs:88
↓ 2 callersMethodget_transition_constraints
Groups transition constraints together by their degree. This function also assigns composition coefficients to each constraint. These coefficients wi
winterfell/air/src/air/mod.rs:352
↓ 2 callersFunctionget_transition_poly_degree
( evaluations: &[E], inv_twiddles: &[E::BaseField], div_values: &[E::BaseField], )
winterfell/prover/src/constraints/evaluation_table.rs:462
↓ 2 callersFunctionget_twiddles
(c: &mut Criterion)
winterfell/math/benches/fft.rs:92
↓ 2 callersFunctiongroup_constraints
Groups transition constraints by their degree.
winterfell/air/src/air/transition/mod.rs:298
↓ 2 callersFunctiongroup_constraints
Translates the provided assertions into boundary constraints, groups the constraints by their divisor, and sorts the resulting groups by the degree ad
winterfell/air/src/air/boundary/mod.rs:152
↓ 2 callersFunctioninv
Computes y such that (x * y) % m = 1 except for when when x = 0; in such a case, 0 is returned; x is assumed to be a valid field element.
winterfell/math/src/field/f128/mod.rs:455
↓ 2 callersFunctioninv
Computes y such that (x * y) % m = 1 except for when x = 0. In that case, 0 is returned. x is assumed to be a valid field element.
winterfell/math/src/field/f256/mod.rs:439
↓ 2 callersMethodis_none
Returns `true` if this field extension is set to `None`.
winterfell/air/src/options.rs:267
↓ 2 callersMethodlde_blowup_factor
(&self)
circom-prover/src/lib.rs:502
↓ 2 callersMethodmeta
Returns execution trace metadata.
winterfell/air/src/air/trace_info.rs:129
↓ 2 callersFunctionmod_reduce
(x: u128)
winterfell/math/src/field/f64/mod.rs:544
↓ 2 callersFunctionmul
Computes (a * b) % m; a and b are assumed to be valid field elements.
winterfell/math/src/field/f128/mod.rs:414
↓ 2 callersFunctionmul
Computes (a * b) % m. a and b are assumed to be valid field elements.
winterfell/math/src/field/f256/mod.rs:432
↓ 2 callersFunctionmul_128x64
(a: u128, b: u64)
winterfell/math/src/field/f128/mod.rs:554
↓ 2 callersFunctionmul_reduce
(z0: u64, z1: u64, z2: u64)
winterfell/math/src/field/f128/mod.rs:562
↓ 2 callersMethodnext
Updates the state by incrementing the counter and returns hash(seed || counter)
winterfell/crypto/src/random/mod.rs:303
↓ 2 callersFunctionnormalize_indexes
(indexes: &[usize])
winterfell/crypto/src/merkle/mod.rs:362
↓ 2 callersMethodnum_assertions
(&self)
circom-prover/src/lib.rs:517
↓ 2 callersMethodnum_aux_segments
Returns the number of auxiliary trace segments in an execution trace.
winterfell/air/src/air/trace_info.rs:254
↓ 2 callersMethodnum_columns
Returns the number of individual column polynomials used to describe this composition polynomial.
winterfell/prover/src/constraints/composition_poly.rs:56
↓ 2 callersMethodnum_rows
Returns number of rows in this table.
winterfell/air/src/proof/table.rs:67
↓ 2 callersMethodnum_transition_exemptions
Returns the number of rows at the end of an execution trace to which transition constraints do not apply. This is guaranteed to be at least 1 (which
winterfell/air/src/air/context.rs:236
↓ 2 callersFunctionpadder
(input: &mut Vec<BaseElement>)
winterfell/crypto/src/hash/poseidon/poseidon.rs:22
↓ 2 callersMethodparse
PARSING -------------------------------------------------------------------------------------------- Decomposes this layer into a combination of query
winterfell/fri/src/proof.rs:295
↓ 2 callersMethodparse_remainder
Returns a vector of remainder values (last FRI layer) parsed from this proof. # Errors Returns an error if: The number of remainder values implied by
winterfell/fri/src/proof.rs:177
↓ 2 callersFunctionpermutation
(input: &mut Vec<BaseElement>)
winterfell/crypto/src/hash/poseidon/poseidon.rs:51
↓ 2 callersMethodpoly_offset
Returns offset by which we need to shift the domain before evaluating this constraint. The offset is returned as a tuple describing both, the number
winterfell/air/src/air/boundary/constraint.rs:106
↓ 2 callersFunctionprepare_assertions
Makes sure the assertions are valid in the context of this computation and don't overlap with each other - i.e. no two assertions are placed against t
winterfell/air/src/air/boundary/mod.rs:192
↓ 2 callersFunctionprint_matrix
(name:str,M)
circuits/poseidon/generate_parameters_grain.sage.py:493
↓ 2 callersFunctionprint_vector
(name:str,M)
circuits/poseidon/generate_parameters_grain.sage.py:516
↓ 2 callersMethodquery
QUERY TRACE -------------------------------------------------------------------------------------------- Returns trace table rows at the specified pos
winterfell/prover/src/trace/commitment.rs:79
↓ 2 callersMethodread_main_trace_frame_into
Reads current and next rows from the main trace segment into the specified frame.
winterfell/prover/src/trace/trace_lde.rs:71
↓ 2 callersMethodreset
Clears a vector of internally stored layers.
winterfell/fri/src/prover/mod.rs:147
↓ 2 callersMethodroot
Returns the root of the tree.
winterfell/crypto/src/merkle/mod.rs:133
↓ 2 callersMethodserialize_nodes
Converts all internal proof nodes into a vector of bytes. # Panics Panics if: The proof contains more than 255 Merkle paths. The Merkle paths consist
winterfell/crypto/src/merkle/proofs.rs:380
↓ 2 callersFunctionshuffle
Randomly shuffles slice elements.
winterfell/utils/rand/src/lib.rs:116
↓ 2 callersFunctionsub
Computes (a - b) % m; a and b are assumed to be valid field elements.
winterfell/math/src/field/f128/mod.rs:405
↓ 2 callersFunctionsub
(a: u64, b: u64)
winterfell/math/src/field/f62/mod.rs:509
↓ 2 callersFunctionsub
Computes (a - b) % m; a and b are assumed to be valid field elements.
winterfell/math/src/field/f256/mod.rs:423
↓ 2 callersMethodto_biguint
(&self)
winterfell/math/src/field/f256/tests.rs:100
↓ 2 callersMethodtrace_domain_generator
Returns the generator of the trace domain for an instance of the computation described by this AIR. The generator is the $n$th root of unity where $n
winterfell/air/src/air/mod.rs:419
↓ 2 callersMethodtrace_length
Returns execution trace length of the computation described by this context.
winterfell/air/src/proof/context.rs:50
↓ 2 callersMethodtrace_poly_degree
Returns degree of trace polynomials for an instance of a computation. The degree is always `trace_length` - 1.
winterfell/air/src/air/context.rs:176
↓ 2 callersMethodtrace_table
Returns the execution trace for this commitment. The trace contains both the main trace segment and the auxiliary trace segments (if any).
winterfell/prover/src/trace/commitment.rs:71
↓ 2 callersMethodtrace_twiddles
Returns twiddles which can be used to evaluate trace polynomials.
winterfell/prover/src/domain.rs:52
↓ 2 callersMethodtransition_constraint_degrees
(&self)
circom-prover/src/lib.rs:510
↓ 2 callersFunctiontranspose
Splits polynomial coefficients into the specified number of columns. The coefficients are split in such a way that each resulting column has the same
winterfell/prover/src/constraints/composition_poly.rs:111
↓ 2 callersFunctiontranspose_slice
Transposes a slice of `n` elements into a matrix with `N` columns and `n`/`N` rows. When `concurrent` feature is enabled, the slice will be transpose
winterfell/utils/core/src/lib.rs:557
↓ 2 callersFunctiontranspose_square_stretch
(matrix: &mut [T], size: usize, stretch: usize)
winterfell/math/src/fft/concurrent.rs:170
↓ 2 callersMethodupdate_row
Updates a single row in the fragment with provided data.
winterfell/prover/src/constraints/evaluation_table.rs:276
↓ 2 callersMethodupdate_transition_evaluations
( &mut self, row_idx: usize, main_evaluations: &[E::BaseField], aux_evaluation
winterfell/prover/src/constraints/evaluation_table.rs:284
↓ 2 callersFunctionvalidate_stride
(stride: usize, first_step: usize, column: usize)
winterfell/air/src/air/assertions/mod.rs:351
↓ 2 callersMethodverify
VERIFICATION PROCEDURE -------------------------------------------------------------------------------------------- Executes the query phase of the FR
winterfell/fri/src/verifier/mod.rs:202
↓ 2 callersFunctionverify_proof
( proof: FriProof, commitments: Vec<<Blake3 as Hasher>::Digest>, evaluations: &[BaseElement],
winterfell/fri/src/prover/tests.rs:85
↓ 2 callersMethodwrite_into
Serializes `self` and writes the resulting bytes into the `target`.
winterfell/air/src/proof/ood_frame.rs:128
↓ 2 callersMethodwrite_into
(&self, target: &mut W)
examples/sum/src/air.rs:35
↓ 1 callersFunctionacc_column
( column: Vec<E>, divisor: &ConstraintDivisor<E::BaseField>, domain_offset: E::BaseField, resu
winterfell/prover/src/constraints/evaluation_table.rs:330
↓ 1 callersFunctionadd
Computes (a + b) % m; a and b are assumed to be valid field elements.
winterfell/math/src/field/f128/mod.rs:395
↓ 1 callersFunctionadd
(a: u64, b: u64)
winterfell/math/src/field/f62/mod.rs:500
↓ 1 callersFunctionadd
Computes (a + b) % m. a and b are assumed to be valid field elements.
winterfell/math/src/field/f256/mod.rs:413
↓ 1 callersMethodadd
Adds a new constraint to the group. The constraint is identified by an index in the evaluation table.
winterfell/air/src/air/transition/mod.rs:245
↓ 1 callersMethodadd
Creates a new boundary constraint from the specified assertion and adds it to the group.
winterfell/air/src/air/boundary/constraint_group.rs:96
← previousnext →201–300 of 1,090, ranked by callers