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
↓ 263 callersMethodlen
(&self)
winterfell/prover/src/matrix.rs:285
↓ 61 callersMethodexp
(self, power: Self::PositiveInteger)
winterfell/math/src/field/f64/mod.rs:76
↓ 60 callersMethodto_le_bytes
(&self)
winterfell/math/src/field/f256/mod.rs:398
↓ 57 callersFunctionrand_value
Returns a single random value of the specified type. # Panics Panics if: A valid value requires over 32 bytes. A valid value could not be generated a
winterfell/utils/rand/src/lib.rs:28
↓ 51 callersFunctionhash
(input: &mut Vec<BaseElement>)
winterfell/crypto/src/hash/poseidon/poseidon.rs:32
↓ 36 callersMethodlen
(&self)
winterfell/air/src/proof/table.rs:137
↓ 32 callersFunctionlog2
Returns base 2 logarithm of `n`, where `n` is a power of two. # Panics Panics if `n` is not a power of two. # Examples ``` # use winter_math::log2;
winterfell/math/src/utils/mod.rs:203
↓ 27 callersFunctionget_root_of_unity
()
winterfell/math/src/field/f64/tests.rs:142
↓ 26 callersMethodoptions
Returns STARK protocol parameters used to generate this proof.
winterfell/air/src/proof/mod.rs:72
↓ 21 callersMethodreseed
Reseeds the coin with the specified data by setting the new seed to hash(`seed` || `data`). # Examples ``` # use winter_crypto::{RandomCoin, Hasher,
winterfell/crypto/src/random/mod.rs:105
↓ 19 callersMethodas_int
(&self)
winterfell/math/src/field/f64/mod.rs:207
↓ 19 callersFunctionzeroed_vector
()
winterfell/math/src/field/f64/tests.rs:232
↓ 18 callersMethoddraw_pair
Returns the next pair of pseudo-random field elements. # Errors Returns an error if any of the field elements could not be generated after 100 calls
winterfell/crypto/src/random/mod.rs:203
↓ 18 callersMethodwrite_u8_slice
(&mut self, values: &[u8])
winterfell/utils/core/src/lib.rs:391
↓ 17 callersMethodcontext
(&self)
winterfell/air/src/air/tests.rs:284
↓ 17 callersMethodread_u8
(&mut self)
winterfell/utils/core/src/lib.rs:229
↓ 17 callersMethodsquare
(self)
winterfell/math/src/field/traits.rs:103
↓ 16 callersMethodwrite
Writes a serializable value into `self`. # Panics Panics if the value could not be written into `self`.
winterfell/utils/core/src/lib.rs:381
↓ 15 callersMethodis_empty
(&self)
winterfell/prover/src/constraints/periodic_table.rs:80
↓ 15 callersMethodmul_base
(self, other: E)
winterfell/math/src/field/traits.rs:287
↓ 15 callersFunctionrand_vector
Returns a vector of random value of the specified type and the specified length. # Panics Panics if: A valid value requires at over 32 bytes. A valid
winterfell/utils/rand/src/lib.rs:45
↓ 15 callersFunctionuninit_vector
(length: usize)
winterfell/utils/core/src/lib.rs:437
↓ 14 callersMethodwrite_u8
(&mut self, value: u8)
winterfell/utils/core/src/lib.rs:387
↓ 13 callersMethodcurrent
(&self)
winterfell/air/src/air/transition/frame.rs:61
↓ 13 callersFunctioneval
Evaluates a polynomial at a single point and returns the result. Evaluates polynomial `p` at coordinate `x` using [Horner's method](https://en.wikipe
winterfell/math/src/polynom/mod.rs:53
↓ 13 callersMethodprove_batch
Computes Merkle paths for the provided indexes and compresses the paths into a single proof. # Errors Returns an error if: No indexes were provided (
winterfell/crypto/src/merkle/mod.rs:188
↓ 13 callersFunctionrand_array
Returns an array of random value of the specified type and the specified length. # Panics Panics if: A valid value requires at over 32 bytes. A valid
winterfell/utils/rand/src/lib.rs:68
↓ 12 callersFunctioncheck_file
Verify that a file exists, returning an error on failure.
circom-prover/src/utils.rs:203
↓ 12 callersMethoddegree_adjustment
Returns a degree adjustment factor for all boundary constraints in this group.
winterfell/air/src/air/boundary/constraint_group.rs:88
↓ 12 callersMethodget
Returns the element located at the specified column and row indexes in this matrix. # Panics Panics if either `col_idx` or `row_idx` are out of bound
winterfell/prover/src/matrix.rs:83
↓ 12 callersMethodnum_cols
Returns the number of columns in this matrix.
winterfell/prover/src/matrix.rs:70
↓ 11 callersMethodce_domain_size
Returns the size of the constraint evaluation domain for this computation.
winterfell/prover/src/domain.rs:70
↓ 11 callersMethodconstraints
Returns a list of boundary constraints in this group.
winterfell/air/src/air/boundary/constraint_group.rs:78
↓ 11 callersMethoddraw
Returns the next pseudo-random field element. # Errors Returns an error if a valid field element could not be generated after 1000 calls to the PRNG.
winterfell/crypto/src/random/mod.rs:179
↓ 11 callersFunctionmul
(a: u64, b: u64)
winterfell/math/src/field/f62/mod.rs:520
↓ 11 callersMethodnum_rows
Returns the number of rows in this table. This is the same as the size of the constraint evaluation domain.
winterfell/prover/src/constraints/evaluation_table.rs:93
↓ 10 callersFunctionhash_2x1
HELPER FUNCTIONS --------------------------------------------------------------------------------------------
winterfell/crypto/src/merkle/tests.rs:318
↓ 10 callersMethodlde_domain_size
Returns the size of the low-degree extension domain.
winterfell/prover/src/domain.rs:88
↓ 10 callersMethodlength
Returns execution trace length. The length is guaranteed to be a power of two.
winterfell/air/src/air/trace_info.rs:124
↓ 10 callersMethodread_u64
(&mut self)
winterfell/utils/core/src/lib.rs:271
↓ 10 callersMethodread_u8_vec
(&mut self, len: usize)
winterfell/utils/core/src/lib.rs:303
↓ 10 callersMethodrows
Returns an iterator over rows of this table.
winterfell/air/src/proof/table.rs:83
↓ 10 callersMethodtrace_length
Returns length of the execution trace for this computation.
winterfell/prover/src/domain.rs:47
↓ 9 callersMethodas_bytes
(&self)
winterfell/crypto/src/hash/rescue/rp62_248/digest.rs:34
↓ 9 callersMethodfolding_factor
Returns folding factor for this prover.
winterfell/fri/src/prover/mod.rs:131
↓ 9 callersFunctionget_power_series
Returns a vector containing successive powers of a given base. More precisely, for base `b`, generates a vector with values [1, b, b^2, b^3, ..., b^(
winterfell/math/src/utils/mod.rs:36
↓ 9 callersFunctioninv
(x: u64)
winterfell/math/src/field/f62/mod.rs:531
↓ 9 callersMethodoffset
Returns the row at which the fragment starts.
winterfell/prover/src/constraints/evaluation_table.rs:261
↓ 9 callersFunctionpermute
(values: &mut [T])
winterfell/math/src/fft/serial.rs:108
↓ 9 callersMethodprint_big_steps
Returns whether the logging level is set to [Default](LoggingLevel::Default) or above. This is used to trigger the printing of big step announcements
circom-prover/src/utils.rs:249
↓ 9 callersMethodtrace_layout
Returns a layout describing how columns of the execution trace described by this context are arranged into segments.
winterfell/air/src/proof/mod.rs:78
↓ 8 callersMethodce_blowup_factor
Returns constraint evaluation domain blowup factor for the computation described by this AIR. The blowup factor is defined as the smallest power of t
winterfell/air/src/air/mod.rs:431
↓ 8 callersFunctiondegree_of
Returns the degree of the provided polynomial. If the size of the provided slice is much larger than the degree of the polynomial (i.e., a large numb
winterfell/math/src/polynom/mod.rs:591
↓ 8 callersFunctiondigest
(input: &[u8])
winterfell/crypto/src/hash/poseidon/poseidon.rs:8
↓ 8 callersMethodget_periodic_column_polys
Returns polynomial for all periodic columns. These polynomials are interpolated from the values returned from the [get_periodic_column_values()](Air:
winterfell/air/src/air/mod.rs:310
↓ 8 callersMethodhas_more_bytes
(&self)
winterfell/utils/core/src/lib.rs:325
↓ 8 callersFunctioninterpolate_poly
Interpolates evaluations of a polynomial over the specified domain into a polynomial in coefficient from using the FFT algorithm. Uses the inverse [F
winterfell/math/src/fft/mod.rs:272
↓ 8 callersMethodlength
(&self)
winterfell/prover/src/trace/trace_table.rs:355
↓ 8 callersMethodnext
(&self)
winterfell/air/src/air/transition/frame.rs:73
↓ 8 callersMethodpoly
Returns a value polynomial for this constraint.
winterfell/air/src/air/boundary/constraint.rs:97
↓ 7 callersMethodas_bytes
Flattens a two-dimensional array of bytes into a slice of bytes.
winterfell/utils/core/src/lib.rs:410
↓ 7 callersFunctioncommand_execution
Execute a system command, returning an error on failure.
circom-prover/src/utils.rs:137
↓ 7 callersMethoddivisor
Returns a divisor for transition constraints. All transition constraints have the same divisor which has the form: $$ z(x) = \frac{x^n - 1}{x - g^{n
winterfell/air/src/air/transition/mod.rs:145
↓ 7 callersFunctionfft_in_place
In-place recursive FFT with permuted output. Adapted from: https://github.com/0xProject/OpenZKP/tree/master/algebra/primefield/src/fft
winterfell/math/src/fft/serial.rs:124
↓ 7 callersFunctiongrain_random_bits
(num_bits)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:117
↓ 7 callersFunctiongrain_random_bits
(num_bits)
circuits/poseidon/generate_parameters_grain.sage.py:117
↓ 7 callersMethodhash_fn
Returns a hash functions to be used during STARK proof construction. Security of a STARK proof is bounded by collision resistance of the hash functio
winterfell/air/src/options.rs:202
↓ 7 callersMethodis_single
Returns true if this is a single-value assertion (one value, one step).
winterfell/air/src/air/assertions/mod.rs:154
↓ 7 callersFunctionmul
Returns a polynomial resulting from multiplying two polynomials together. Polynomials `a` and `b` are expected to be in the coefficient form, and the
winterfell/math/src/polynom/mod.rs:326
↓ 7 callersMethodread_row_into
Reads a single row from this execution trace into the provided target.
winterfell/prover/src/trace/trace_table.rs:340
↓ 7 callersMethodtrace_info
Returns info of the execution trace for an instance of the computation described by this AIR.
winterfell/air/src/air/mod.rs:389
↓ 6 callersFunctionalgorithm_2
(M, NUM_CELLS)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:298
↓ 6 callersFunctionalgorithm_2
(M, NUM_CELLS)
circuits/poseidon/generate_parameters_grain.sage.py:298
↓ 6 callersMethodapply
Executes the provided closure for all possible instantiations of this assertions against a execution trace of the specified length. # Panics Panics i
winterfell/air/src/air/assertions/mod.rs:260
↓ 6 callersFunctionapply_permutation
Applies Rescue-XLIX permutation to the provided state. Implementation is based on algorithm 3 from <https://eprint.iacr.org/2020/1143.pdf>
winterfell/crypto/src/hash/rescue/rp62_248/mod.rs:235
↓ 6 callersFunctionapply_permutation
()
winterfell/crypto/src/hash/rescue/rp64_256/tests.rs:48
↓ 6 callersMethodblowup_factor
Returns trace blowup factor for a STARK proof. This is the factor by which the execution trace is extended during low-degree extension. It has a dire
winterfell/air/src/options.rs:181
↓ 6 callersFunctionbuild_prng
()
winterfell/air/src/air/tests.rs:327
↓ 6 callersFunctiondelete_file
(path: String)
circom-prover/src/utils.rs:217
↓ 6 callersMethodevaluate
Evaluates this constraint over the specified state and returns the result. This also applies composition coefficients as well as the degree adjustmen
winterfell/prover/src/constraints/boundary.rs:367
↓ 6 callersFunctiongroup_vector_elements
Transmutes a vector of `n` elements into a vector of `n` / `N` elements, each of which is an array of `N` elements. This function just re-interprets
winterfell/utils/core/src/lib.rs:461
↓ 6 callersMethodlayout
(&self)
winterfell/prover/src/trace/trace_table.rs:351
↓ 6 callersMethodlayout
Returns a description of how execution trace columns are arranged into segments. Currently, an execution trace can consist of at most two segments.
winterfell/air/src/air/trace_info.rs:110
↓ 6 callersMethodnum_rows
Returns the number of rows in this matrix.
winterfell/prover/src/matrix.rs:75
↓ 6 callersMethodread_u16
(&mut self)
winterfell/utils/core/src/lib.rs:239
↓ 6 callersMethodtrace_len
Returns length of the execution trace for an instance of a computation. This is guaranteed to be a power of two greater than or equal to 8.
winterfell/air/src/air/context.rs:169
↓ 6 callersMethodwrite_into
Serializes `self` and writes the resulting bytes into the `target`.
winterfell/air/src/proof/queries.rs:145
↓ 5 callersFunctionadd_192x192
(a0: u64, a1: u64, a2: u64, b0: u64, b1: u64, b2: u64)
winterfell/math/src/field/f128/mod.rs:592
↓ 5 callersFunctionalgorithm_1
(M, NUM_CELLS)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:254
↓ 5 callersFunctionalgorithm_1
(M, NUM_CELLS)
circuits/poseidon/generate_parameters_grain.sage.py:254
↓ 5 callersFunctionalgorithm_3
(M, NUM_CELLS)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:338
↓ 5 callersFunctionalgorithm_3
(M, NUM_CELLS)
circuits/poseidon/generate_parameters_grain.sage.py:338
↓ 5 callersFunctionbatch_inversion
Computes a multiplicative inverse of a sequence of elements using batch inversion method. Any ZEROs in the provided sequence are ignored. When `conc
winterfell/math/src/utils/mod.rs:177
↓ 5 callersMethodcc
Returns composition coefficients for this constraint.
winterfell/air/src/air/boundary/constraint.rs:111
↓ 5 callersMethodcurrent_mut
(&mut self)
winterfell/air/src/air/transition/frame.rs:67
↓ 5 callersMethoddomain_offset
Returns the offset by which the evaluation domain is shifted. The domain is shifted by multiplying every element in the domain by this offset. Curre
winterfell/fri/src/options.rs:58
↓ 5 callersMethodevaluate_at
EVALUATORS -------------------------------------------------------------------------------------------- Evaluates the divisor polynomial at the provid
winterfell/air/src/air/divisor.rs:130
↓ 5 callersFunctionevaluate_poly_with_offset
Evaluates a polynomial on all points of the specified (shifted) domain using the FFT algorithm. Uses the [FFT](https://en.wikipedia.org/wiki/Discrete
winterfell/math/src/fft/mod.rs:169
↓ 5 callersMethodfield_extension
Specifies whether composition polynomial should be constructed in an extension field of STARK protocol. Using a field extension increases maximum sec
winterfell/air/src/options.rs:211
↓ 5 callersMethodget_evaluation_degree
Computes a degree to which this degree description expands in the context of execution trace of the specified length. The expanded degree is computed
winterfell/air/src/air/transition/degree.rs:102
next →1–100 of 1,090, ranked by callers