Struct ark_marlin::ahp::AHPForR1CS

pub struct AHPForR1CS<F: Field> { /* fields omitted */ }

The algebraic holographic proof defined in CHMMVW19. Currently, this AHP only supports inputs of size one less than a power of 2 (i.e., of the form 2^n - 1).

Implementations

impl<F: PrimeField> AHPForR1CS<F>

pub fn index<C: ConstraintSynthesizer<F>>(c: C) -> Result<Index<F>, Error>

Generate the index for this constraint system.

impl<F: PrimeField> AHPForR1CS<F>

pub fn prover_init<'a, C: ConstraintSynthesizer<F>>(
    index: &'a Index<F>,
    c: C
) -> Result<ProverState<'a, F>, Error>

Initialize the AHP prover.

pub fn prover_first_round<'a, R: RngCore>(
    state: ProverState<'a, F>,
    rng: &mut R
) -> Result<(ProverMsg<F>, ProverFirstOracles<F>, ProverState<'a, F>), Error>

Output the first round message and the next state.

pub fn prover_num_first_round_oracles() -> usize

Output the number of oracles sent by the prover in the first round.

pub fn prover_first_round_degree_bounds(
    _info: &IndexInfo<F>
) -> impl Iterator<Item = Option<usize>>

Output the degree bounds of oracles in the first round.

pub fn prover_second_round<'a, R: RngCore>(
    ver_message: &VerifierFirstMsg<F>,
    state: ProverState<'a, F>,
    _r: &mut R
) -> (ProverMsg<F>, ProverSecondOracles<F>, ProverState<'a, F>)

Output the second round message and the next state.

pub fn prover_num_second_round_oracles() -> usize

Output the number of oracles sent by the prover in the second round.

pub fn prover_second_round_degree_bounds(
    info: &IndexInfo<F>
) -> impl Iterator<Item = Option<usize>>

Output the degree bounds of oracles in the second round.

pub fn prover_third_round<'a, R: RngCore>(
    ver_message: &VerifierSecondMsg<F>,
    prover_state: ProverState<'a, F>,
    _r: &mut R
) -> Result<(ProverMsg<F>, ProverThirdOracles<F>), Error>

Output the third round message and the next state.

pub fn prover_num_third_round_oracles() -> usize

Output the number of oracles sent by the prover in the third round.

pub fn prover_third_round_degree_bounds(
    info: &IndexInfo<F>
) -> impl Iterator<Item = Option<usize>>

Output the degree bounds of oracles in the third round.

impl<F: PrimeField> AHPForR1CS<F>

pub fn verifier_first_round<R: RngCore>(
    index_info: IndexInfo<F>,
    rng: &mut R
) -> Result<(VerifierFirstMsg<F>, VerifierState<F>), Error>

Output the first message and next round state.

pub fn verifier_second_round<R: RngCore>(
    state: VerifierState<F>,
    rng: &mut R
) -> (VerifierSecondMsg<F>, VerifierState<F>)

Output the second message and next round state.

pub fn verifier_third_round<R: RngCore>(
    state: VerifierState<F>,
    rng: &mut R
) -> VerifierState<F>

Output the third message and next round state.

pub fn verifier_query_set<'a, R: RngCore>(
    state: VerifierState<F>,
    _: &'a mut R
) -> (QuerySet<F>, VerifierState<F>)

Output the query state and next round state.

impl<F: PrimeField> AHPForR1CS<F>

pub const INDEXER_POLYNOMIALS: [&'static str; 12]

The labels for the polynomials output by the AHP indexer.

pub const PROVER_POLYNOMIALS: [&'static str; 9]

The labels for the polynomials output by the AHP prover.

pub const LC_WITH_ZERO_EVAL: [&'static str; 2]

THe linear combinations that are statically known to evaluate to zero.

pub fn num_formatted_public_inputs_is_admissible(num_inputs: usize) -> bool

Check that the (formatted) public input is of the form 2^n for some integer n.

pub fn formatted_public_input_is_admissible(input: &[F]) -> bool

Check that the (formatted) public input is of the form 2^n for some integer n.

pub fn max_degree(
    num_constraints: usize,
    num_variables: usize,
    num_non_zero: usize
) -> Result<usize, Error>

The maximum degree of polynomials produced by the indexer and prover of this protocol. The number of the variables must include the “one” variable. That is, it must be with respect to the number of formatted public inputs.

pub fn get_degree_bounds(info: &IndexInfo<F>) -> [usize; 2]

Get all the strict degree bounds enforced in the AHP.

pub fn construct_linear_combinations<E>(
    public_input: &[F],
    evals: &E,
    state: &VerifierState<F>
) -> Result<Vec<LinearCombination<F>>, Error> where
    E: EvaluationsProvider<F>, 

Construct the linear combinations that are checked by the AHP.