translator.test.cpp

Go to the documentation of this file.

#include "barretenberg/circuit_checker/translator_circuit_checker.hpp"
#include "barretenberg/common/log.hpp"
#include "barretenberg/numeric/uint256/uint256.hpp"
#include "barretenberg/relations/relation_parameters.hpp"
#include "barretenberg/relations/translator_vm/translator_decomposition_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_decomposition_short_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_delta_range_constraint_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_delta_range_constraint_short_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_extra_relations_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_extra_short_relations_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_non_native_field_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_non_native_field_short_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_permutation_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_permutation_short_relation_impl.hpp"
#include "barretenberg/relations/translator_vm/translator_shiftable_first_coeff_zero_short_relation_impl.hpp"
#include "barretenberg/sumcheck/sumcheck_round.hpp"
#include "barretenberg/transcript/transcript_manifest.hpp"
#include "barretenberg/translator_vm/translator_circuit_builder.hpp"
#include "barretenberg/translator_vm/translator_prover.hpp"
#include "barretenberg/translator_vm/translator_verifier.hpp"
 
#include <gtest/gtest.h>
using namespace bb;
 
using CircuitBuilder = TranslatorFlavor::CircuitBuilder;
using Transcript = TranslatorFlavor::Transcript;
using OpQueue = ECCOpQueue;
static auto& engine = numeric::get_debug_randomness();
 
// Test helper: Create a VK by committing to proving key polynomials (for comparing with fixed VK)
TranslatorFlavor::VerificationKey create_vk_from_proving_key(
    const std::shared_ptr<TranslatorFlavor::ProvingKey>& proving_key)
{
    TranslatorFlavor::VerificationKey vk;
    // Only ordered_extra_range_constraints_numerator needs a VK commitment (the only non-computable precomputed)
    vk.ordered_extra_range_constraints_numerator =
        proving_key->commitment_key.commit(proving_key->polynomials.ordered_extra_range_constraints_numerator);
    return vk;
}
 
// Compute VK hash from fixed commitments (for test verification that vk_hash() is correct)
TranslatorFlavor::FF compute_translator_vk_hash()
{
    std::vector<TranslatorFlavor::FF> elements;
    // Serialize commitments using the Codec
    for (const auto& commitment : TranslatorHardcodedVKAndHash::get_all()) {
        auto frs = TranslatorFlavor::Codec::serialize_to_fields(commitment);
        for (const auto& fr : frs) {
            elements.push_back(fr);
        }
    }
    return TranslatorFlavor::HashFunction::hash(elements);
}
 
class TranslatorTests : public ::testing::Test {
    using G1 = g1::affine_element;
    using Fr = fr;
    using Fq = fq;
    using Flavor = TranslatorFlavor;
    using FF = Flavor::FF;
    using Commitment = Flavor::Commitment;
 
  protected:
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
 
    static TranscriptManifest build_expected_translator_manifest()
    {
        TranscriptManifest manifest;
        constexpr size_t frs_per_G = FrCodec::calc_num_fields<Flavor::Commitment>();
        constexpr size_t NUM_SUMCHECK_ROUNDS = Flavor::CONST_TRANSLATOR_LOG_N;
 
        // Round 0: vk_hash, Gemini masking, wire commitments
        manifest.add_entry(0, "vk_hash", 1);
        manifest.add_entry(0, "Gemini:masking_poly_comm", frs_per_G);
 
        // Wire commitments (10 total: 5 concatenated + 5 ordered)
        // clang-format off
        std::vector<std::string> wire_labels = {
            "CONCATENATED_RANGE_CONSTRAINTS_0", "CONCATENATED_RANGE_CONSTRAINTS_1",
            "CONCATENATED_RANGE_CONSTRAINTS_2", "CONCATENATED_RANGE_CONSTRAINTS_3",
            "CONCATENATED_NON_RANGE",
            "ORDERED_RANGE_CONSTRAINTS_0", "ORDERED_RANGE_CONSTRAINTS_1",
            "ORDERED_RANGE_CONSTRAINTS_2", "ORDERED_RANGE_CONSTRAINTS_3",
            "ORDERED_RANGE_CONSTRAINTS_4",
        };
        // clang-format on
        for (const auto& label : wire_labels) {
            manifest.add_entry(0, label, frs_per_G);
        }
        // beta and gamma are consecutive challenges (no data between), so both in round 0
        manifest.add_challenge(0, "beta");
        manifest.add_challenge(0, "gamma");
 
        // Round 1: Z_PERM -> Sumcheck:alpha + all gate challenges (same round, no data between them)
        manifest.add_entry(1, "Z_PERM", frs_per_G);
        manifest.add_challenge(1, "Sumcheck:alpha");
        manifest.add_challenge(1, "Sumcheck:gate_challenge");
 
        // Round 2: Libra concatenation commitment + Sum -> Libra:Challenge
        manifest.add_entry(2, "Libra:concatenation_commitment", frs_per_G);
        manifest.add_entry(2, "Libra:Sum", 1);
        manifest.add_challenge(2, "Libra:Challenge");
 
        // Rounds 3-15: Sumcheck univariates for mini-circuit rounds 0..12
        constexpr size_t LOG_MINI = Flavor::LOG_MINI_CIRCUIT_SIZE;
        for (size_t i = 0; i < LOG_MINI; ++i) {
            manifest.add_entry(3 + i, "Sumcheck:univariate_" + std::to_string(i), 9);
            manifest.add_challenge(3 + i, "Sumcheck:u_" + std::to_string(i));
        }
 
        // Round 16: 154 minicircuit wire evaluations sent mid-sumcheck, then univariate_13
        manifest.add_entry(3 + LOG_MINI, "Sumcheck:minicircuit_evaluations", Flavor::NUM_MINICIRCUIT_EVALUATIONS);
        manifest.add_entry(3 + LOG_MINI, "Sumcheck:univariate_" + std::to_string(LOG_MINI), 9);
        manifest.add_challenge(3 + LOG_MINI, "Sumcheck:u_" + std::to_string(LOG_MINI));
 
        // Rounds 17-19: remaining sumcheck rounds 14..16
        for (size_t i = LOG_MINI + 1; i < NUM_SUMCHECK_ROUNDS; ++i) {
            manifest.add_entry(3 + i, "Sumcheck:univariate_" + std::to_string(i), 9);
            manifest.add_challenge(3 + i, "Sumcheck:u_" + std::to_string(i));
        }
 
        // Sumcheck full-circuit evaluations (computable precomputed + minicircuit wires excluded) + Libra commitments
        // -> rho
        const size_t eval_round = 3 + NUM_SUMCHECK_ROUNDS;
        manifest.add_entry(eval_round, "Sumcheck:evaluations", Flavor::NUM_FULL_CIRCUIT_EVALUATIONS);
        manifest.add_entry(eval_round, "Libra:claimed_evaluation", 1);
        manifest.add_entry(eval_round, "Libra:grand_sum_commitment", frs_per_G);
        manifest.add_entry(eval_round, "Libra:quotient_commitment", frs_per_G);
        manifest.add_challenge(eval_round, "rho");
 
        // Gemini fold commitments -> Gemini:r
        const size_t gemini_fold_round = eval_round + 1;
        for (size_t i = 1; i < NUM_SUMCHECK_ROUNDS; ++i) {
            manifest.add_entry(gemini_fold_round, "Gemini:FOLD_" + std::to_string(i), frs_per_G);
        }
        manifest.add_challenge(gemini_fold_round, "Gemini:r");
 
        // Gemini evaluations + Libra evals -> Shplonk:nu
        const size_t gemini_eval_round = gemini_fold_round + 1;
        for (size_t i = 1; i <= NUM_SUMCHECK_ROUNDS; ++i) {
            manifest.add_entry(gemini_eval_round, "Gemini:a_" + std::to_string(i), 1);
        }
        // No more Gemini:P_pos / Gemini:P_neg (interleaving replaced by concatenation)
        manifest.add_entry(gemini_eval_round, "Libra:concatenation_eval", 1);
        manifest.add_entry(gemini_eval_round, "Libra:shifted_grand_sum_eval", 1);
        manifest.add_entry(gemini_eval_round, "Libra:grand_sum_eval", 1);
        manifest.add_entry(gemini_eval_round, "Libra:quotient_eval", 1);
        manifest.add_challenge(gemini_eval_round, "Shplonk:nu");
 
        // Shplonk:Q -> Shplonk:z
        const size_t shplonk_round = gemini_eval_round + 1;
        manifest.add_entry(shplonk_round, "Shplonk:Q", frs_per_G);
        manifest.add_challenge(shplonk_round, "Shplonk:z");
 
        // KZG:W
        const size_t kzg_round = shplonk_round + 1;
        manifest.add_entry(kzg_round, "KZG:W", frs_per_G);
 
        return manifest;
    }
 
    // Helper function to add no-ops
    static void add_random_ops(std::shared_ptr<bb::ECCOpQueue>& op_queue, size_t count = 1)
    {
        for (size_t i = 0; i < count; i++) {
            op_queue->random_op_ultra_only();
        }
    }
 
    static void add_mixed_ops(std::shared_ptr<bb::ECCOpQueue>& op_queue, size_t count = 100)
    {
        auto P1 = G1::random_element();
        auto P2 = G1::random_element();
        auto z = Fr::random_element();
        for (size_t i = 0; i < count; i++) {
            op_queue->add_accumulate(P1);
            op_queue->mul_accumulate(P2, z);
        }
        op_queue->eq_and_reset();
    }
 
    // Construct a test circuit based on some random operations
    static CircuitBuilder generate_test_circuit(const Fq& batching_challenge_v,
                                                const Fq& evaluation_challenge_x,
                                                const size_t circuit_size_parameter = 500)
    {
 
        auto op_queue = std::make_shared<ECCOpQueue>();
        // Construct zk_columns
        op_queue->construct_zk_columns();
        // Table with correct final structure for translator
        add_mixed_ops(op_queue, circuit_size_parameter / 2);
        add_random_ops(op_queue, TranslatorCircuitBuilder::NUM_RANDOM_OPS_END);
        // Merge with fixed append
        op_queue->merge_fixed_append(op_queue->get_append_offset_for_prover());
 
        return CircuitBuilder{ batching_challenge_v, evaluation_challenge_x, op_queue };
    }
 
    static bool prove_and_verify(const CircuitBuilder& circuit_builder,
                                 const Fq& evaluation_challenge_x,
                                 const Fq& batching_challenge_v)
    {
        // Setup prover transcript
        auto prover_transcript = std::make_shared<Transcript>();
        prover_transcript->send_to_verifier("init", Fq::random_element());
        auto initial_transcript = prover_transcript->export_proof();
 
        // Setup verifier transcript
        auto verifier_transcript = std::make_shared<Transcript>(initial_transcript);
        verifier_transcript->template receive_from_prover<Fq>("init");
 
        // Create proving key and prover
        auto proving_key = std::make_shared<TranslatorProvingKey>(circuit_builder);
        TranslatorProver prover{ proving_key, prover_transcript };
 
        // Generate proof
        auto proof = prover.construct_proof();
 
        // Commit to op queue wires
        std::array<TranslatorFlavor::Commitment, TranslatorFlavor::NUM_OP_QUEUE_WIRES> op_queue_commitments;
        op_queue_commitments[0] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.op);
        op_queue_commitments[1] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.x_lo_y_hi);
        op_queue_commitments[2] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.x_hi_z_1);
        op_queue_commitments[3] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.y_lo_z_2);
 
        // Get accumulated_result from the prover
        uint256_t accumulated_result = prover.get_accumulated_result();
 
        // Create verifier
        TranslatorVerifier verifier(verifier_transcript,
                                    proof,
                                    evaluation_challenge_x,
                                    batching_challenge_v,
                                    accumulated_result,
                                    op_queue_commitments);
 
        // Verify proof: get reduction result and check all components
        auto result = verifier.reduce_to_pairing_check();
        return result.pairing_points.check() && result.reduction_succeeded;
    }
 
    static bool prove_and_verify_short_monomial(const CircuitBuilder& circuit_builder,
                                                const Fq& evaluation_challenge_x,
                                                const Fq& batching_challenge_v)
    {
        auto prover_transcript = std::make_shared<Transcript>();
        prover_transcript->send_to_verifier("init", Fq::random_element());
        auto initial_transcript = prover_transcript->export_proof();
 
        auto verifier_transcript = std::make_shared<Transcript>(initial_transcript);
        verifier_transcript->template receive_from_prover<Fq>("init");
 
        auto proving_key = std::make_shared<TranslatorProvingKey>(circuit_builder);
        TranslatorProver prover{ proving_key, prover_transcript };
        auto proof = prover.construct_proof();
        EXPECT_EQ(proof.size(), TranslatorFlavor::PROOF_LENGTH);
 
        std::array<TranslatorFlavor::Commitment, TranslatorFlavor::NUM_OP_QUEUE_WIRES> op_queue_commitments;
        op_queue_commitments[0] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.op);
        op_queue_commitments[1] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.x_lo_y_hi);
        op_queue_commitments[2] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.x_hi_z_1);
        op_queue_commitments[3] =
            proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.y_lo_z_2);
 
        TranslatorVerifier verifier(verifier_transcript,
                                    proof,
                                    evaluation_challenge_x,
                                    batching_challenge_v,
                                    prover.get_accumulated_result(),
                                    op_queue_commitments);
 
        auto result = verifier.reduce_to_pairing_check();
        return result.pairing_points.check() && result.reduction_succeeded;
    }
 
    template <typename FullRelation, typename ShortRelation>
    static void expect_short_relation_matches_full_edges(const TranslatorShortMonomialFlavor::ProverUnivariates<2>& in,
                                                         const RelationParameters<FF>& params,
                                                         const FF& scaling_factor)
    {
        typename TranslatorFlavor::ExtendedEdges extended_edges;
        for (auto [extended_edge, short_edge] : zip_view(extended_edges.get_all(), in.get_all())) {
            extended_edge = short_edge.template extend_to<TranslatorFlavor::MAX_PARTIAL_RELATION_LENGTH>();
        }
 
        typename FullRelation::SumcheckTupleOfUnivariatesOverSubrelations full_accumulators{};
        typename ShortRelation::SumcheckTupleOfUnivariatesOverSubrelations short_accumulators{};
        FullRelation::accumulate(full_accumulators, extended_edges, params, scaling_factor);
        ShortRelation::accumulate(short_accumulators, in, params, scaling_factor);
 
        EXPECT_EQ(short_accumulators, full_accumulators);
    }
 
    static TranslatorShortMonomialFlavor::ProverUnivariates<2> get_short_edge_input(bool random_inputs)
    {
        TranslatorShortMonomialFlavor::ProverUnivariates<2> result;
        FF value = 0;
        for (auto& edge : result.get_all()) {
            if (random_inputs) {
                edge = bb::Univariate<FF, 2>({ FF::random_element(), FF::random_element() });
            } else {
                value += 1;
                edge = bb::Univariate<FF, 2>({ value, value + 1 });
                value += 1;
            }
        }
        return result;
    }
};
 
TEST_F(TranslatorTests, ProofLengthCheck)
{
    using Fq = fq;
 
    Fq batching_challenge_v = Fq::random_element();
    Fq evaluation_challenge_x = Fq::random_element();
 
    // Generate a circuit and its verification key (computed at runtime from the proving key)
    CircuitBuilder circuit_builder = generate_test_circuit(batching_challenge_v, evaluation_challenge_x);
 
    // Setup prover transcript
    auto prover_transcript = std::make_shared<Transcript>();
    prover_transcript->send_to_verifier("init", Fq::random_element());
    prover_transcript->export_proof();
    auto proving_key = std::make_shared<TranslatorProvingKey>(circuit_builder);
    TranslatorProver prover{ proving_key, prover_transcript };
 
    // Generate proof
    auto proof = prover.construct_proof();
 
    EXPECT_EQ(proof.size(), TranslatorFlavor::PROOF_LENGTH);
}
 
TEST_F(TranslatorTests, Basic)
{
    using Fq = fq;
 
    Fq batching_challenge_v = Fq::random_element();
    Fq evaluation_challenge_x = Fq::random_element();
 
    // Generate a circuit without no-ops
    CircuitBuilder circuit_builder = generate_test_circuit(batching_challenge_v, evaluation_challenge_x);
 
    EXPECT_TRUE(TranslatorCircuitChecker::check(circuit_builder));
    bool verified = prove_and_verify(circuit_builder, evaluation_challenge_x, batching_challenge_v);
    EXPECT_TRUE(verified);
}
 
TEST_F(TranslatorTests, ShortMonomialRelationsMatchFullEdgeRelations)
{
    const auto run_test = [&](bool random_inputs) {
        using FF = TranslatorFlavor::FF;
        const auto input = get_short_edge_input(random_inputs);
        const auto params = RelationParameters<FF>::get_random();
        const FF scaling_factor = random_inputs ? FF::random_element() : FF(7);
 
        expect_short_relation_matches_full_edges<TranslatorPermutationRelation<FF>,
                                                 TranslatorPermutationShortRelation<FF>>(input, params, scaling_factor);
        expect_short_relation_matches_full_edges<TranslatorDeltaRangeConstraintRelation<FF>,
                                                 TranslatorDeltaRangeConstraintShortRelation<FF>>(
            input, params, scaling_factor);
        expect_short_relation_matches_full_edges<TranslatorOpcodeConstraintRelation<FF>,
                                                 TranslatorOpcodeConstraintShortRelation<FF>>(
            input, params, scaling_factor);
        expect_short_relation_matches_full_edges<TranslatorAccumulatorTransferRelation<FF>,
                                                 TranslatorAccumulatorTransferShortRelation<FF>>(
            input, params, scaling_factor);
        expect_short_relation_matches_full_edges<TranslatorDecompositionRelation<FF>,
                                                 TranslatorDecompositionShortRelation<FF>>(
            input, params, scaling_factor);
        expect_short_relation_matches_full_edges<TranslatorNonNativeFieldRelation<FF>,
                                                 TranslatorNonNativeFieldShortRelation<FF>>(
            input, params, scaling_factor);
        expect_short_relation_matches_full_edges<TranslatorZeroConstraintsRelation<FF>,
                                                 TranslatorZeroConstraintsShortRelation<FF>>(
            input, params, scaling_factor);
    };
 
    run_test(/*random_inputs=*/false);
    run_test(/*random_inputs=*/true);
}
 
TEST_F(TranslatorTests, ShortMonomialProverVerifies)
{
    using Fq = fq;
 
    Fq batching_challenge_v = Fq::random_element();
    Fq evaluation_challenge_x = Fq::random_element();
 
    CircuitBuilder circuit_builder = generate_test_circuit(batching_challenge_v, evaluation_challenge_x);
 
    EXPECT_TRUE(TranslatorCircuitChecker::check(circuit_builder));
    EXPECT_TRUE(prove_and_verify(circuit_builder, evaluation_challenge_x, batching_challenge_v));
    EXPECT_TRUE(prove_and_verify_short_monomial(circuit_builder, evaluation_challenge_x, batching_challenge_v));
}
 
TEST_F(TranslatorTests, BasicAvmMode)
{
    using Fq = fq;
 
    Fq batching_challenge_v = Fq::random_element();
    Fq evaluation_challenge_x = Fq::random_element();
 
    // Add the same operations to the ECC op queue; the native computation is performed under the hood.
    auto op_queue = std::make_shared<bb::ECCOpQueue>();
    // Seed a no-op to supply the 2 leading zero rows Translator's op-queue wires need for shiftability.
    op_queue->no_op_ultra_only();
    add_random_ops(op_queue, CircuitBuilder::NUM_RANDOM_OPS_START);
    add_mixed_ops(op_queue, 100);
    op_queue->merge();
    auto circuit_builder = CircuitBuilder{ batching_challenge_v, evaluation_challenge_x, op_queue, /*avm_mode=*/true };
 
    EXPECT_TRUE(TranslatorCircuitChecker::check(circuit_builder));
    bool verified = prove_and_verify(circuit_builder, evaluation_challenge_x, batching_challenge_v);
    EXPECT_TRUE(verified);
}
 
TEST_F(TranslatorTests, FixedVK)
{
    using Fq = fq;
 
    auto prover_transcript = std::make_shared<Transcript>();
    prover_transcript->send_to_verifier("init", Fq::random_element());
    prover_transcript->export_proof();
    Fq batching_challenge_v = Fq::random_element();
    Fq evaluation_challenge_x = Fq::random_element();
 
    // Generate the default fixed VK
    TranslatorFlavor::VerificationKey fixed_vk{};
 
    // Lambda for manually computing a verification key for a given circuit and comparing it to the fixed VK
    auto compare_computed_vk_against_fixed = [&](size_t circuit_size_parameter) {
        CircuitBuilder circuit_builder =
            generate_test_circuit(batching_challenge_v, evaluation_challenge_x, circuit_size_parameter);
        auto proving_key = std::make_shared<TranslatorProvingKey>(circuit_builder);
        TranslatorProver prover{ proving_key, prover_transcript };
        TranslatorFlavor::VerificationKey computed_vk = create_vk_from_proving_key(proving_key->proving_key);
        auto labels = TranslatorFlavor::VerificationKey::get_labels();
 
        size_t index = 0;
        for (auto [vk_commitment, fixed_commitment] : zip_view(computed_vk.get_all(), fixed_vk.get_all())) {
            if (vk_commitment != fixed_commitment) {
                info("// ", labels[index]);
                info("Commitment(uint256_t(\"0x", vk_commitment.x, "\"),");
                info("           uint256_t(\"0x", vk_commitment.y, "\")),");
            }
            EXPECT_EQ(vk_commitment, fixed_commitment) << "Mismatch at label: " << labels[index];
            ++index;
        }
 
        EXPECT_EQ(computed_vk, fixed_vk);
    };
 
    // Check consistency of the fixed VK with the computed VK for some different circuit sizes
    const size_t circuit_size_parameter_1 = 1 << 2;
    const size_t circuit_size_parameter_2 = 1 << 3;
 
    compare_computed_vk_against_fixed(circuit_size_parameter_1);
    compare_computed_vk_against_fixed(circuit_size_parameter_2);
 
    // Verify that the hardcoded VK hash matches the computed hash
    auto computed_hash = compute_translator_vk_hash();
    auto hardcoded_hash = TranslatorHardcodedVKAndHash::vk_hash();
    if (computed_hash != hardcoded_hash) {
        info("VK hash mismatch! Update TranslatorHardcodedVKAndHash::vk_hash() with:");
        info("0x", computed_hash);
    }
    EXPECT_EQ(computed_hash, hardcoded_hash) << "Hardcoded VK hash does not match computed hash";
}
 
TEST_F(TranslatorTests, TranscriptPinned)
{
    using Fq = fq;
 
    Fq batching_challenge_v = Fq::random_element();
    Fq evaluation_challenge_x = Fq::random_element();
 
    CircuitBuilder circuit_builder = generate_test_circuit(batching_challenge_v, evaluation_challenge_x);
 
    // Create proving key and prover
    auto prover_transcript = std::make_shared<Transcript>();
    auto proving_key = std::make_shared<TranslatorProvingKey>(circuit_builder);
    TranslatorProver prover{ proving_key, prover_transcript };
 
    // Generate proof
    auto proof = prover.construct_proof();
 
    // Setup verifier transcript with manifest tracking
    auto verifier_transcript = std::make_shared<Transcript>(proof);
    verifier_transcript->enable_manifest();
 
    // Get accumulated_result from the prover
    uint256_t accumulated_result = prover.get_accumulated_result();
 
    // Commit to op queue wires
    std::array<TranslatorFlavor::Commitment, TranslatorFlavor::NUM_OP_QUEUE_WIRES> op_queue_commitments;
    op_queue_commitments[0] = proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.op);
    op_queue_commitments[1] =
        proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.x_lo_y_hi);
    op_queue_commitments[2] =
        proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.x_hi_z_1);
    op_queue_commitments[3] =
        proving_key->proving_key->commitment_key.commit(proving_key->proving_key->polynomials.y_lo_z_2);
 
    // Create verifier with all required inputs
    TranslatorVerifier verifier(verifier_transcript,
                                proof,
                                evaluation_challenge_x,
                                batching_challenge_v,
                                accumulated_result,
                                op_queue_commitments);
 
    // Run verification - just reduce to pairing check to exercise the transcript
    [[maybe_unused]] auto result = verifier.reduce_to_pairing_check();
 
    // Compare verifier manifest against hardcoded expected structure
    auto expected_manifest = build_expected_translator_manifest();
    auto verifier_manifest = verifier_transcript->get_manifest();
 
    EXPECT_EQ(verifier_manifest, expected_manifest);
}
 
TEST_F(TranslatorTests, EvaluationPartition)
{
    using Flavor = TranslatorFlavor;
    using FF = Flavor::FF;
 
    // Fill all entities with distinct values (entity index as value)
    Flavor::AllEntities<FF> evals;
    {
        size_t idx = 0;
        for (auto& e : evals.get_all()) {
            e = FF(idx++);
        }
    }
 
    // Collect addresses of all entities touched by each getter
    std::set<FF*> covered;
 
    for (auto& e : evals.get_minicircuit_wires()) {
        EXPECT_TRUE(covered.insert(&e).second) << "minicircuit wire overlaps with a previous entity";
    }
    EXPECT_EQ(covered.size(), Flavor::NUM_MINICIRCUIT_WIRES);
 
    for (auto& e : evals.get_minicircuit_wires_shifted()) {
        EXPECT_TRUE(covered.insert(&e).second) << "minicircuit wire shift overlaps with a previous entity";
    }
    EXPECT_EQ(covered.size(), 2 * Flavor::NUM_MINICIRCUIT_WIRES);
 
    for (auto& e : evals.get_full_circuit_entities()) {
        EXPECT_TRUE(covered.insert(&e).second) << "full-circuit entity overlaps with a previous entity";
    }
    EXPECT_EQ(covered.size(), 2 * Flavor::NUM_MINICIRCUIT_WIRES + Flavor::NUM_FULL_CIRCUIT_EVALUATIONS);
 
    // Concat polys are reconstructed (not sent in proof), but still in AllEntities
    for (auto& e : evals.get_concatenated()) {
        EXPECT_TRUE(covered.insert(&e).second) << "concatenated poly overlaps with a previous entity";
    }
    EXPECT_EQ(covered.size(),
              2 * Flavor::NUM_MINICIRCUIT_WIRES + Flavor::NUM_FULL_CIRCUIT_EVALUATIONS +
                  Flavor::NUM_CONCATENATED_POLYS);
 
    // The computable precomputed selectors are the remaining entities
    size_t remaining = Flavor::NUM_ALL_ENTITIES - covered.size();
    EXPECT_EQ(remaining, Flavor::NUM_COMPUTABLE_PRECOMPUTED);
 
    // Verify the remaining entities are exactly the computable precomputed ones
    for (auto& e : evals.get_all()) {
        if (covered.find(&e) == covered.end()) {
            // This entity must be one of the 12 computable precomputed selectors
            remaining--;
        }
    }
    EXPECT_EQ(remaining, 0UL);
}
 
TEST_F(TranslatorTests, RepeatedCommitmentsIndicesCorrect)
{
    using Flavor = TranslatorFlavor;
    using Commitment = Flavor::Commitment;
 
    fq batching_challenge_v = fq::random_element();
    fq evaluation_challenge_x = fq::random_element();
    CircuitBuilder circuit_builder = generate_test_circuit(batching_challenge_v, evaluation_challenge_x);
    auto pk = std::make_shared<TranslatorProvingKey>(circuit_builder);
 
    pk->proving_key->commitment_key = Flavor::CommitmentKey(pk->proving_key->circuit_size);
 
    auto pcs_unshifted = pk->proving_key->polynomials.get_pcs_unshifted();
    auto pcs_to_be_shifted = pk->proving_key->polynomials.get_pcs_to_be_shifted();
 
    // Commit to all PCS polynomials
    const auto& ck = pk->proving_key->commitment_key;
    std::vector<Commitment> unshifted_comms;
    for (auto& poly : pcs_unshifted) {
        unshifted_comms.push_back(ck.commit(poly));
    }
    std::vector<Commitment> shifted_comms;
    for (auto& poly : pcs_to_be_shifted) {
        shifted_comms.push_back(ck.commit(poly));
    }
 
    // Build the commitment vector exactly as Shplemini does: [Q, pcs_unshifted..., pcs_to_be_shifted...]
    std::vector<Commitment> commitments;
    commitments.push_back(Commitment::one()); // dummy Q
    commitments.insert(commitments.end(), unshifted_comms.begin(), unshifted_comms.end());
    commitments.insert(commitments.end(), shifted_comms.begin(), shifted_comms.end());
 
    constexpr auto repeated = Flavor::REPEATED_COMMITMENTS;
    // Same offset logic as remove_repeated_commitments
    constexpr size_t offset = Flavor::HasZK ? 2 : 1;
 
    // Verify both ranges using the same indexing as remove_repeated_commitments
    auto check_range = [&](const auto& range, const std::string& label) {
        for (size_t i = 0; i < range.count; i++) {
            EXPECT_EQ(commitments[range.original_start + offset + i], commitments[range.duplicate_start + offset + i])
                << label << " commitment mismatch at index " << i;
        }
    };
 
    check_range(repeated.first, "Range 1");
    check_range(repeated.second, "Range 2");
}
 
TEST_F(TranslatorTests, VerifierPopulatesAllEntities)
{
    using Flavor = TranslatorFlavor;
    using FF = Flavor::FF;
 
    // Prepare random minicircuit evaluations (154 values)
    std::array<FF, Flavor::NUM_MINICIRCUIT_EVALUATIONS> mid;
    for (auto& v : mid) {
        v = FF::random_element(&engine);
    }
 
    // Prepare random full-circuit evaluations (26 values)
    std::array<FF, Flavor::NUM_FULL_CIRCUIT_EVALUATIONS> full_circuit;
    for (auto& v : full_circuit) {
        v = FF::random_element(&engine);
    }
 
    // Random challenge (computable precomputed selectors depend on this)
    std::vector<FF> challenge(Flavor::CONST_TRANSLATOR_LOG_N);
    for (auto& u : challenge) {
        u = FF::random_element(&engine);
    }
 
    // Verifier reconstruction: start from zero, populate via the two verifier methods
    Flavor::AllEntities<FF> evals;
    Flavor::set_minicircuit_evaluations(evals, mid);
    Flavor::complete_full_circuit_evaluations(evals, full_circuit, std::span<const FF>(challenge));
 
    // Every entity should now be nonzero (probability of a random FF being zero is negligible)
    auto all = evals.get_all();
    for (size_t i = 0; i < Flavor::NUM_ALL_ENTITIES; i++) {
        EXPECT_NE(all[i], FF(0)) << "Entity " << i << " was not populated by verifier methods";
    }
}