mega_zk_flavor_generated.hpp

Go to the documentation of this file.

// AUTOGENERATED FILE — do not edit. Regenerate via:
//   node barretenberg/cpp/scripts/flavor-codegen/dist/main.js
//
// Source: barretenberg/cpp/scripts/flavor-codegen/src/flavors/mega_zk.ts
#pragma once
 
#include <array>
#include <cstddef>
#include <cstdint>
#include <span>
#include <string>
#include <tuple>
#include <vector>
 
#include "barretenberg/common/ref_array.hpp"
#include "barretenberg/common/ref_vector.hpp"
#include "barretenberg/flavor/repeated_commitments_data.hpp"
#include "barretenberg/honk/execution_trace/execution_trace_block.hpp"
#include "barretenberg/relations/bilinear_or_batched_eq_check_relation.hpp"
#include "barretenberg/relations/databus_lookup_relation.hpp"
#include "barretenberg/relations/delta_range_constraint_relation.hpp"
#include "barretenberg/relations/ecc_op_queue_relation.hpp"
#include "barretenberg/relations/permutation_relation.hpp"
#include "barretenberg/relations/poseidon2_external_relation.hpp"
#include "barretenberg/relations/poseidon2_initial_external_relation.hpp"
#include "barretenberg/relations/poseidon2_quad_internal_relation.hpp"
#include "barretenberg/relations/poseidon2_quad_internal_terminal_relation.hpp"
#include "barretenberg/relations/poseidon2_transition_entry_relation.hpp"
#include "barretenberg/relations/ultra_arithmetic_relation.hpp"
 
namespace bb {
 
class MegaZKFlavor_Generated {
  public:
    // Dense flavor-local entity index. Layout: [masking | precomputed | witness | shifted].
    enum class EntityId : uint16_t {
        q_m = 0,
        q_l = 1,
        q_r = 2,
        q_o = 3,
        q_4 = 4,
        q_c = 5,
        q_arith = 6,
        q_bilinear_batched_eq = 7,
        sigma_1 = 8,
        sigma_2 = 9,
        sigma_3 = 10,
        sigma_4 = 11,
        id_1 = 12,
        id_2 = 13,
        id_3 = 14,
        id_4 = 15,
        lagrange_first = 16,
        lagrange_last = 17,
        q_delta_range = 18,
        lagrange_ecc_op = 19,
        q_busread = 20,
        kernel_calldata_indicator = 21,
        databus_id = 22,
        q_poseidon2_external = 23,
        q_poseidon2_external_initial = 24,
        q_poseidon2_quad_internal = 25,
        q_5 = 26,
        q_poseidon2_quad_internal_terminal = 27,
        q_poseidon2_transition_entry = 28,
        w_l = 29,
        w_r = 30,
        w_o = 31,
        w_4 = 32,
        z_perm = 33,
        ecc_op_wire_1 = 34,
        ecc_op_wire_2 = 35,
        ecc_op_wire_3 = 36,
        ecc_op_wire_4 = 37,
        kernel_calldata = 38,
        kernel_calldata_read_counts = 39,
        kernel_calldata_inverses = 40,
        w_l_shift = 41,
        w_r_shift = 42,
        w_o_shift = 43,
        w_4_shift = 44,
        z_perm_shift = 45,
    };
 
    // Sumcheck relation tuple. Source of truth is
    // flavor-codegen/src/flavors/mega_zk.ts; structural relations are omitted.
    template <typename FF>
    using Relations_ = std::tuple<bb::ArithmeticRelation<FF>,
                                  bb::BilinearOrBatchedEqCheckRelation<FF>,
                                  bb::UltraPermutationRelation<FF>,
                                  bb::DeltaRangeConstraintRelation<FF>,
                                  bb::EccOpQueueRelation<FF>,
                                  bb::MegaEccOpBoundaryRelation<FF>,
                                  bb::SingleBusLookupRelation<FF,
                                                              EntityId::kernel_calldata,
                                                              EntityId::kernel_calldata_read_counts,
                                                              EntityId::kernel_calldata_inverses,
                                                              EntityId::kernel_calldata_indicator,
                                                              EntityId::q_l>,
                                  bb::Poseidon2ExternalRelation<FF>,
                                  bb::Poseidon2InitialExternalRelation<FF>,
                                  bb::Poseidon2QuadInternalRelation<FF>,
                                  bb::Poseidon2QuadInternalTerminalRelation<FF>,
                                  bb::Poseidon2TransitionEntryRelation<FF>>;
 
    static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 29;
    static constexpr size_t NUM_WITNESS_ENTITIES = 12;
    static constexpr size_t NUM_MASKING_ENTITIES = 0;
    static constexpr size_t NUM_SHIFTED_ENTITIES = 5;
    static constexpr bool HasDataBus = true;
    static constexpr size_t NUM_BUS_COLUMNS = 1;
    static constexpr std::array<size_t, NUM_BUS_COLUMNS> BUILDER_BUS_INDICES = { 0 };
    static constexpr bool HasLogDerivLookup = false;
    static constexpr bool HasElliptic = false;
    static constexpr bool HasMemory = false;
    static constexpr bool HasNonNativeField = false;
    static constexpr bool HasEccOpQueue = true;
    static constexpr size_t NUM_COMMITTED_WITNESS_ENTITIES = NUM_WITNESS_ENTITIES + NUM_MASKING_ENTITIES;
    static constexpr size_t NUM_UNSHIFTED_ENTITIES = NUM_PRECOMPUTED_ENTITIES + NUM_COMMITTED_WITNESS_ENTITIES;
    static constexpr size_t NUM_ALL_ENTITIES = NUM_UNSHIFTED_ENTITIES + NUM_SHIFTED_ENTITIES;
 
    // Per-shifted-entity (original, duplicate) index pairs in AllEntities, one per shifted
    // entity. Collapsed into `RepeatedCommitmentsData` below for Shplemini compatibility.
    static constexpr std::array<DuplicatePair, NUM_SHIFTED_ENTITIES> REPEATED_COMMITMENT_PAIRS = {
        DuplicatePair{ 29, 41 }, DuplicatePair{ 30, 42 }, DuplicatePair{ 31, 43 },
        DuplicatePair{ 32, 44 }, DuplicatePair{ 33, 45 },
    };
    static constexpr RepeatedCommitmentsData REPEATED_COMMITMENTS =
        repeated_commitments_from_pairs(REPEATED_COMMITMENT_PAIRS);
 
    // Gate-selector blocks, parallel to `get_gate_selectors()`.
    template <typename TraceBlocks> static auto get_gate_blocks(TraceBlocks& blocks)
    {
        using BlockBase = typename TraceBlocks::BlockBase;
        return RefArray<BlockBase, 9>(std::array<BlockBase*, 9>{
            &blocks.arithmetic,
            &blocks.arithmetic,
            &blocks.delta_range,
            &blocks.busread,
            &blocks.poseidon2,
            &blocks.poseidon2,
            &blocks.poseidon2,
            &blocks.poseidon2,
            &blocks.poseidon2,
        });
    }
 
    template <typename TraceBlocks> static auto get_gate_blocks(TraceBlocks const& blocks)
    {
        using BlockBase = typename TraceBlocks::BlockBase;
        return RefArray<const BlockBase, 9>(std::array<const BlockBase*, 9>{
            &blocks.arithmetic,
            &blocks.arithmetic,
            &blocks.delta_range,
            &blocks.busread,
            &blocks.poseidon2,
            &blocks.poseidon2,
            &blocks.poseidon2,
            &blocks.poseidon2,
            &blocks.poseidon2,
        });
    }
 
    // GateKind for each gate selector, parallel to `get_gate_blocks()`.
    static constexpr std::array<GateKind, 9> GATE_KINDS{
        GateKind::Arith,
        GateKind::BilinearBatchedEq,
        GateKind::DeltaRange,
        GateKind::BusRead,
        GateKind::Poseidon2Ext,
        GateKind::Poseidon2ExtInitial,
        GateKind::Poseidon2QuadInt,
        GateKind::Poseidon2QuadIntTerminal,
        GateKind::Poseidon2TransitionEntry,
    };
 
    // Non-gate selectors in `get_non_gate_selectors()` order, as references into a single block.
    template <typename TraceBlock> static auto get_block_non_gate_selectors(TraceBlock& block)
    {
        using SelT = std::remove_reference_t<decltype(block.q_m())>;
        return RefArray<SelT, 7>{
            block.q_m(), block.q_1(), block.q_2(), block.q_3(), block.q_4(), block.q_c(), block.q_5(),
        };
    }
 
    // AllEntities: flat `std::array` storage with EntityId-keyed access and named accessors.
    template <typename DataType> class AllEntities {
      public:
        using EntityId = MegaZKFlavor_Generated::EntityId;
        std::array<DataType, NUM_ALL_ENTITIES> data{};
 
        DataType& operator[](EntityId id) { return data[static_cast<size_t>(id)]; }
        const DataType& operator[](EntityId id) const { return data[static_cast<size_t>(id)]; }
 
        std::span<DataType, NUM_ALL_ENTITIES> get_all() { return data; }
        std::span<const DataType, NUM_ALL_ENTITIES> get_all() const { return data; }
 
        // Named accessors (unshifted + shifted): mutable + const overloads.
        DataType& q_m() { return data[static_cast<size_t>(EntityId::q_m)]; }
        const DataType& q_m() const { return data[static_cast<size_t>(EntityId::q_m)]; }
        DataType& q_l() { return data[static_cast<size_t>(EntityId::q_l)]; }
        const DataType& q_l() const { return data[static_cast<size_t>(EntityId::q_l)]; }
        DataType& q_r() { return data[static_cast<size_t>(EntityId::q_r)]; }
        const DataType& q_r() const { return data[static_cast<size_t>(EntityId::q_r)]; }
        DataType& q_o() { return data[static_cast<size_t>(EntityId::q_o)]; }
        const DataType& q_o() const { return data[static_cast<size_t>(EntityId::q_o)]; }
        DataType& q_4() { return data[static_cast<size_t>(EntityId::q_4)]; }
        const DataType& q_4() const { return data[static_cast<size_t>(EntityId::q_4)]; }
        DataType& q_c() { return data[static_cast<size_t>(EntityId::q_c)]; }
        const DataType& q_c() const { return data[static_cast<size_t>(EntityId::q_c)]; }
        DataType& q_arith() { return data[static_cast<size_t>(EntityId::q_arith)]; }
        const DataType& q_arith() const { return data[static_cast<size_t>(EntityId::q_arith)]; }
        DataType& q_bilinear_batched_eq() { return data[static_cast<size_t>(EntityId::q_bilinear_batched_eq)]; }
        const DataType& q_bilinear_batched_eq() const
        {
            return data[static_cast<size_t>(EntityId::q_bilinear_batched_eq)];
        }
        DataType& sigma_1() { return data[static_cast<size_t>(EntityId::sigma_1)]; }
        const DataType& sigma_1() const { return data[static_cast<size_t>(EntityId::sigma_1)]; }
        DataType& sigma_2() { return data[static_cast<size_t>(EntityId::sigma_2)]; }
        const DataType& sigma_2() const { return data[static_cast<size_t>(EntityId::sigma_2)]; }
        DataType& sigma_3() { return data[static_cast<size_t>(EntityId::sigma_3)]; }
        const DataType& sigma_3() const { return data[static_cast<size_t>(EntityId::sigma_3)]; }
        DataType& sigma_4() { return data[static_cast<size_t>(EntityId::sigma_4)]; }
        const DataType& sigma_4() const { return data[static_cast<size_t>(EntityId::sigma_4)]; }
        DataType& id_1() { return data[static_cast<size_t>(EntityId::id_1)]; }
        const DataType& id_1() const { return data[static_cast<size_t>(EntityId::id_1)]; }
        DataType& id_2() { return data[static_cast<size_t>(EntityId::id_2)]; }
        const DataType& id_2() const { return data[static_cast<size_t>(EntityId::id_2)]; }
        DataType& id_3() { return data[static_cast<size_t>(EntityId::id_3)]; }
        const DataType& id_3() const { return data[static_cast<size_t>(EntityId::id_3)]; }
        DataType& id_4() { return data[static_cast<size_t>(EntityId::id_4)]; }
        const DataType& id_4() const { return data[static_cast<size_t>(EntityId::id_4)]; }
        DataType& lagrange_first() { return data[static_cast<size_t>(EntityId::lagrange_first)]; }
        const DataType& lagrange_first() const { return data[static_cast<size_t>(EntityId::lagrange_first)]; }
        DataType& lagrange_last() { return data[static_cast<size_t>(EntityId::lagrange_last)]; }
        const DataType& lagrange_last() const { return data[static_cast<size_t>(EntityId::lagrange_last)]; }
        DataType& q_delta_range() { return data[static_cast<size_t>(EntityId::q_delta_range)]; }
        const DataType& q_delta_range() const { return data[static_cast<size_t>(EntityId::q_delta_range)]; }
        DataType& lagrange_ecc_op() { return data[static_cast<size_t>(EntityId::lagrange_ecc_op)]; }
        const DataType& lagrange_ecc_op() const { return data[static_cast<size_t>(EntityId::lagrange_ecc_op)]; }
        DataType& q_busread() { return data[static_cast<size_t>(EntityId::q_busread)]; }
        const DataType& q_busread() const { return data[static_cast<size_t>(EntityId::q_busread)]; }
        DataType& kernel_calldata_indicator() { return data[static_cast<size_t>(EntityId::kernel_calldata_indicator)]; }
        const DataType& kernel_calldata_indicator() const
        {
            return data[static_cast<size_t>(EntityId::kernel_calldata_indicator)];
        }
        DataType& databus_id() { return data[static_cast<size_t>(EntityId::databus_id)]; }
        const DataType& databus_id() const { return data[static_cast<size_t>(EntityId::databus_id)]; }
        DataType& q_poseidon2_external() { return data[static_cast<size_t>(EntityId::q_poseidon2_external)]; }
        const DataType& q_poseidon2_external() const
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_external)];
        }
        DataType& q_poseidon2_external_initial()
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_external_initial)];
        }
        const DataType& q_poseidon2_external_initial() const
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_external_initial)];
        }
        DataType& q_poseidon2_quad_internal() { return data[static_cast<size_t>(EntityId::q_poseidon2_quad_internal)]; }
        const DataType& q_poseidon2_quad_internal() const
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_quad_internal)];
        }
        DataType& q_5() { return data[static_cast<size_t>(EntityId::q_5)]; }
        const DataType& q_5() const { return data[static_cast<size_t>(EntityId::q_5)]; }
        DataType& q_poseidon2_quad_internal_terminal()
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_quad_internal_terminal)];
        }
        const DataType& q_poseidon2_quad_internal_terminal() const
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_quad_internal_terminal)];
        }
        DataType& q_poseidon2_transition_entry()
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_transition_entry)];
        }
        const DataType& q_poseidon2_transition_entry() const
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_transition_entry)];
        }
        DataType& w_l() { return data[static_cast<size_t>(EntityId::w_l)]; }
        const DataType& w_l() const { return data[static_cast<size_t>(EntityId::w_l)]; }
        DataType& w_r() { return data[static_cast<size_t>(EntityId::w_r)]; }
        const DataType& w_r() const { return data[static_cast<size_t>(EntityId::w_r)]; }
        DataType& w_o() { return data[static_cast<size_t>(EntityId::w_o)]; }
        const DataType& w_o() const { return data[static_cast<size_t>(EntityId::w_o)]; }
        DataType& w_4() { return data[static_cast<size_t>(EntityId::w_4)]; }
        const DataType& w_4() const { return data[static_cast<size_t>(EntityId::w_4)]; }
        DataType& z_perm() { return data[static_cast<size_t>(EntityId::z_perm)]; }
        const DataType& z_perm() const { return data[static_cast<size_t>(EntityId::z_perm)]; }
        DataType& ecc_op_wire_1() { return data[static_cast<size_t>(EntityId::ecc_op_wire_1)]; }
        const DataType& ecc_op_wire_1() const { return data[static_cast<size_t>(EntityId::ecc_op_wire_1)]; }
        DataType& ecc_op_wire_2() { return data[static_cast<size_t>(EntityId::ecc_op_wire_2)]; }
        const DataType& ecc_op_wire_2() const { return data[static_cast<size_t>(EntityId::ecc_op_wire_2)]; }
        DataType& ecc_op_wire_3() { return data[static_cast<size_t>(EntityId::ecc_op_wire_3)]; }
        const DataType& ecc_op_wire_3() const { return data[static_cast<size_t>(EntityId::ecc_op_wire_3)]; }
        DataType& ecc_op_wire_4() { return data[static_cast<size_t>(EntityId::ecc_op_wire_4)]; }
        const DataType& ecc_op_wire_4() const { return data[static_cast<size_t>(EntityId::ecc_op_wire_4)]; }
        DataType& kernel_calldata() { return data[static_cast<size_t>(EntityId::kernel_calldata)]; }
        const DataType& kernel_calldata() const { return data[static_cast<size_t>(EntityId::kernel_calldata)]; }
        DataType& kernel_calldata_read_counts()
        {
            return data[static_cast<size_t>(EntityId::kernel_calldata_read_counts)];
        }
        const DataType& kernel_calldata_read_counts() const
        {
            return data[static_cast<size_t>(EntityId::kernel_calldata_read_counts)];
        }
        DataType& kernel_calldata_inverses() { return data[static_cast<size_t>(EntityId::kernel_calldata_inverses)]; }
        const DataType& kernel_calldata_inverses() const
        {
            return data[static_cast<size_t>(EntityId::kernel_calldata_inverses)];
        }
        DataType& w_l_shift() { return data[static_cast<size_t>(EntityId::w_l_shift)]; }
        const DataType& w_l_shift() const { return data[static_cast<size_t>(EntityId::w_l_shift)]; }
        DataType& w_r_shift() { return data[static_cast<size_t>(EntityId::w_r_shift)]; }
        const DataType& w_r_shift() const { return data[static_cast<size_t>(EntityId::w_r_shift)]; }
        DataType& w_o_shift() { return data[static_cast<size_t>(EntityId::w_o_shift)]; }
        const DataType& w_o_shift() const { return data[static_cast<size_t>(EntityId::w_o_shift)]; }
        DataType& w_4_shift() { return data[static_cast<size_t>(EntityId::w_4_shift)]; }
        const DataType& w_4_shift() const { return data[static_cast<size_t>(EntityId::w_4_shift)]; }
        DataType& z_perm_shift() { return data[static_cast<size_t>(EntityId::z_perm_shift)]; }
        const DataType& z_perm_shift() const { return data[static_cast<size_t>(EntityId::z_perm_shift)]; }
 
        // Kind/shift partitions: contiguous slices of `data`.
        std::span<DataType, NUM_UNSHIFTED_ENTITIES> get_unshifted()
        {
            return std::span<DataType, NUM_UNSHIFTED_ENTITIES>{ data.data() + (0), NUM_UNSHIFTED_ENTITIES };
        }
        std::span<const DataType, NUM_UNSHIFTED_ENTITIES> get_unshifted() const
        {
            return std::span<const DataType, NUM_UNSHIFTED_ENTITIES>{ data.data() + (0), NUM_UNSHIFTED_ENTITIES };
        }
        std::span<DataType, NUM_PRECOMPUTED_ENTITIES> get_precomputed()
        {
            return std::span<DataType, NUM_PRECOMPUTED_ENTITIES>{ data.data() + (NUM_MASKING_ENTITIES),
                                                                  NUM_PRECOMPUTED_ENTITIES };
        }
        std::span<const DataType, NUM_PRECOMPUTED_ENTITIES> get_precomputed() const
        {
            return std::span<const DataType, NUM_PRECOMPUTED_ENTITIES>{ data.data() + (NUM_MASKING_ENTITIES),
                                                                        NUM_PRECOMPUTED_ENTITIES };
        }
        std::span<DataType, NUM_WITNESS_ENTITIES> get_witness()
        {
            return std::span<DataType, NUM_WITNESS_ENTITIES>{
                data.data() + (NUM_MASKING_ENTITIES + NUM_PRECOMPUTED_ENTITIES), NUM_WITNESS_ENTITIES
            };
        }
        std::span<const DataType, NUM_WITNESS_ENTITIES> get_witness() const
        {
            return std::span<const DataType, NUM_WITNESS_ENTITIES>{
                data.data() + (NUM_MASKING_ENTITIES + NUM_PRECOMPUTED_ENTITIES), NUM_WITNESS_ENTITIES
            };
        }
        std::span<DataType, NUM_SHIFTED_ENTITIES> get_to_be_shifted()
        {
            return std::span<DataType, NUM_SHIFTED_ENTITIES>{ data.data() + (29), NUM_SHIFTED_ENTITIES };
        }
        std::span<const DataType, NUM_SHIFTED_ENTITIES> get_to_be_shifted() const
        {
            return std::span<const DataType, NUM_SHIFTED_ENTITIES>{ data.data() + (29), NUM_SHIFTED_ENTITIES };
        }
        std::span<DataType, NUM_SHIFTED_ENTITIES> get_shifted()
        {
            return std::span<DataType, NUM_SHIFTED_ENTITIES>{ data.data() + (NUM_UNSHIFTED_ENTITIES),
                                                              NUM_SHIFTED_ENTITIES };
        }
        std::span<const DataType, NUM_SHIFTED_ENTITIES> get_shifted() const
        {
            return std::span<const DataType, NUM_SHIFTED_ENTITIES>{ data.data() + (NUM_UNSHIFTED_ENTITIES),
                                                                    NUM_SHIFTED_ENTITIES };
        }
 
        // Subset views (relation-declared groupings in layout order).
        RefArray<DataType, 4> get_wires()
        {
            return { (*this)[EntityId::w_l], (*this)[EntityId::w_r], (*this)[EntityId::w_o], (*this)[EntityId::w_4] };
        }
        RefArray<const DataType, 4> get_wires() const
        {
            return { (*this)[EntityId::w_l], (*this)[EntityId::w_r], (*this)[EntityId::w_o], (*this)[EntityId::w_4] };
        }
        RefArray<DataType, 7> get_non_gate_selectors()
        {
            return { (*this)[EntityId::q_m], (*this)[EntityId::q_l], (*this)[EntityId::q_r], (*this)[EntityId::q_o],
                     (*this)[EntityId::q_4], (*this)[EntityId::q_c], (*this)[EntityId::q_5] };
        }
        RefArray<const DataType, 7> get_non_gate_selectors() const
        {
            return { (*this)[EntityId::q_m], (*this)[EntityId::q_l], (*this)[EntityId::q_r], (*this)[EntityId::q_o],
                     (*this)[EntityId::q_4], (*this)[EntityId::q_c], (*this)[EntityId::q_5] };
        }
        RefArray<DataType, 9> get_gate_selectors()
        {
            return { (*this)[EntityId::q_arith],
                     (*this)[EntityId::q_bilinear_batched_eq],
                     (*this)[EntityId::q_delta_range],
                     (*this)[EntityId::q_busread],
                     (*this)[EntityId::q_poseidon2_external],
                     (*this)[EntityId::q_poseidon2_external_initial],
                     (*this)[EntityId::q_poseidon2_quad_internal],
                     (*this)[EntityId::q_poseidon2_quad_internal_terminal],
                     (*this)[EntityId::q_poseidon2_transition_entry] };
        }
        RefArray<const DataType, 9> get_gate_selectors() const
        {
            return { (*this)[EntityId::q_arith],
                     (*this)[EntityId::q_bilinear_batched_eq],
                     (*this)[EntityId::q_delta_range],
                     (*this)[EntityId::q_busread],
                     (*this)[EntityId::q_poseidon2_external],
                     (*this)[EntityId::q_poseidon2_external_initial],
                     (*this)[EntityId::q_poseidon2_quad_internal],
                     (*this)[EntityId::q_poseidon2_quad_internal_terminal],
                     (*this)[EntityId::q_poseidon2_transition_entry] };
        }
        RefArray<DataType, 4> get_sigmas()
        {
            return { (*this)[EntityId::sigma_1],
                     (*this)[EntityId::sigma_2],
                     (*this)[EntityId::sigma_3],
                     (*this)[EntityId::sigma_4] };
        }
        RefArray<const DataType, 4> get_sigmas() const
        {
            return { (*this)[EntityId::sigma_1],
                     (*this)[EntityId::sigma_2],
                     (*this)[EntityId::sigma_3],
                     (*this)[EntityId::sigma_4] };
        }
        RefArray<DataType, 4> get_ids()
        {
            return {
                (*this)[EntityId::id_1], (*this)[EntityId::id_2], (*this)[EntityId::id_3], (*this)[EntityId::id_4]
            };
        }
        RefArray<const DataType, 4> get_ids() const
        {
            return {
                (*this)[EntityId::id_1], (*this)[EntityId::id_2], (*this)[EntityId::id_3], (*this)[EntityId::id_4]
            };
        }
        RefArray<DataType, 4> get_ecc_op_wires()
        {
            return { (*this)[EntityId::ecc_op_wire_1],
                     (*this)[EntityId::ecc_op_wire_2],
                     (*this)[EntityId::ecc_op_wire_3],
                     (*this)[EntityId::ecc_op_wire_4] };
        }
        RefArray<const DataType, 4> get_ecc_op_wires() const
        {
            return { (*this)[EntityId::ecc_op_wire_1],
                     (*this)[EntityId::ecc_op_wire_2],
                     (*this)[EntityId::ecc_op_wire_3],
                     (*this)[EntityId::ecc_op_wire_4] };
        }
        RefArray<DataType, 2> get_databus_entities()
        {
            return { (*this)[EntityId::kernel_calldata], (*this)[EntityId::kernel_calldata_read_counts] };
        }
        RefArray<const DataType, 2> get_databus_entities() const
        {
            return { (*this)[EntityId::kernel_calldata], (*this)[EntityId::kernel_calldata_read_counts] };
        }
        RefArray<DataType, 1> get_databus_inverses() { return { (*this)[EntityId::kernel_calldata_inverses] }; }
        RefArray<const DataType, 1> get_databus_inverses() const
        {
            return { (*this)[EntityId::kernel_calldata_inverses] };
        }
        RefArray<DataType, 1> get_databus_indicators() { return { (*this)[EntityId::kernel_calldata_indicator] }; }
        RefArray<const DataType, 1> get_databus_indicators() const
        {
            return { (*this)[EntityId::kernel_calldata_indicator] };
        }
        RefArray<DataType, 1> get_databus_selectors() { return { (*this)[EntityId::q_l] }; }
        RefArray<const DataType, 1> get_databus_selectors() const { return { (*this)[EntityId::q_l] }; }
 
        // Composite views: concatenations of subset views.
        auto get_selectors() { return concatenate(get_non_gate_selectors(), get_gate_selectors()); }
        auto get_selectors() const { return concatenate(get_non_gate_selectors(), get_gate_selectors()); }
 
        // Labels — uppercase, layout order.
        static const std::vector<std::string>& get_labels()
        {
            static const std::vector<std::string> labels = {
                "Q_M",
                "Q_L",
                "Q_R",
                "Q_O",
                "Q_4",
                "Q_C",
                "Q_ARITH",
                "Q_BILINEAR_BATCHED_EQ",
                "SIGMA_1",
                "SIGMA_2",
                "SIGMA_3",
                "SIGMA_4",
                "ID_1",
                "ID_2",
                "ID_3",
                "ID_4",
                "LAGRANGE_FIRST",
                "LAGRANGE_LAST",
                "Q_DELTA_RANGE",
                "LAGRANGE_ECC_OP",
                "Q_BUSREAD",
                "KERNEL_CALLDATA_INDICATOR",
                "DATABUS_ID",
                "Q_POSEIDON2_EXTERNAL",
                "Q_POSEIDON2_EXTERNAL_INITIAL",
                "Q_POSEIDON2_QUAD_INTERNAL",
                "Q_5",
                "Q_POSEIDON2_QUAD_INTERNAL_TERMINAL",
                "Q_POSEIDON2_TRANSITION_ENTRY",
                "W_L",
                "W_R",
                "W_O",
                "W_4",
                "Z_PERM",
                "ECC_OP_WIRE_1",
                "ECC_OP_WIRE_2",
                "ECC_OP_WIRE_3",
                "ECC_OP_WIRE_4",
                "KERNEL_CALLDATA",
                "KERNEL_CALLDATA_READ_COUNTS",
                "KERNEL_CALLDATA_INVERSES",
                "W_L_SHIFT",
                "W_R_SHIFT",
                "W_O_SHIFT",
                "W_4_SHIFT",
                "Z_PERM_SHIFT",
            };
            return labels;
        }
    };
 
    // Verification-key transport class. Owns its own storage; not a slice of AllEntities.
    template <typename DataType_> class PrecomputedEntities {
      public:
        using DataType = DataType_;
        std::array<DataType, NUM_PRECOMPUTED_ENTITIES> data{};
 
        bool operator==(const PrecomputedEntities&) const = default;
 
        std::span<DataType, NUM_PRECOMPUTED_ENTITIES> get_all() { return data; }
        std::span<const DataType, NUM_PRECOMPUTED_ENTITIES> get_all() const { return data; }
 
        static constexpr size_t size() { return NUM_PRECOMPUTED_ENTITIES; }
 
        // Named accessor methods — index into local `data` (NOT the AllEntities layout).
        DataType& q_m() { return data[0]; }
        const DataType& q_m() const { return data[0]; }
        DataType& q_l() { return data[1]; }
        const DataType& q_l() const { return data[1]; }
        DataType& q_r() { return data[2]; }
        const DataType& q_r() const { return data[2]; }
        DataType& q_o() { return data[3]; }
        const DataType& q_o() const { return data[3]; }
        DataType& q_4() { return data[4]; }
        const DataType& q_4() const { return data[4]; }
        DataType& q_c() { return data[5]; }
        const DataType& q_c() const { return data[5]; }
        DataType& q_arith() { return data[6]; }
        const DataType& q_arith() const { return data[6]; }
        DataType& q_bilinear_batched_eq() { return data[7]; }
        const DataType& q_bilinear_batched_eq() const { return data[7]; }
        DataType& sigma_1() { return data[8]; }
        const DataType& sigma_1() const { return data[8]; }
        DataType& sigma_2() { return data[9]; }
        const DataType& sigma_2() const { return data[9]; }
        DataType& sigma_3() { return data[10]; }
        const DataType& sigma_3() const { return data[10]; }
        DataType& sigma_4() { return data[11]; }
        const DataType& sigma_4() const { return data[11]; }
        DataType& id_1() { return data[12]; }
        const DataType& id_1() const { return data[12]; }
        DataType& id_2() { return data[13]; }
        const DataType& id_2() const { return data[13]; }
        DataType& id_3() { return data[14]; }
        const DataType& id_3() const { return data[14]; }
        DataType& id_4() { return data[15]; }
        const DataType& id_4() const { return data[15]; }
        DataType& lagrange_first() { return data[16]; }
        const DataType& lagrange_first() const { return data[16]; }
        DataType& lagrange_last() { return data[17]; }
        const DataType& lagrange_last() const { return data[17]; }
        DataType& q_delta_range() { return data[18]; }
        const DataType& q_delta_range() const { return data[18]; }
        DataType& lagrange_ecc_op() { return data[19]; }
        const DataType& lagrange_ecc_op() const { return data[19]; }
        DataType& q_busread() { return data[20]; }
        const DataType& q_busread() const { return data[20]; }
        DataType& kernel_calldata_indicator() { return data[21]; }
        const DataType& kernel_calldata_indicator() const { return data[21]; }
        DataType& databus_id() { return data[22]; }
        const DataType& databus_id() const { return data[22]; }
        DataType& q_poseidon2_external() { return data[23]; }
        const DataType& q_poseidon2_external() const { return data[23]; }
        DataType& q_poseidon2_external_initial() { return data[24]; }
        const DataType& q_poseidon2_external_initial() const { return data[24]; }
        DataType& q_poseidon2_quad_internal() { return data[25]; }
        const DataType& q_poseidon2_quad_internal() const { return data[25]; }
        DataType& q_5() { return data[26]; }
        const DataType& q_5() const { return data[26]; }
        DataType& q_poseidon2_quad_internal_terminal() { return data[27]; }
        const DataType& q_poseidon2_quad_internal_terminal() const { return data[27]; }
        DataType& q_poseidon2_transition_entry() { return data[28]; }
        const DataType& q_poseidon2_transition_entry() const { return data[28]; }
 
        // Subset views.
        RefArray<DataType, 7> get_non_gate_selectors()
        {
            return { this->q_m(), this->q_l(), this->q_r(), this->q_o(), this->q_4(), this->q_c(), this->q_5() };
        }
        RefArray<const DataType, 7> get_non_gate_selectors() const
        {
            return { this->q_m(), this->q_l(), this->q_r(), this->q_o(), this->q_4(), this->q_c(), this->q_5() };
        }
        RefArray<DataType, 9> get_gate_selectors()
        {
            return { this->q_arith(),
                     this->q_bilinear_batched_eq(),
                     this->q_delta_range(),
                     this->q_busread(),
                     this->q_poseidon2_external(),
                     this->q_poseidon2_external_initial(),
                     this->q_poseidon2_quad_internal(),
                     this->q_poseidon2_quad_internal_terminal(),
                     this->q_poseidon2_transition_entry() };
        }
        RefArray<const DataType, 9> get_gate_selectors() const
        {
            return { this->q_arith(),
                     this->q_bilinear_batched_eq(),
                     this->q_delta_range(),
                     this->q_busread(),
                     this->q_poseidon2_external(),
                     this->q_poseidon2_external_initial(),
                     this->q_poseidon2_quad_internal(),
                     this->q_poseidon2_quad_internal_terminal(),
                     this->q_poseidon2_transition_entry() };
        }
        RefArray<DataType, 4> get_sigmas()
        {
            return { this->sigma_1(), this->sigma_2(), this->sigma_3(), this->sigma_4() };
        }
        RefArray<const DataType, 4> get_sigmas() const
        {
            return { this->sigma_1(), this->sigma_2(), this->sigma_3(), this->sigma_4() };
        }
        RefArray<DataType, 4> get_ids() { return { this->id_1(), this->id_2(), this->id_3(), this->id_4() }; }
        RefArray<const DataType, 4> get_ids() const
        {
            return { this->id_1(), this->id_2(), this->id_3(), this->id_4() };
        }
        RefArray<DataType, 1> get_databus_indicators() { return { this->kernel_calldata_indicator() }; }
        RefArray<const DataType, 1> get_databus_indicators() const { return { this->kernel_calldata_indicator() }; }
        RefArray<DataType, 1> get_databus_selectors() { return { this->q_l() }; }
        RefArray<const DataType, 1> get_databus_selectors() const { return { this->q_l() }; }
 
        // Composite views.
        auto get_selectors() { return concatenate(get_non_gate_selectors(), get_gate_selectors()); }
        auto get_selectors() const { return concatenate(get_non_gate_selectors(), get_gate_selectors()); }
 
        static const std::vector<std::string>& get_labels()
        {
            static const std::vector<std::string> labels = {
                "Q_M",
                "Q_L",
                "Q_R",
                "Q_O",
                "Q_4",
                "Q_C",
                "Q_ARITH",
                "Q_BILINEAR_BATCHED_EQ",
                "SIGMA_1",
                "SIGMA_2",
                "SIGMA_3",
                "SIGMA_4",
                "ID_1",
                "ID_2",
                "ID_3",
                "ID_4",
                "LAGRANGE_FIRST",
                "LAGRANGE_LAST",
                "Q_DELTA_RANGE",
                "LAGRANGE_ECC_OP",
                "Q_BUSREAD",
                "KERNEL_CALLDATA_INDICATOR",
                "DATABUS_ID",
                "Q_POSEIDON2_EXTERNAL",
                "Q_POSEIDON2_EXTERNAL_INITIAL",
                "Q_POSEIDON2_QUAD_INTERNAL",
                "Q_5",
                "Q_POSEIDON2_QUAD_INTERNAL_TERMINAL",
                "Q_POSEIDON2_TRANSITION_ENTRY",
            };
            return labels;
        }
    };
 
    // Prover-commitment transport class (witness only). Owns its own storage.
    template <typename DataType_> class WitnessEntities {
      public:
        using DataType = DataType_;
        std::array<DataType, NUM_WITNESS_ENTITIES> data{};
 
        bool operator==(const WitnessEntities&) const = default;
 
        std::span<DataType, NUM_WITNESS_ENTITIES> get_all() { return data; }
        std::span<const DataType, NUM_WITNESS_ENTITIES> get_all() const { return data; }
 
        static constexpr size_t size() { return NUM_WITNESS_ENTITIES; }
 
        // Named accessor methods — index into local `data` (NOT the AllEntities layout).
        DataType& w_l() { return data[0]; }
        const DataType& w_l() const { return data[0]; }
        DataType& w_r() { return data[1]; }
        const DataType& w_r() const { return data[1]; }
        DataType& w_o() { return data[2]; }
        const DataType& w_o() const { return data[2]; }
        DataType& w_4() { return data[3]; }
        const DataType& w_4() const { return data[3]; }
        DataType& z_perm() { return data[4]; }
        const DataType& z_perm() const { return data[4]; }
        DataType& ecc_op_wire_1() { return data[5]; }
        const DataType& ecc_op_wire_1() const { return data[5]; }
        DataType& ecc_op_wire_2() { return data[6]; }
        const DataType& ecc_op_wire_2() const { return data[6]; }
        DataType& ecc_op_wire_3() { return data[7]; }
        const DataType& ecc_op_wire_3() const { return data[7]; }
        DataType& ecc_op_wire_4() { return data[8]; }
        const DataType& ecc_op_wire_4() const { return data[8]; }
        DataType& kernel_calldata() { return data[9]; }
        const DataType& kernel_calldata() const { return data[9]; }
        DataType& kernel_calldata_read_counts() { return data[10]; }
        const DataType& kernel_calldata_read_counts() const { return data[10]; }
        DataType& kernel_calldata_inverses() { return data[11]; }
        const DataType& kernel_calldata_inverses() const { return data[11]; }
 
        // Subset views.
        RefArray<DataType, 4> get_wires() { return { this->w_l(), this->w_r(), this->w_o(), this->w_4() }; }
        RefArray<const DataType, 4> get_wires() const { return { this->w_l(), this->w_r(), this->w_o(), this->w_4() }; }
        RefArray<DataType, 4> get_ecc_op_wires()
        {
            return { this->ecc_op_wire_1(), this->ecc_op_wire_2(), this->ecc_op_wire_3(), this->ecc_op_wire_4() };
        }
        RefArray<const DataType, 4> get_ecc_op_wires() const
        {
            return { this->ecc_op_wire_1(), this->ecc_op_wire_2(), this->ecc_op_wire_3(), this->ecc_op_wire_4() };
        }
        RefArray<DataType, 2> get_databus_entities()
        {
            return { this->kernel_calldata(), this->kernel_calldata_read_counts() };
        }
        RefArray<const DataType, 2> get_databus_entities() const
        {
            return { this->kernel_calldata(), this->kernel_calldata_read_counts() };
        }
        RefArray<DataType, 1> get_databus_inverses() { return { this->kernel_calldata_inverses() }; }
        RefArray<const DataType, 1> get_databus_inverses() const { return { this->kernel_calldata_inverses() }; }
 
        RefArray<DataType, 5> get_to_be_shifted()
        {
            return { this->w_l(), this->w_r(), this->w_o(), this->w_4(), this->z_perm() };
        }
        RefArray<const DataType, 5> get_to_be_shifted() const
        {
            return { this->w_l(), this->w_r(), this->w_o(), this->w_4(), this->z_perm() };
        }
 
        static const std::vector<std::string>& get_labels()
        {
            static const std::vector<std::string> labels = {
                "W_L",
                "W_R",
                "W_O",
                "W_4",
                "Z_PERM",
                "ECC_OP_WIRE_1",
                "ECC_OP_WIRE_2",
                "ECC_OP_WIRE_3",
                "ECC_OP_WIRE_4",
                "KERNEL_CALLDATA",
                "KERNEL_CALLDATA_READ_COUNTS",
                "KERNEL_CALLDATA_INVERSES",
            };
            return labels;
        }
    };
};
 
} // namespace bb