Method open_combinations

poly-commit/src/lib.rs:445–485

Open commitments to all polynomials involved in a number of linear combinations (LC) simultaneously.

(
        ck: &Self::CommitterKey,
        linear_combinations: impl IntoIterator<Item = &'a LinearCombination<F>>,
        polynomials: impl IntoIterator<Item = &'a LabeledPolynomial<F, P>>,
        

    /// Open commitments to all polynomials involved in a number of linear
    /// combinations (LC) simultaneously.
    fn open_combinations<'a>(
        ck: &Self::CommitterKey,
        linear_combinations: impl IntoIterator<Item = &'a LinearCombination<F>>,
        polynomials: impl IntoIterator<Item = &'a LabeledPolynomial<F, P>>,
        commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
        query_set: &QuerySet<P::Point>,
        sponge: &mut impl CryptographicSponge,
        states: impl IntoIterator<Item = &'a Self::CommitmentState>,
        rng: Option<&mut dyn RngCore>,
    ) -> Result<BatchLCProof<F, Self::BatchProof>, Self::Error>
    where
        Self::CommitmentState: 'a,
        Self::Commitment: 'a,
        P: 'a,
    {
        // The default implementation proceeds by batch-opening all polynomials
        // appearing in those LC that are queried at the same point.
        let linear_combinations: Vec<_> = linear_combinations.into_iter().collect();
        let polynomials: Vec<_> = polynomials.into_iter().collect();

        // Rearrange the information about queries on linear combinations into
        // information about queries on individual polynomials.
        let poly_query_set =
            lc_query_set_to_poly_query_set(linear_combinations.iter().copied(), query_set);
        let poly_evals = evaluate_query_set(polynomials.iter().copied(), &poly_query_set);

        // Batch-open all polynomials that refer to each individual point in `query_set`
        let proof = Self::batch_open(
            ck,
            polynomials,
            commitments,
            &poly_query_set,
            sponge,
            states,
            rng,
        )?;
        Ok(BatchLCProof {
            proof,
            evals: Some(poly_evals.values().copied().collect()),
        })
    }

    /// Verify opening proofs for all polynomials involved in a number of
    /// linear combinations (LC) simultaneously.