Struct kimchi::proof::ProverProof

pub struct ProverProof<G: AffineRepr, OpeningProof> {
    pub commitments: ProverCommitments<G>,
    pub proof: OpeningProof,
    pub evals: ProofEvaluations<PointEvaluations<Vec<G::ScalarField>>>,
    pub ft_eval1: G::ScalarField,
    pub prev_challenges: Vec<RecursionChallenge<G>>,
}

The proof that the prover creates from a ProverIndex and a witness.

Fields

commitments: ProverCommitments<G>

All the polynomial commitments required in the proof

proof: OpeningProof

batched commitment opening proof

evals: ProofEvaluations<PointEvaluations<Vec<G::ScalarField>>>

Two evaluations over a number of committed polynomials

ft_eval1: G::ScalarField

Required evaluation for Maller’s optimization

prev_challenges: Vec<RecursionChallenge<G>>

The challenges underlying the optional polynomials folded into the proof

Implementations

impl<G: KimchiCurve, OpeningProof: OpenProof<G>> ProverProof<G, OpeningProof>where G::BaseField: PrimeField,

pub fn create<EFqSponge: Clone + FqSponge<G::BaseField, G, G::ScalarField>, EFrSponge: FrSponge<G::ScalarField>, RNG: RngCore + CryptoRng>( groupmap: &G::Map, witness: [Vec<G::ScalarField>; 15], runtime_tables: &[RuntimeTable<G::ScalarField>], index: &ProverIndex<G, OpeningProof>, rng: &mut RNG ) -> Result<Self, ProverError>where VerifierIndex<G, OpeningProof>: Clone,

This function constructs prover’s zk-proof from the witness & the ProverIndex against SRS instance

Errors

Will give error if create_recursive process fails.

pub fn create_recursive<EFqSponge: Clone + FqSponge<G::BaseField, G, G::ScalarField>, EFrSponge: FrSponge<G::ScalarField>, RNG: RngCore + CryptoRng>( group_map: &G::Map, witness: [Vec<G::ScalarField>; 15], runtime_tables: &[RuntimeTable<G::ScalarField>], index: &ProverIndex<G, OpeningProof>, prev_challenges: Vec<RecursionChallenge<G>>, blinders: Option<[Option<PolyComm<G::ScalarField>>; 15]>, rng: &mut RNG ) -> Result<Self, ProverError>where VerifierIndex<G, OpeningProof>: Clone,

This function constructs prover’s recursive zk-proof from the witness & the ProverIndex against SRS instance

Errors

Will give error if inputs(like lookup_context.joint_lookup_table_d8) are None.

Panics

Will panic if lookup_context.joint_lookup_table_d8 is None.

impl<G: KimchiCurve, OpeningProof: OpenProof<G>> ProverProof<G, OpeningProof>where G::BaseField: PrimeField,

pub fn oracles<EFqSponge: Clone + FqSponge<G::BaseField, G, G::ScalarField>, EFrSponge: FrSponge<G::ScalarField>>( &self, index: &VerifierIndex<G, OpeningProof>, public_comm: &PolyComm<G>, public_input: Option<&[G::ScalarField]> ) -> Result<OraclesResult<G, EFqSponge>>

This function runs the random oracle argument

Errors

Will give error if commitment(s) are invalid(missing or wrong length), or proof is verified as invalid.

Panics

Will panic if PolishToken evaluation is invalid.

Trait Implementations

impl<G: Clone + AffineRepr, OpeningProof: Clone> Clone for ProverProof<G, OpeningProof>where G::ScalarField: Clone,

fn clone(&self) -> ProverProof<G, OpeningProof>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<G: Debug + AffineRepr, OpeningProof: Debug> Debug for ProverProof<G, OpeningProof>where G::ScalarField: Debug,

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de, G, OpeningProof> Deserialize<'de> for ProverProof<G, OpeningProof>where OpeningProof: Deserialize<'de>, G: CanonicalDeserialize + CanonicalSerialize + AffineRepr,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G: PartialEq + AffineRepr, OpeningProof: PartialEq> PartialEq<ProverProof<G, OpeningProof>> for ProverProof<G, OpeningProof>where G::ScalarField: PartialEq,

fn eq(&self, other: &ProverProof<G, OpeningProof>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<G, OpeningProof> Serialize for ProverProof<G, OpeningProof>where OpeningProof: Serialize, G: CanonicalDeserialize + CanonicalSerialize + AffineRepr,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<G: AffineRepr, OpeningProof> StructuralPartialEq for ProverProof<G, OpeningProof>