triple_ipa_claim.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
 
#include "barretenberg/commitment_schemes/claim.hpp"
#include "barretenberg/commitment_schemes/claim_batcher.hpp"
#include "barretenberg/common/assert.hpp"
#include "barretenberg/polynomials/polynomial.hpp"
 
#include <cstddef>
#include <span>
#include <vector>
 
namespace bb {
 
template <typename Curve> struct TripleIpaClaim {
    using Fr = typename Curve::ScalarField;
    using Commitment = typename Curve::AffineElement;
 
    Commitment unshifted_commitment;
    Fr unshifted_evaluation = Fr::zero();
    Commitment shifted_commitment;
    Fr shifted_evaluation = Fr::zero();
    OpeningClaim<Curve> univariate;
    std::vector<Fr> multilinear_challenge;
};
 
template <typename Curve> struct TripleIpaClaimData {
    using Fr = typename Curve::ScalarField;
    using Commitment = typename Curve::AffineElement;
 
    struct UnshiftedClaim {
        std::vector<Commitment> commitments;
        std::vector<Fr> evaluations;
        std::vector<Fr> rho_powers;
        std::vector<Fr> multilinear_challenge;
    };
 
    struct ShiftedBatch {
        std::vector<Commitment> commitments;          // source commitments (the flavor's get_to_be_shifted set)
        std::vector<Fr> source_unshifted_evaluations; // sources' unshifted evals at u; used for the <F',eq> cross-sum
        std::vector<Fr> shifted_evaluations;          // the shifted evals at u (the diagonal shift claim)
        std::vector<Fr> rho_powers;
    };
 
    UnshiftedClaim unshifted;
    ShiftedBatch shifted;
    OpeningClaim<Curve> univariate;
 
    static std::vector<Fr> rho_powers(const Fr& rho, size_t count, size_t offset = 0)
    {
        std::vector<Fr> powers;
        powers.reserve(count);
        Fr power = Fr::one();
        for (size_t idx = 0; idx < offset; ++idx) {
            power *= rho;
        }
        for (size_t idx = 0; idx < count; ++idx) {
            powers.emplace_back(power);
            power *= rho;
        }
        return powers;
    }
 
    template <typename CommitmentRange,
              typename EvaluationRange,
              typename ShiftedCommitmentRange,
              typename ShiftedSourceEvaluationRange,
              typename ShiftedEvaluationRange>
    static TripleIpaClaimData create(const CommitmentRange& unshifted_commitments,
                                     const EvaluationRange& unshifted_evaluations,
                                     const ShiftedCommitmentRange& shifted_source_commitments,
                                     const ShiftedSourceEvaluationRange& shifted_source_evaluations,
                                     const ShiftedEvaluationRange& shifted_evaluations,
                                     std::span<const Fr> multilinear_challenge,
                                     const Fr& rho,
                                     const OpeningClaim<Curve>& univariate)
    {
        const size_t num_unshifted = unshifted_commitments.size();
        BB_ASSERT_EQ(num_unshifted, unshifted_evaluations.size());
        const size_t num_shifted = shifted_evaluations.size();
        BB_ASSERT_EQ(num_shifted, shifted_source_commitments.size());
        BB_ASSERT_EQ(num_shifted, shifted_source_evaluations.size());
 
        TripleIpaClaimData data;
        data.unshifted.multilinear_challenge.assign(multilinear_challenge.begin(), multilinear_challenge.end());
        data.unshifted.commitments.reserve(num_unshifted);
        data.unshifted.evaluations.reserve(num_unshifted);
        for (size_t idx = 0; idx < num_unshifted; ++idx) {
            data.unshifted.commitments.emplace_back(unshifted_commitments[idx]);
            data.unshifted.evaluations.emplace_back(unshifted_evaluations[idx]);
        }
        data.unshifted.rho_powers = rho_powers(rho, num_unshifted);
 
        data.shifted.commitments.reserve(num_shifted);
        data.shifted.source_unshifted_evaluations.reserve(num_shifted);
        data.shifted.shifted_evaluations.reserve(num_shifted);
        for (size_t idx = 0; idx < num_shifted; ++idx) {
            data.shifted.commitments.emplace_back(shifted_source_commitments[idx]);
            data.shifted.source_unshifted_evaluations.emplace_back(shifted_source_evaluations[idx]);
            data.shifted.shifted_evaluations.emplace_back(shifted_evaluations[idx]);
        }
        data.shifted.rho_powers = rho_powers(rho, num_shifted, num_unshifted);
 
        data.univariate = univariate;
        return data;
    }
 
    TripleIpaClaim<Curve> batch() const
    {
        TripleIpaClaim<Curve> claim;
        claim.unshifted_commitment = batch_commitments<Curve>(std::span<const Commitment>(unshifted.commitments),
                                                              std::span<const Fr>(unshifted.rho_powers));
        claim.unshifted_evaluation = batch_evaluations<Curve>(std::span<const Fr>(unshifted.evaluations),
                                                              std::span<const Fr>(unshifted.rho_powers));
 
        claim.shifted_commitment = batch_commitments<Curve>(std::span<const Commitment>(shifted.commitments),
                                                            std::span<const Fr>(shifted.rho_powers));
        claim.shifted_evaluation = batch_evaluations<Curve>(std::span<const Fr>(shifted.shifted_evaluations),
                                                            std::span<const Fr>(shifted.rho_powers));
 
        claim.univariate = univariate;
        claim.multilinear_challenge = unshifted.multilinear_challenge;
        return claim;
    }
};
 
template <typename Curve> struct TripleIpaInput {
    using Fr = typename Curve::ScalarField;
    using Polynomial = bb::Polynomial<Fr>;
 
    TripleIpaClaimData<Curve> claim_data;
    std::vector<Polynomial> unshifted_polynomials;
    std::vector<Polynomial> shifted_polynomials; // source polys for the shift claim (the get_to_be_shifted set)
    Polynomial univariate_polynomial;
};
 
} // namespace bb