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
↓ 5 callersMethodinv
(self)
winterfell/math/src/field/f64/mod.rs:98
↓ 5 callersMethodmain_constraints
Returns a reference to the boundary constraints against the main segment of an execution trace. The constraints are grouped by their divisors.
winterfell/air/src/air/boundary/mod.rs:136
↓ 5 callersMethodmain_trace_width
Returns the number of columns in the main segment of an execution trace. This is guaranteed to be between 1 and 255.
winterfell/air/src/air/trace_info.rs:239
↓ 5 callersMethodnext_mut
(&mut self)
winterfell/air/src/air/transition/frame.rs:79
↓ 5 callersMethodnum_queries
Returns number of queries for a STARK proof. This directly impacts proof soundness as each additional query adds roughly `log2(blowup_factor)` bits o
winterfell/air/src/options.rs:171
↓ 5 callersMethodpartial_cmp
(&self, other: &Self)
winterfell/air/src/air/assertions/mod.rs:325
↓ 5 callersFunctionpermute_index
(size: usize, index: usize)
winterfell/math/src/fft/mod.rs:598
↓ 5 callersFunctionprint_matrix
(name:str,M)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:496
↓ 5 callersMethodprove
Returns a Merkle path to a leaf at the specified `index`. The leaf itself will be the first element in the path. # Errors Returns an error if the sp
winterfell/crypto/src/merkle/mod.rs:160
↓ 5 callersMethodread_u32
(&mut self)
winterfell/utils/core/src/lib.rs:255
↓ 5 callersMethodtrace_to_lde_blowup
Returns blowup factor from trace to LDE domain.
winterfell/prover/src/domain.rs:62
↓ 5 callersMethodwrite_into
Serializes `self` and writes the resulting bytes into the `target` writer.
winterfell/fri/src/proof.rs:201
↓ 5 callersMethodwrite_u16
Writes a u16 value in little-endian byte order into `self`. # Panics Panics if the value could not be written into `self`.
winterfell/utils/core/src/lib.rs:357
↓ 4 callersFunctionadd_constants
(state: &mut [BaseElement; STATE_WIDTH], ark: &[BaseElement; STATE_WIDTH])
winterfell/crypto/src/hash/rescue/rp62_248/mod.rs:271
↓ 4 callersFunctionapply_inv_sbox
(state: &mut [BaseElement; STATE_WIDTH])
winterfell/crypto/src/hash/rescue/rp62_248/mod.rs:281
↓ 4 callersFunctionapply_mds
(state: &mut [BaseElement; STATE_WIDTH])
winterfell/crypto/src/hash/rescue/rp62_248/mod.rs:260
↓ 4 callersFunctionare_siblings
Two nodes are siblings if index of the left node is even and right node immediately follows the left node.
winterfell/crypto/src/merkle/proofs.rs:456
↓ 4 callersMethodas_bytes
(&self)
winterfell/crypto/src/hash/mod.rs:102
↓ 4 callersMethodaux_trace_width
Returns the number of columns in all auxiliary segments of an execution trace.
winterfell/air/src/air/trace_info.rs:244
↓ 4 callersFunctionbuild_domain
(size: usize)
winterfell/math/src/fft/tests.rs:75
↓ 4 callersMethodcolumn
Returns index of the column against which this assertion is placed.
winterfell/air/src/air/assertions/mod.rs:128
↓ 4 callersMethoddepth
Returns depth of the tree. The depth of a tree is zero-based. Thus, a tree with two leaves has depth 1, a tree with four leaves has depth 2 etc.
winterfell/crypto/src/merkle/mod.rs:141
↓ 4 callersMethoddouble
(self)
winterfell/math/src/field/traits.rs:96
↓ 4 callersMethoddraw_integers
Returns a vector of unique integers selected from the range [0, domain_size). # Errors Returns an error if the specified number of unique integers co
winterfell/crypto/src/random/mod.rs:252
↓ 4 callersFunctionelement_vec
(n: usize, f: &dyn Fn(usize) -> usize)
winterfell/crypto/src/hash/poseidon/tests.rs:121
↓ 4 callersFunctionelements_as_bytes
()
winterfell/math/src/field/f64/tests.rs:184
↓ 4 callersFunctioneval_many
Evaluates a polynomial at multiple points and returns a vector of results. Evaluates polynomial `p` at all coordinates in `xs` slice by repeatedly in
winterfell/math/src/polynom/mod.rs:80
↓ 4 callersMethodevaluate_columns_over
Evaluates polynomials contained in the columns of this matrix over the specified domain and returns the result. The evaluation is done as follows: Ea
winterfell/prover/src/matrix.rs:185
↓ 4 callersMethodfill
Fill all rows in the execution trace. The rows are filled by executing the provided closures as follows: - `init` closure is used to initialize the f
winterfell/prover/src/trace/trace_table.rs:230
↓ 4 callersFunctionget_inv_twiddles
Returns a set of inverse twiddles for the specified domain size. These twiddles can then be used for FFT-based polynomial interpolation. The length o
winterfell/math/src/fft/mod.rs:504
↓ 4 callersFunctionget_power_series_with_offset
Returns a vector containing successive powers of a given base offset by the specified value. More precisely, for base `b` and offset `s`, generates a
winterfell/math/src/utils/mod.rs:71
↓ 4 callersFunctioninterpolate
Returns a polynomial in coefficient form interpolated from a set of X and Y coordinates. Uses [Lagrange interpolation](https://en.wikipedia.org/wiki/
winterfell/math/src/polynom/mod.rs:112
↓ 4 callersFunctioninterpolate_poly_with_offset
Interpolates evaluations of a polynomial over the specified (shifted) domain into a polynomial in coefficient from using the FFT algorithm. Uses the
winterfell/math/src/fft/mod.rs:360
↓ 4 callersMethodis_multi_segment
Returns true if an execution trace contains more than one segment.
winterfell/air/src/air/trace_info.rs:134
↓ 4 callersMethodleading_zeros
Returns the number of leading zeros in the seed if it is interpreted as an integer in big-endian byte order. # Examples ``` # use winter_crypto::{Ran
winterfell/crypto/src/random/mod.rs:156
↓ 4 callersMethodmain_trace_width
Returns number of columns in the main segment of the execution trace.
winterfell/prover/src/trace/trace_lde.rs:49
↓ 4 callersMethodmin_blowup_factor
Returns a minimum blowup factor needed to evaluate constraint of this degree. This is guaranteed to be a power of two, greater than one.
winterfell/air/src/air/transition/degree.rs:113
↓ 4 callersMethodnum_aux_constraints
Returns the number of constraints applied against auxiliary trace segments of a computation.
winterfell/air/src/air/transition/mod.rs:130
↓ 4 callersMethodnum_fri_layers
Computes and return the number of FRI layers required for a domain of the specified size. The remainder layer (the last FRI layer) is not included in
winterfell/fri/src/options.rs:93
↓ 4 callersMethodnumerator
Returns the numerator portion of this constraint divisor.
winterfell/air/src/air/divisor.rs:108
↓ 4 callersFunctionpermute
(v: &mut [E])
winterfell/math/src/fft/concurrent.rs:95
↓ 4 callersMethodroot
Returns the root of the commitment Merkle tree.
winterfell/prover/src/constraints/commitment.rs:42
↓ 4 callersFunctionsplit_radix_fft
In-place recursive FFT with permuted output. Adapted from: https://github.com/0xProject/OpenZKP/tree/master/algebra/primefield/src/fft
winterfell/math/src/fft/concurrent.rs:123
↓ 4 callersMethodto_big_uint
(&self)
winterfell/math/src/field/f128/tests.rs:265
↓ 4 callersMethodto_fri_options
Returns options for FRI protocol instantiated with parameters from this proof options.
winterfell/air/src/options.rs:224
↓ 4 callersMethodto_paths
(&self, indexes: &[usize])
winterfell/crypto/src/merkle/proofs.rs:258
↓ 4 callersFunctionto_u256
(b)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:71
↓ 4 callersFunctionuninit_matrix
Allocates memory for a two-dimensional data structure without initializing it.
winterfell/prover/src/constraints/evaluation_table.rs:303
↓ 4 callersMethodupdate_row
Updates a single row in the execution trace with provided data.
winterfell/prover/src/trace/trace_table.rs:246
↓ 4 callersMethodwrite_u32
Writes a u32 value in little-endian byte order into `self`. # Panics Panics if the value could not be written into `self`.
winterfell/utils/core/src/lib.rs:365
↓ 3 callersFunctionadd_constants
(state: &mut [BaseElement], round: usize)
winterfell/crypto/src/hash/poseidon/poseidon.rs:90
↓ 3 callersFunctionapply_sbox
(state: &mut [BaseElement; STATE_WIDTH])
winterfell/crypto/src/hash/rescue/rp62_248/mod.rs:276
↓ 3 callersMethodas_elements
(&self)
winterfell/crypto/src/hash/rescue/rp62_248/digest.rs:22
↓ 3 callersMethodas_elements
(&self)
winterfell/crypto/src/hash/rescue/rp64_256/digest.rs:22
↓ 3 callersMethodaux_constraints
Returns a reference to the boundary constraints against auxiliary segments of an execution trace. The constraints are grouped by their divisors.
winterfell/air/src/air/boundary/mod.rs:142
↓ 3 callersFunctionbuild_constraint_params
HELPER FUNCTIONS ================================================================================================
winterfell/air/src/air/boundary/tests.rs:271
↓ 3 callersFunctionbuild_fib_trace
(length: usize)
winterfell/prover/src/tests/mod.rs:17
↓ 3 callersMethodbuild_layers
COMMIT PHASE -------------------------------------------------------------------------------------------- Executes the commit phase of the FRI protoco
winterfell/fri/src/prover/mod.rs:166
↓ 3 callersFunctioncanonicalize
(path: P)
circom-prover/src/utils.rs:125
↓ 3 callersMethodce_to_lde_blowup
Returns blowup factor from constraint evaluation to LDE domain.
winterfell/prover/src/domain.rs:80
↓ 3 callersMethodcomposition_degree
Returns the degree to which all constraint polynomials are normalized before they are composed together. This degree is always `ce_domain_size` - 1.
winterfell/air/src/air/context.rs:191
↓ 3 callersMethodconjugate
(&self)
winterfell/math/src/field/f64/mod.rs:128
↓ 3 callersFunctioncreate_mds_p
(n, t)
winterfell/crypto/src/hash/poseidon/generate_parameters_grain.sage.py:164
↓ 3 callersFunctioncreate_mds_p
(n, t)
circuits/poseidon/generate_parameters_grain.sage.py:164
↓ 3 callersMethoddegree
Returns degree descriptors for all constraints in this group.
winterfell/air/src/air/transition/mod.rs:239
↓ 3 callersMethodevaluate
LOW-DEGREE EXTENSION -------------------------------------------------------------------------------------------- Evaluates DEEP composition polynomia
winterfell/prover/src/composer/mod.rs:243
↓ 3 callersMethodevaluate_columns_at
Evaluates polynomials contained in the columns of this matrix at a single point `x`.
winterfell/prover/src/matrix.rs:200
↓ 3 callersFunctionevaluate_poly
Evaluates a polynomial on all points of the specified domain using the FFT algorithm. Uses the [FFT](https://en.wikipedia.org/wiki/Discrete_Fourier_t
winterfell/math/src/fft/mod.rs:83
↓ 3 callersFunctionflatten_slice_elements
Transmutes a slice of `n` arrays each of length `N`, into a slice of `N` * `n` elements. This function just re-interprets the underlying memory and i
winterfell/utils/core/src/lib.rs:514
↓ 3 callersMethodget_boundary_constraints
Convert assertions returned from [get_assertions()](Air::get_assertions) and [get_aux_assertions()](Air::get_aux_assertions) methods into boundary con
winterfell/air/src/air/mod.rs:365
↓ 3 callersMethodget_num_steps
Returns the number of steps against which this assertion will be applied given an execution trace of the specified length. For single-value assertion
winterfell/air/src/air/assertions/mod.rs:290
↓ 3 callersMethodget_row
(&self, ce_step: usize)
winterfell/prover/src/constraints/periodic_table.rs:84
↓ 3 callersFunctionget_twiddles
Returns a set of twiddles for the specified domain size. These twiddles can then be used for FFT-based polynomial evaluation. The length of the retur
winterfell/math/src/fft/mod.rs:464
↓ 3 callersMethodgrinding_factor
Returns query seed grinding factor for a STARK proof. Grinding applies Proof-of-Work/ to the query position seed. An honest prover needs to perform t
winterfell/air/src/options.rs:192
↓ 3 callersMethodinterpolate_columns
Interpolates columns of the matrix into polynomials in coefficient form and returns the result. The interpolation is performed as follows: Each colum
winterfell/prover/src/matrix.rs:151
↓ 3 callersMethodis_periodic
Returns true if this is a periodic assertion (one value, many steps).
winterfell/air/src/air/assertions/mod.rs:159
↓ 3 callersMethodmain_segment
(&self)
winterfell/prover/src/trace/trace_table.rs:369
↓ 3 callersFunctionmake_fragments
Breaks the source data into a mutable set of fragments such that each fragment has the same number of columns as the source data, and the number of ro
winterfell/prover/src/constraints/evaluation_table.rs:313
↓ 3 callersFunctionmap_indexes
( indexes: &[usize], tree_depth: usize, )
winterfell/crypto/src/merkle/mod.rs:342
↓ 3 callersFunctionmul
()
winterfell/math/src/polynom/tests.rs:107
↓ 3 callersFunctionnormalize
(value: u64)
winterfell/math/src/field/f62/mod.rs:582
↓ 3 callersMethodnum_main_constraints
Returns the number of constraints applied against the main trace segment of a computation.
winterfell/air/src/air/transition/mod.rs:109
↓ 3 callersMethodnum_segments
Returns the total number of segments in an execution trace.
winterfell/air/src/air/trace_info.rs:249
↓ 3 callersFunctionpermute
(v: &mut [E])
winterfell/math/src/fft/mod.rs:589
↓ 3 callersFunctionprepare_assertions
()
winterfell/air/src/air/boundary/tests.rs:198
↓ 3 callersMethodreseed_with_int
Reseeds the coin with the specified value by setting the new seed to hash(`seed` || `value`). # Examples ``` # use winter_crypto::{RandomCoin, Hasher
winterfell/crypto/src/random/mod.rs:131
↓ 3 callersFunctionsub_192x192
(a0: u64, a1: u64, a2: u64, b0: u64, b1: u64, b2: u64)
winterfell/math/src/field/f128/mod.rs:584
↓ 3 callersFunctionsub_modulus
(a_lo: u64, a_hi: u64)
winterfell/math/src/field/f128/mod.rs:576
↓ 3 callersFunctionsyn_div_in_place
Divides a polynomial by a polynomial of special form and saves the result into the original polynomial. Specifically, divides polynomial `p` by polyn
winterfell/math/src/polynom/mod.rs:524
↓ 3 callersMethodto_bytes
Serializes this proof into a vector of bytes.
winterfell/air/src/proof/mod.rs:122
↓ 3 callersMethodtrace_len
Returns the number of rows in the execution trace.
winterfell/prover/src/trace/trace_lde.rs:61
↓ 3 callersMethodvalidate_trace_length
Checks if the assertion is valid against an execution trace of the specified length. # Errors Returns an error if: `trace_length` is not a power of t
winterfell/air/src/air/assertions/mod.rs:225
↓ 3 callersFunctionverify_batch
()
winterfell/crypto/src/merkle/tests.rs:214
↓ 3 callersMethodwidth
Returns the total number of columns in an execution trace. This is guaranteed to be between 1 and 255.
winterfell/air/src/air/trace_info.rs:117
↓ 3 callersMethodwrite_into
(&self, _target: &mut W)
winterfell/utils/core/src/lib.rs:76
↓ 3 callersMethodwrite_into
(&self, target: &mut W)
winterfell/utils/core/src/tests.rs:95
↓ 3 callersMethodwrite_u8_slice
(&mut self, values: &[u8])
winterfell/crypto/src/hash/sha/mod.rs:78
↓ 2 callersFunctionadd64_with_carry
(a: u64, b: u64, carry: u64)
winterfell/math/src/field/f128/mod.rs:600
↓ 2 callersMethodadd_aux_constraints
Adds the provided constraints against auxiliary segments of an execution trace to this group. Twiddles and [Air] instance are passed in for evaluatin
winterfell/prover/src/constraints/boundary.rs:243
↓ 2 callersMethodadd_aux_segment
Adds the provided auxiliary segment LDE to this trace LDE.
winterfell/prover/src/trace/trace_lde.rs:36
← previousnext →101–200 of 1,090, ranked by callers