Method batch_check

poly-commit/src/lib.rs:373–441

Verify opening proofs for several polynomials at one or more points each (possibly different for each polynomial). Each entry in the query set of points contains the label of the polynomial which was queried at that point. Behaviour is undefined if `query_set` contains the entries with the same point label but different points. Behaviour is also undefined if proofs are not ordered the same way a

(
        vk: &Self::VerifierKey,
        commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
        query_set: &QuerySet<P::Point>,
        evaluations: &Evaluations<P::P

    ///
    /// The opening challenges are independent for each batch of polynomials.
    fn batch_check<'a, R: RngCore>(
        vk: &Self::VerifierKey,
        commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitment>>,
        query_set: &QuerySet<P::Point>,
        evaluations: &Evaluations<P::Point, F>,
        proof: &Self::BatchProof,
        sponge: &mut impl CryptographicSponge,
        rng: &mut R,
    ) -> Result<bool, Self::Error>
    where
        Self::Commitment: 'a,
    {
        // The default implementation proceeds by rearranging the queries in
        // order to gather (i.e. batch) the proofs of all polynomials that should
        // have been opened at the same point, then verifying those proofs
        // simultaneously with a single call to `check` (per point).
        let commitments: BTreeMap<_, _> = commitments.into_iter().map(|c| (c.label(), c)).collect();
        let mut query_to_labels_map = BTreeMap::new();

        // `label` is the label of the polynomial the query refers to
        // `point_label` is the label of the point being queried
        // `point` is the actual point
        for (label, (point_label, point)) in query_set.iter() {
            // For each point label in `query_set`, we define an entry in
            // `query_to_labels_map` containing a pair whose first element is
            // the actual point and the second one is the set of labels of the
            // polynomials being queried at that point
            let labels = query_to_labels_map
                .entry(point_label)
                .or_insert((point, BTreeSet::new()));
            labels.1.insert(label);
        }

        // Implicit assumption: proofs are ordered in same manner as queries in
        // `query_to_labels_map`.
        let proofs: Vec<_> = proof.clone().into();
        assert_eq!(proofs.len(), query_to_labels_map.len());

        let mut result = true;
        for ((_point_label, (point, labels)), proof) in query_to_labels_map.into_iter().zip(proofs)
        {
            // Constructing matching vectors with the commitment and claimed
            // value of each polynomial being queried at `point`
            let mut comms: Vec<&'_ LabeledCommitment<_>> = Vec::new();
            let mut values = Vec::new();
            for label in labels.into_iter() {
                let commitment = commitments.get(label).ok_or(Error::MissingPolynomial {
                    label: label.to_string(),
                })?;

                let v_i = evaluations.get(&(label.clone(), point.clone())).ok_or(
                    Error::MissingEvaluation {
                        label: label.to_string(),
                    },
                )?;

                comms.push(commitment);
                values.push(*v_i);