Struct ProverIndex

pub struct ProverIndex<G: KimchiCurve, OpeningProof: OpenProof<G>> {
    pub cs: Arc<ConstraintSystem<G::ScalarField>>,
    pub linearization: Linearization<Vec<PolishToken<G::ScalarField, Column, BerkeleyChallengeTerm>>, Column>,
    pub powers_of_alpha: Alphas<G::ScalarField>,
    pub srs: Arc<OpeningProof::SRS>,
    pub max_poly_size: usize,
    pub column_evaluations: Arc<LazyCache<ColumnEvaluations<G::ScalarField>>>,
    pub verifier_index: Option<VerifierIndex<G, OpeningProof>>,
    pub verifier_index_digest: Option<G::BaseField>,
}

The index used by the prover

Fields

cs: Arc<ConstraintSystem<G::ScalarField>>

constraints system polynomials

linearization: Linearization<Vec<PolishToken<G::ScalarField, Column, BerkeleyChallengeTerm>>, Column>

The symbolic linearization of our circuit, which can compile to concrete types once certain values are learned in the protocol.

powers_of_alpha: Alphas<G::ScalarField>

The mapping between powers of alpha and constraints

srs: Arc<OpeningProof::SRS>

polynomial commitment keys

max_poly_size: usize

maximal size of polynomial section

column_evaluations: Arc<LazyCache<ColumnEvaluations<G::ScalarField>>>

verifier_index: Option<VerifierIndex<G, OpeningProof>>

The verifier index corresponding to this prover index

verifier_index_digest: Option<G::BaseField>

The verifier index digest corresponding to this prover index

Implementations

impl<F: PrimeField, G: KimchiCurve<ScalarField = F>, OpeningProof: OpenProof<G>> ProverIndex<G, OpeningProof>

pub fn verify( &self, witness: &[Vec<F>; 15], public: &[F], ) -> Result<(), GateError>

This function verifies the consistency of the wire assignments (witness) against the constraints witness: wire assignment witness RETURN: verification status

impl<F: PrimeField, G: KimchiCurve<ScalarField = F>, OpeningProof: OpenProof<G>> ProverIndex<G, OpeningProof>

pub fn verify_generic( &mut self, witness: &[DensePolynomial<F>; 15], public: &DensePolynomial<F>, ) -> bool

Function to verify the generic polynomials with a witness.

impl<F: PrimeField, G: KimchiCurve<ScalarField = F>, OpeningProof: OpenProof<G>> ProverIndex<G, OpeningProof>

pub fn perm_quot( &self, lagrange: &WitnessOverDomains<F>, beta: F, gamma: F, z: &DensePolynomial<F>, alphas: impl Iterator<Item = F>, ) -> Result<(Evaluations<F, D<F>>, DensePolynomial<F>), ProverError>

permutation quotient poly contribution computation

Errors

Will give error if polynomial division fails.

Panics

Will panic if power of alpha is missing.

pub fn perm_lnrz( &self, e: &ProofEvaluations<PointEvaluations<F>>, zeta: F, beta: F, gamma: F, alphas: impl Iterator<Item = F>, ) -> Evaluations<F, D<F>>

permutation linearization poly contribution computation

impl<F: PrimeField, G: KimchiCurve<ScalarField = F>, OpeningProof: OpenProof<G>> ProverIndex<G, OpeningProof>

pub fn perm_aggreg( &self, witness: &[Vec<F>; 15], beta: &F, gamma: &F, rng: &mut (impl RngCore + CryptoRng), ) -> Result<DensePolynomial<F>, ProverError>

permutation aggregation polynomial computation

Errors

Will give error if permutation result is not correct.

Panics

Will panic if first element is not 1.

impl<G: KimchiCurve, OpeningProof: OpenProof<G>> ProverIndex<G, OpeningProof>

where G::BaseField: PrimeField,

pub fn create( cs: ConstraintSystem<G::ScalarField>, endo_q: G::ScalarField, srs: Arc<OpeningProof::SRS>, lazy_mode: bool, ) -> Self

this function compiles the index from constraints

pub fn compute_verifier_index_digest<EFqSponge: Clone + FqSponge<G::BaseField, G, G::ScalarField>>( &mut self, ) -> G::BaseField

where VerifierIndex<G, OpeningProof>: Clone,

Retrieve or compute the digest for the corresponding verifier index. If the digest is not already cached inside the index, store it.

pub fn verifier_index_digest<EFqSponge: Clone + FqSponge<G::BaseField, G, G::ScalarField>>( &self, ) -> G::BaseField

where VerifierIndex<G, OpeningProof>: Clone,

Retrieve or compute the digest for the corresponding verifier index.

impl<G: KimchiCurve, OpeningProof: OpenProof<G>> ProverIndex<G, OpeningProof>

where G::BaseField: PrimeField,

pub fn verifier_index(&self) -> VerifierIndex<G, OpeningProof>

where VerifierIndex<G, OpeningProof>: Clone,

Produces the VerifierIndex from the prover’s ProverIndex.

Panics

Will panic if srs cannot be in cell.

Trait Implementations

impl<G: Clone + KimchiCurve, OpeningProof: Clone + OpenProof<G>> Clone for ProverIndex<G, OpeningProof>

where G::ScalarField: Clone, OpeningProof::SRS: Clone, G::BaseField: Clone,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<G: Debug + KimchiCurve, OpeningProof: Debug + OpenProof<G>> Debug for ProverIndex<G, OpeningProof>

where G::ScalarField: Debug, OpeningProof::SRS: Debug, G::BaseField: Debug,

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

Formats the value using the given formatter.

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

where ConstraintSystem<G::ScalarField>: Serialize + DeserializeOwned, OpeningProof::SRS: Default, ColumnEvaluations<G::ScalarField>: Serialize + DeserializeOwned, G: Default + KimchiCurve, OpeningProof: Default + OpenProof<G>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<G: KimchiCurve, OpeningProof: OpenProof<G>> Serialize for ProverIndex<G, OpeningProof>

where ConstraintSystem<G::ScalarField>: Serialize + DeserializeOwned, ColumnEvaluations<G::ScalarField>: Serialize + DeserializeOwned,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.