Struct OpeningProof

pub struct OpeningProof<G: AffineRepr> {
    pub lr: Vec<(G, G)>,
    pub delta: G,
    pub z1: G::ScalarField,
    pub z2: G::ScalarField,
    pub sg: G,
}

Fields

lr: Vec<(G, G)>

Vector of rounds of L & R commitments

delta: G

z1: G::ScalarField

z2: G::ScalarField

sg: G

A final folded commitment base

Implementations

impl<G: AffineRepr> OpeningProof<G>

pub fn prechallenges<EFqSponge: FqSponge<G::BaseField, G, G::ScalarField>>( &self, sponge: &mut EFqSponge, ) -> Vec<ScalarChallenge<G::ScalarField>>

Computes a log-sized vector of scalar challenges for recombining elements inside the IPA.

pub fn challenges<EFqSponge: FqSponge<G::BaseField, G, G::ScalarField>>( &self, endo_r: &G::ScalarField, sponge: &mut EFqSponge, ) -> Challenges<G::ScalarField>

Same as prechallenges, but maps scalar challenges using the provided endomorphism, and computes their inverses.

Trait Implementations

impl<G: Clone + AffineRepr> Clone for OpeningProof<G>

where G::ScalarField: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug + AffineRepr> Debug for OpeningProof<G>

where G::ScalarField: Debug,

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

Formats the value using the given formatter.

impl<G: Default + AffineRepr> Default for OpeningProof<G>

where G::ScalarField: Default,

fn default() -> OpeningProof<G>

Returns the “default value” for a type.

impl<'de, G> Deserialize<'de> for OpeningProof<G>

where 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, CamlF, CamlG> From<CamlOpeningProof<CamlG, CamlF>> for OpeningProof<G>

where G: AffineRepr, CamlG: Into<G>, CamlF: Into<G::ScalarField>,

fn from(caml: CamlOpeningProof<CamlG, CamlF>) -> Self

Converts to this type from the input type.

impl<G, CamlF, CamlG> From<OpeningProof<G>> for CamlOpeningProof<CamlG, CamlF>

where G: AffineRepr, CamlG: From<G>, CamlF: From<G::ScalarField>,

fn from(opening_proof: OpeningProof<G>) -> Self

Converts to this type from the input type.

impl<BaseField: PrimeField, G: AffineRepr<BaseField = BaseField> + CommitmentCurve + EndoCurve> OpenProof<G> for OpeningProof<G>

type SRS = SRS<G>

fn open<EFqSponge, RNG, D: EvaluationDomain<<G as AffineRepr>::ScalarField>>( srs: &Self::SRS, group_map: &<G as CommitmentCurve>::Map, plnms: &'_ [(DensePolynomialOrEvaluations<'_, G::ScalarField, D>, PolyComm<G::ScalarField>)], elm: &[<G as AffineRepr>::ScalarField], polyscale: <G as AffineRepr>::ScalarField, evalscale: <G as AffineRepr>::ScalarField, sponge: EFqSponge, rng: &mut RNG, ) -> Self

where EFqSponge: Clone + FqSponge<<G as AffineRepr>::BaseField, G, <G as AffineRepr>::ScalarField>, RNG: RngCore + CryptoRng,

Create an opening proof for a batch of polynomials. The parameters are the following:

fn verify<EFqSponge, RNG>( srs: &Self::SRS, group_map: &G::Map, batch: &mut [BatchEvaluationProof<'_, G, EFqSponge, Self>], rng: &mut RNG, ) -> bool

where EFqSponge: FqSponge<<G as AffineRepr>::BaseField, G, <G as AffineRepr>::ScalarField>, RNG: RngCore + CryptoRng,

Verify the opening proof

impl<G: PartialEq + AffineRepr> PartialEq for OpeningProof<G>

where G::ScalarField: PartialEq,

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

Tests for self and other values to be equal, and is used by ==.

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

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

impl<G> Serialize for OpeningProof<G>

where 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> StructuralPartialEq for OpeningProof<G>