batched_honk_translator_verifier.hpp

Go to the documentation of this file.

#pragma once
 
#include "barretenberg/commitment_schemes/pairing_points.hpp"
#include "barretenberg/flavor/mega_zk_flavor.hpp"
#include "barretenberg/flavor/mega_zk_recursive_flavor.hpp"
#include "barretenberg/honk/proof_system/types/proof.hpp"
#include "barretenberg/stdlib/primitives/curves/bn254.hpp"
#include "barretenberg/stdlib/primitives/pairing_points.hpp"
#include "barretenberg/stdlib/proof/proof.hpp"
#include "barretenberg/stdlib/translator_vm_verifier/translator_recursive_flavor.hpp"
#include "barretenberg/translator_vm/translator_flavor.hpp"
#include "barretenberg/ultra_honk/verifier_instance.hpp"
 
namespace bb {
 
template <typename Curve> class BatchedHonkTranslatorVerifier_ {
  public:
    static constexpr bool IsRecursive = Curve::is_stdlib_type;
 
    // Select MegaZK flavor based on native vs recursive.
    using MegaZKFlavorT = std::conditional_t<IsRecursive, MegaZKRecursiveFlavor_<UltraCircuitBuilder>, MegaZKFlavor>;
    // Select translator flavor based on native vs recursive.
    using TransFlavor = std::conditional_t<IsRecursive, TranslatorRecursiveFlavor, TranslatorFlavor>;
 
    using FF = typename MegaZKFlavorT::FF;
    using Commitment = typename MegaZKFlavorT::Commitment;
    using MegaZKVerifierInstance = VerifierInstance_<MegaZKFlavorT>;
    using MegaZKVKAndHash = typename MegaZKFlavorT::VKAndHash;
    using Transcript = std::conditional_t<IsRecursive, UltraStdlibTranscript, NativeTranscript>;
    using MegaZKVerifierCommitments = typename MegaZKFlavorT::VerifierCommitments;
    using TransVerifierCommitments = typename TransFlavor::VerifierCommitments;
 
    // Proof type: stdlib::Proof<UltraCircuitBuilder> for recursive, HonkProof for native.
    using Proof = std::conditional_t<IsRecursive, stdlib::Proof<UltraCircuitBuilder>, HonkProof>;
 
    // PairingPoints type.
    using PairingPoints =
        std::conditional_t<IsRecursive, stdlib::recursion::PairingPoints<Curve>, bb::PairingPoints<Curve>>;
 
    // BF type from the translator flavor (BN254 base field elements).
    using TransBF = typename TransFlavor::BF;
 
    // Joint RepeatedCommitmentsData for Shplemini's remove_repeated_commitments optimization.
    // After Shplemini's offset=2 (Q_commitment + gemini_masking_poly), the virtual layout is:
    //   Unshifted: [MegaZK_precomputed(P) | MegaZK_witness(W) | Trans_PCS_unshifted(TU)]
    //   Shifted:   [MegaZK_shifted(S) | Trans_PCS_shifted(TS)]
    //
    // Range 1 (MegaZK): witness[0..S-1] ↔ mega_zk_shifted[0..S-1]
    // Range 2 (Translator merged): ordered(5)+z_perm(1)+concat(5) in unshifted ↔ same in shifted
    static constexpr RepeatedCommitmentsData REPEATED_COMMITMENTS = [] {
        constexpr size_t P = MegaZKFlavorT::NUM_PRECOMPUTED_ENTITIES;
        // W = MegaFlavor::NUM_WITNESS_ENTITIES (without masking, which is handled by Shplemini's offset)
        constexpr size_t W = MegaZKFlavorT::REPEATED_COMMITMENTS.first.duplicate_start -
                             MegaZKFlavorT::REPEATED_COMMITMENTS.first.original_start;
        constexpr size_t S = MegaZKFlavorT::NUM_SHIFTED_ENTITIES;
        constexpr size_t TU = TranslatorFlavor::NUM_PCS_UNSHIFTED;
        // Skip before repeated entries: masking(1)+ordered_extra(1)+op(1)=3 in unshifted, op_queue(3) in shifted
        constexpr size_t TRANS_UNSHIFTED_SKIP = TranslatorFlavor::REPEATED_COMMITMENTS.first.original_start + 1;
        constexpr size_t TRANS_SHIFTED_SKIP =
            TranslatorFlavor::NUM_PCS_TO_BE_SHIFTED -
            (TranslatorFlavor::REPEATED_COMMITMENTS.first.count + TranslatorFlavor::REPEATED_COMMITMENTS.second.count);
        return RepeatedCommitmentsData(
            P,                                   // MegaZK original: start of witness in unshifted
            P + W + TU,                          // MegaZK duplicate: start of mega_zk_shifted
            S,                                   // MegaZK count
            P + W + TRANS_UNSHIFTED_SKIP,        // Translator original: ordered+z_perm+concat in unshifted
            P + W + TU + S + TRANS_SHIFTED_SKIP, // Translator duplicate: same entries in shifted
            TranslatorFlavor::REPEATED_COMMITMENTS.first.count +
                TranslatorFlavor::REPEATED_COMMITMENTS.second.count); // Translator count
    }();
 
    struct ReductionResult {
        PairingPoints pairing_points;
        bool reduction_succeeded = false;
    };
 
    struct OinkResult {
        std::vector<FF> public_inputs;
        Commitment calldata_commitment;
        std::array<Commitment, MegaZKFlavorT::NUM_WIRES> ecc_op_wires;
    };
 
    BatchedHonkTranslatorVerifier_(std::shared_ptr<MegaZKVKAndHash> mega_zk_vk_and_hash,
                                   std::shared_ptr<Transcript> transcript);
 
    OinkResult verify_mega_zk_oink(const Proof& mega_zk_proof);
 
    [[nodiscard("Verification result should be checked")]] ReductionResult verify(
        const Proof& joint_proof,
        const TransBF& evaluation_input_x,
        const TransBF& batching_challenge_v,
        const TransBF& accumulated_result,
        const std::array<Commitment, TranslatorFlavor::NUM_OP_QUEUE_WIRES>& op_queue_wire_commitments);
 
  private:
    // Methods mirroring the prover's structure.
    TransVerifierCommitments verify_translator_oink(
        const Proof& joint_proof,
        const TransBF& evaluation_input_x,
        const TransBF& batching_challenge_v,
        const TransBF& accumulated_result,
        const std::array<Commitment, TranslatorFlavor::NUM_OP_QUEUE_WIRES>& op_queue_wire_commitments);
    bool verify_joint_sumcheck();
    ReductionResult verify_joint_pcs(bool sumcheck_verified,
                                     MegaZKVerifierCommitments& mega_zk_commitments,
                                     TransVerifierCommitments& trans_commitments);
 
    std::shared_ptr<MegaZKVKAndHash> mega_zk_vk_and_hash;
    std::shared_ptr<Transcript> transcript;
 
    // Verifier instance stored after verify_mega_zk_oink (provides accessors)
    std::shared_ptr<MegaZKVerifierInstance> mega_zk_verifier_instance;
 
    // Builder pointer (only meaningful for recursive, nullptr for native).
    std::conditional_t<IsRecursive, UltraCircuitBuilder*, std::nullptr_t> builder = nullptr;
 
    // Relation parameters populated during verify_mega_zk_oink / verify_translator_oink.
    bb::RelationParameters<FF> mega_zk_relation_parameters;
    bb::RelationParameters<FF> translator_relation_parameters;
 
    // State populated by verify_joint_sumcheck(), consumed by verify_joint_pcs().
    std::vector<FF> joint_challenge;
    typename MegaZKFlavorT::AllValues mega_zk_evals;
    typename TransFlavor::AllValues trans_evals;
    std::array<Commitment, NUM_LIBRA_COMMITMENTS> libra_commitments;
    FF libra_evaluation;
    FF libra_challenge;
};
 
// Type aliases.
using BatchedHonkTranslatorVerifier = BatchedHonkTranslatorVerifier_<curve::BN254>;
using BatchedHonkTranslatorRecursiveVerifier = BatchedHonkTranslatorVerifier_<stdlib::bn254<UltraCircuitBuilder>>;
 
} // namespace bb