Method batch_open

poly-commit/src/lib.rs:269–358

Open several polynomials at one or more points each (possibly different for each polynomial). Each entry in the in the query set of points contains the label of the polynomial which should be queried at that point. Behaviour is undefined if `query_set` contains the entries with the same point label but different actual points. The opening challenges are independent for each batch of polynomials.

(
        ck: &Self::CommitterKey,
        labeled_polynomials: impl IntoIterator<Item = &'a LabeledPolynomial<F, P>>,
        commitments: impl IntoIterator<Item = &'a LabeledCommitment<Self::Commitm

    ///
    /// The opening challenges are independent for each batch of polynomials.
    fn batch_open<'a>(
        ck: &Self::CommitterKey,
        labeled_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<Self::BatchProof, Self::Error>
    where
        P: 'a,
        Self::CommitmentState: 'a,
        Self::Commitment: 'a,
    {
        // The default implementation achieves proceeds by rearranging the queries in
        // order to gather (i.e. batch) all polynomials that should be queried at
        // the same point, then opening their commitments simultaneously with a
        // single call to `open` (per point)
        let rng = &mut optional_rng::OptionalRng(rng);
        let poly_st_comm: BTreeMap<_, _> = labeled_polynomials
            .into_iter()
            .zip(states)
            .zip(commitments.into_iter())
            .map(|((poly, st), comm)| (poly.label(), (poly, st, comm)))
            .collect();

        let open_time = start_timer!(|| format!(
            "Opening {} polynomials at query set of size {}",
            poly_st_comm.len(),
            query_set.len(),
        ));

        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);
        }

        let mut proofs = Vec::new();
        for (_point_label, (point, labels)) in query_to_labels_map.into_iter() {
            let mut query_polys: Vec<&'a LabeledPolynomial<_, _>> = Vec::new();
            let mut query_states: Vec<&'a Self::CommitmentState> = Vec::new();
            let mut query_comms: Vec<&'a LabeledCommitment<Self::Commitment>> = Vec::new();

            // Constructing matching vectors with the polynomial, commitment
            // randomness and actual commitment for each polynomial being
            // queried at `point`
            for label in labels {