Method accumulate_elems

poly-commit/src/sonic_pc/mod.rs:39–92

(
        combined_comms: &mut BTreeMap<Option<usize>, E::G1>,
        combined_witness: &mut E::G1,
        combined_adjusted_witness: &mut E::G1,
        vk: &VerifierKey<E>,
        commitments: im

    P: DenseUVPolynomial<E::ScalarField>,
{
    fn accumulate_elems<'a>(
        combined_comms: &mut BTreeMap<Option<usize>, E::G1>,
        combined_witness: &mut E::G1,
        combined_adjusted_witness: &mut E::G1,
        vk: &VerifierKey<E>,
        commitments: impl IntoIterator<Item = &'a LabeledCommitment<Commitment<E>>>,
        point: P::Point,
        values: impl IntoIterator<Item = E::ScalarField>,
        proof: &kzg10::Proof<E>,
        sponge: &mut impl CryptographicSponge,
        randomizer: Option<E::ScalarField>,
    ) {
        let acc_time = start_timer!(|| "Accumulating elements");

        let mut curr_challenge = sponge.squeeze_field_elements_with_sizes(&[CHALLENGE_SIZE])[0];

        // Keeps track of running combination of values
        let mut combined_values = E::ScalarField::zero();

        // Iterates through all of the commitments and accumulates common degree_bound elements in a BTreeMap
        for (labeled_comm, value) in commitments.into_iter().zip(values) {
            combined_values += &(value * &curr_challenge);

            let comm = labeled_comm.commitment();
            let degree_bound = labeled_comm.degree_bound();

            // Applying opening challenge and randomness (used in batch_checking)
            let mut comm_with_challenge: E::G1 = comm.0.mul(curr_challenge);

            if let Some(randomizer) = randomizer {
                comm_with_challenge = comm_with_challenge.mul(&randomizer);
            }

            // Accumulate values in the BTreeMap
            *combined_comms.entry(degree_bound).or_insert(E::G1::zero()) += &comm_with_challenge;
            curr_challenge = sponge.squeeze_field_elements_with_sizes(&[CHALLENGE_SIZE])[0];
        }

        // Push expected results into list of elems. Power will be the negative of the expected power
        let mut witness: E::G1 = proof.w.into_group();
        let mut adjusted_witness = vk.g.mul(combined_values) - &proof.w.mul(point);
        if let Some(random_v) = proof.random_v {
            adjusted_witness += &vk.gamma_g.mul(random_v);
        }

        if let Some(randomizer) = randomizer {
            witness = proof.w.mul(randomizer);
            adjusted_witness = adjusted_witness.mul(&randomizer);
        }

        *combined_witness += &witness;
        *combined_adjusted_witness += &adjusted_witness;
        end_timer!(acc_time);
    }

    fn check_elems(
        combined_comms: BTreeMap<Option<usize>, E::G1>,