multilinear_batching_verifier.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/flavor/multilinear_batching_flavor.hpp"
#include "barretenberg/multilinear_batching/multilinear_batching_claims.hpp"
#include "barretenberg/stdlib/proof/proof.hpp"
#include "barretenberg/sumcheck/sumcheck.hpp"
 
#include <span>
#include <utility>
 
namespace bb {
 
template <typename Flavor_> class MultilinearBatchingVerifierInternal {
  public:
    using Flavor = Flavor_;
    using FF = typename Flavor::FF;
    using Curve = typename Flavor::Curve;
    using Commitment = typename Flavor::Commitment;
    using Transcript = typename Flavor::Transcript;
    using Sumcheck = SumcheckVerifier<Flavor>;
    using VerifierClaim = MultilinearBatchingVerifierClaim<Curve>;
    using Proof = std::conditional_t<Curve::is_stdlib_type, stdlib::Proof<MegaCircuitBuilder>, HonkProof>;
 
    static constexpr size_t NUM_CLAIMS = Flavor::NUM_CLAIMS;
    static constexpr bool IsRecursive = Curve::is_stdlib_type;
 
    explicit MultilinearBatchingVerifierInternal(const std::shared_ptr<Transcript>& transcript);
 
    // The batching sumcheck is read from the shared transcript; the caller is responsible for loading the proof onto it
    // beforehand (in HyperNova folding it is already loaded by the instance sumcheck; in the kernel path the kernel
    // loads the separate batching proof).
    std::pair<bool, VerifierClaim> verify_proof(const std::vector<VerifierClaim>& claims);
 
  private:
    std::shared_ptr<Transcript> transcript;
 
    FF compute_target_sum(const FF& alpha, const std::vector<VerifierClaim>& claims, std::span<const FF> scalars) const;
 
    VerifierClaim compute_new_claim(const SumcheckOutput<Flavor>& sumcheck_result,
                                    const std::vector<VerifierClaim>& claims,
                                    std::vector<FF> scalars);
 
    bool check_eq_consistency(const SumcheckOutput<Flavor>& sumcheck_result, const std::vector<VerifierClaim>& claims);
};
 
template <bool IsRecursive_> class MultilinearBatchingVerifier {
  public:
    using BaseFlavor = std::conditional_t<IsRecursive_, MultilinearBatchingRecursiveFlavor, MultilinearBatchingFlavor>;
    using Curve = typename BaseFlavor::Curve;
    using Transcript = typename BaseFlavor::Transcript;
    using VerifierClaim = MultilinearBatchingVerifierClaim<Curve>;
    using Proof = std::conditional_t<Curve::is_stdlib_type, stdlib::Proof<MegaCircuitBuilder>, HonkProof>;
 
    static constexpr bool IsRecursive = IsRecursive_;
 
    explicit MultilinearBatchingVerifier(const std::shared_ptr<Transcript>& transcript);
 
    // The batching proof must already be loaded onto the shared transcript by the caller (see the internal verifier).
    std::pair<bool, VerifierClaim> verify_proof(const std::vector<VerifierClaim>& claims);
 
  private:
    template <size_t NumClaims>
    std::pair<bool, VerifierClaim> verify_with_width(const std::vector<VerifierClaim>& claims);
 
    std::shared_ptr<Transcript> transcript;
};
 
using MultilinearBatchingNativeVerifier = MultilinearBatchingVerifier<false>;
using MultilinearBatchingRecursiveVerifier = MultilinearBatchingVerifier<true>;
 
} // namespace bb