ultra_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/ultra_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/delta_range_constraint_relation.hpp"
#include "barretenberg/relations/elliptic_relation.hpp"
#include "barretenberg/relations/logderiv_lookup_relation.hpp"
#include "barretenberg/relations/memory_relation.hpp"
#include "barretenberg/relations/non_native_field_relation.hpp"
#include "barretenberg/relations/permutation_relation.hpp"
#include "barretenberg/relations/poseidon2_external_relation.hpp"
#include "barretenberg/relations/poseidon2_internal_relation.hpp"
#include "barretenberg/relations/ultra_arithmetic_relation.hpp"
 
namespace bb {
 
class UltraZKFlavor_Generated {
  public:
    // Dense flavor-local entity index. Layout: [masking | precomputed | witness | shifted].
    enum class EntityId : uint16_t {
        gemini_masking_poly = 0,
        sigma_1 = 1,
        sigma_2 = 2,
        sigma_3 = 3,
        sigma_4 = 4,
        id_1 = 5,
        id_2 = 6,
        id_3 = 7,
        id_4 = 8,
        lagrange_first = 9,
        lagrange_last = 10,
        q_lookup = 11,
        table_1 = 12,
        table_2 = 13,
        table_3 = 14,
        table_4 = 15,
        q_m = 16,
        q_r = 17,
        q_o = 18,
        q_c = 19,
        q_l = 20,
        q_4 = 21,
        q_arith = 22,
        q_delta_range = 23,
        q_elliptic = 24,
        q_memory = 25,
        q_nnf = 26,
        q_poseidon2_external = 27,
        q_poseidon2_internal = 28,
        w_l = 29,
        w_r = 30,
        w_o = 31,
        w_4 = 32,
        z_perm = 33,
        lookup_inverses = 34,
        lookup_read_counts = 35,
        lookup_read_tags = 36,
        w_l_shift = 37,
        w_r_shift = 38,
        w_o_shift = 39,
        w_4_shift = 40,
        z_perm_shift = 41,
    };
 
    // Sumcheck relation tuple. Source of truth is
    // flavor-codegen/src/flavors/ultra_zk.ts; structural relations are omitted.
    template <typename FF>
    using Relations_ = std::tuple<bb::UltraPermutationRelation<FF>,
                                  bb::LogDerivLookupRelation<FF>,
                                  bb::ArithmeticRelation<FF>,
                                  bb::DeltaRangeConstraintRelation<FF>,
                                  bb::EllipticRelation<FF>,
                                  bb::MemoryRelation<FF>,
                                  bb::NonNativeFieldRelation<FF>,
                                  bb::Poseidon2ExternalRelation<FF>,
                                  bb::Poseidon2InternalRelation<FF>>;
 
    static constexpr size_t NUM_PRECOMPUTED_ENTITIES = 28;
    static constexpr size_t NUM_WITNESS_ENTITIES = 8;
    static constexpr size_t NUM_MASKING_ENTITIES = 1;
    static constexpr size_t NUM_SHIFTED_ENTITIES = 5;
    static constexpr bool HasDataBus = false;
    static constexpr size_t NUM_BUS_COLUMNS = 0;
    static constexpr bool HasLogDerivLookup = true;
    static constexpr bool HasElliptic = true;
    static constexpr bool HasMemory = true;
    static constexpr bool HasNonNativeField = true;
    static constexpr bool HasEccOpQueue = false;
    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, 37 }, DuplicatePair{ 30, 38 }, DuplicatePair{ 31, 39 },
        DuplicatePair{ 32, 40 }, DuplicatePair{ 33, 41 },
    };
    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, 8>(std::array<BlockBase*, 8>{
            &blocks.lookup,
            &blocks.arithmetic,
            &blocks.delta_range,
            &blocks.elliptic,
            &blocks.memory,
            &blocks.nnf,
            &blocks.poseidon2_external,
            &blocks.poseidon2_internal,
        });
    }
 
    template <typename TraceBlocks> static auto get_gate_blocks(TraceBlocks const& blocks)
    {
        using BlockBase = typename TraceBlocks::BlockBase;
        return RefArray<const BlockBase, 8>(std::array<const BlockBase*, 8>{
            &blocks.lookup,
            &blocks.arithmetic,
            &blocks.delta_range,
            &blocks.elliptic,
            &blocks.memory,
            &blocks.nnf,
            &blocks.poseidon2_external,
            &blocks.poseidon2_internal,
        });
    }
 
    // GateKind for each gate selector, parallel to `get_gate_blocks()`.
    static constexpr std::array<GateKind, 8> GATE_KINDS{
        GateKind::Lookup, GateKind::Arith, GateKind::DeltaRange,   GateKind::Elliptic,
        GateKind::Memory, GateKind::Nnf,   GateKind::Poseidon2Ext, GateKind::Poseidon2Int,
    };
 
    // 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, 6>{
            block.q_m(), block.q_1(), block.q_2(), block.q_3(), block.q_4(), block.q_c(),
        };
    }
 
    // AllEntities: flat `std::array` storage with EntityId-keyed access and named accessors.
    template <typename DataType> class AllEntities {
      public:
        using EntityId = UltraZKFlavor_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& gemini_masking_poly() { return data[static_cast<size_t>(EntityId::gemini_masking_poly)]; }
        const DataType& gemini_masking_poly() const { return data[static_cast<size_t>(EntityId::gemini_masking_poly)]; }
        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_lookup() { return data[static_cast<size_t>(EntityId::q_lookup)]; }
        const DataType& q_lookup() const { return data[static_cast<size_t>(EntityId::q_lookup)]; }
        DataType& table_1() { return data[static_cast<size_t>(EntityId::table_1)]; }
        const DataType& table_1() const { return data[static_cast<size_t>(EntityId::table_1)]; }
        DataType& table_2() { return data[static_cast<size_t>(EntityId::table_2)]; }
        const DataType& table_2() const { return data[static_cast<size_t>(EntityId::table_2)]; }
        DataType& table_3() { return data[static_cast<size_t>(EntityId::table_3)]; }
        const DataType& table_3() const { return data[static_cast<size_t>(EntityId::table_3)]; }
        DataType& table_4() { return data[static_cast<size_t>(EntityId::table_4)]; }
        const DataType& table_4() const { return data[static_cast<size_t>(EntityId::table_4)]; }
        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_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_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_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_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_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_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& q_elliptic() { return data[static_cast<size_t>(EntityId::q_elliptic)]; }
        const DataType& q_elliptic() const { return data[static_cast<size_t>(EntityId::q_elliptic)]; }
        DataType& q_memory() { return data[static_cast<size_t>(EntityId::q_memory)]; }
        const DataType& q_memory() const { return data[static_cast<size_t>(EntityId::q_memory)]; }
        DataType& q_nnf() { return data[static_cast<size_t>(EntityId::q_nnf)]; }
        const DataType& q_nnf() const { return data[static_cast<size_t>(EntityId::q_nnf)]; }
        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_internal() { return data[static_cast<size_t>(EntityId::q_poseidon2_internal)]; }
        const DataType& q_poseidon2_internal() const
        {
            return data[static_cast<size_t>(EntityId::q_poseidon2_internal)];
        }
        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& lookup_inverses() { return data[static_cast<size_t>(EntityId::lookup_inverses)]; }
        const DataType& lookup_inverses() const { return data[static_cast<size_t>(EntityId::lookup_inverses)]; }
        DataType& lookup_read_counts() { return data[static_cast<size_t>(EntityId::lookup_read_counts)]; }
        const DataType& lookup_read_counts() const { return data[static_cast<size_t>(EntityId::lookup_read_counts)]; }
        DataType& lookup_read_tags() { return data[static_cast<size_t>(EntityId::lookup_read_tags)]; }
        const DataType& lookup_read_tags() const { return data[static_cast<size_t>(EntityId::lookup_read_tags)]; }
        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_MASKING_ENTITIES> get_masking()
        {
            return std::span<DataType, NUM_MASKING_ENTITIES>{ data.data() + (0), NUM_MASKING_ENTITIES };
        }
        std::span<const DataType, NUM_MASKING_ENTITIES> get_masking() const
        {
            return std::span<const DataType, NUM_MASKING_ENTITIES>{ data.data() + (0), NUM_MASKING_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_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, 8> get_gate_selectors()
        {
            return { (*this)[EntityId::q_lookup],
                     (*this)[EntityId::q_arith],
                     (*this)[EntityId::q_delta_range],
                     (*this)[EntityId::q_elliptic],
                     (*this)[EntityId::q_memory],
                     (*this)[EntityId::q_nnf],
                     (*this)[EntityId::q_poseidon2_external],
                     (*this)[EntityId::q_poseidon2_internal] };
        }
        RefArray<const DataType, 8> get_gate_selectors() const
        {
            return { (*this)[EntityId::q_lookup],
                     (*this)[EntityId::q_arith],
                     (*this)[EntityId::q_delta_range],
                     (*this)[EntityId::q_elliptic],
                     (*this)[EntityId::q_memory],
                     (*this)[EntityId::q_nnf],
                     (*this)[EntityId::q_poseidon2_external],
                     (*this)[EntityId::q_poseidon2_internal] };
        }
        RefArray<DataType, 4> get_tables()
        {
            return { (*this)[EntityId::table_1],
                     (*this)[EntityId::table_2],
                     (*this)[EntityId::table_3],
                     (*this)[EntityId::table_4] };
        }
        RefArray<const DataType, 4> get_tables() const
        {
            return { (*this)[EntityId::table_1],
                     (*this)[EntityId::table_2],
                     (*this)[EntityId::table_3],
                     (*this)[EntityId::table_4] };
        }
        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, 6> 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] };
        }
        RefArray<const DataType, 6> 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] };
        }
 
        // 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 = {
                "GEMINI_MASKING_POLY",
                "SIGMA_1",
                "SIGMA_2",
                "SIGMA_3",
                "SIGMA_4",
                "ID_1",
                "ID_2",
                "ID_3",
                "ID_4",
                "LAGRANGE_FIRST",
                "LAGRANGE_LAST",
                "Q_LOOKUP",
                "TABLE_1",
                "TABLE_2",
                "TABLE_3",
                "TABLE_4",
                "Q_M",
                "Q_R",
                "Q_O",
                "Q_C",
                "Q_L",
                "Q_4",
                "Q_ARITH",
                "Q_DELTA_RANGE",
                "Q_ELLIPTIC",
                "Q_MEMORY",
                "Q_NNF",
                "Q_POSEIDON2_EXTERNAL",
                "Q_POSEIDON2_INTERNAL",
                "W_L",
                "W_R",
                "W_O",
                "W_4",
                "Z_PERM",
                "LOOKUP_INVERSES",
                "LOOKUP_READ_COUNTS",
                "LOOKUP_READ_TAGS",
                "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& sigma_1() { return data[0]; }
        const DataType& sigma_1() const { return data[0]; }
        DataType& sigma_2() { return data[1]; }
        const DataType& sigma_2() const { return data[1]; }
        DataType& sigma_3() { return data[2]; }
        const DataType& sigma_3() const { return data[2]; }
        DataType& sigma_4() { return data[3]; }
        const DataType& sigma_4() const { return data[3]; }
        DataType& id_1() { return data[4]; }
        const DataType& id_1() const { return data[4]; }
        DataType& id_2() { return data[5]; }
        const DataType& id_2() const { return data[5]; }
        DataType& id_3() { return data[6]; }
        const DataType& id_3() const { return data[6]; }
        DataType& id_4() { return data[7]; }
        const DataType& id_4() const { return data[7]; }
        DataType& lagrange_first() { return data[8]; }
        const DataType& lagrange_first() const { return data[8]; }
        DataType& lagrange_last() { return data[9]; }
        const DataType& lagrange_last() const { return data[9]; }
        DataType& q_lookup() { return data[10]; }
        const DataType& q_lookup() const { return data[10]; }
        DataType& table_1() { return data[11]; }
        const DataType& table_1() const { return data[11]; }
        DataType& table_2() { return data[12]; }
        const DataType& table_2() const { return data[12]; }
        DataType& table_3() { return data[13]; }
        const DataType& table_3() const { return data[13]; }
        DataType& table_4() { return data[14]; }
        const DataType& table_4() const { return data[14]; }
        DataType& q_m() { return data[15]; }
        const DataType& q_m() const { return data[15]; }
        DataType& q_r() { return data[16]; }
        const DataType& q_r() const { return data[16]; }
        DataType& q_o() { return data[17]; }
        const DataType& q_o() const { return data[17]; }
        DataType& q_c() { return data[18]; }
        const DataType& q_c() const { return data[18]; }
        DataType& q_l() { return data[19]; }
        const DataType& q_l() const { return data[19]; }
        DataType& q_4() { return data[20]; }
        const DataType& q_4() const { return data[20]; }
        DataType& q_arith() { return data[21]; }
        const DataType& q_arith() const { return data[21]; }
        DataType& q_delta_range() { return data[22]; }
        const DataType& q_delta_range() const { return data[22]; }
        DataType& q_elliptic() { return data[23]; }
        const DataType& q_elliptic() const { return data[23]; }
        DataType& q_memory() { return data[24]; }
        const DataType& q_memory() const { return data[24]; }
        DataType& q_nnf() { return data[25]; }
        const DataType& q_nnf() const { return data[25]; }
        DataType& q_poseidon2_external() { return data[26]; }
        const DataType& q_poseidon2_external() const { return data[26]; }
        DataType& q_poseidon2_internal() { return data[27]; }
        const DataType& q_poseidon2_internal() const { return data[27]; }
 
        // Subset views.
        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, 8> get_gate_selectors()
        {
            return { this->q_lookup(), this->q_arith(), this->q_delta_range(),        this->q_elliptic(),
                     this->q_memory(), this->q_nnf(),   this->q_poseidon2_external(), this->q_poseidon2_internal() };
        }
        RefArray<const DataType, 8> get_gate_selectors() const
        {
            return { this->q_lookup(), this->q_arith(), this->q_delta_range(),        this->q_elliptic(),
                     this->q_memory(), this->q_nnf(),   this->q_poseidon2_external(), this->q_poseidon2_internal() };
        }
        RefArray<DataType, 4> get_tables()
        {
            return { this->table_1(), this->table_2(), this->table_3(), this->table_4() };
        }
        RefArray<const DataType, 4> get_tables() const
        {
            return { this->table_1(), this->table_2(), this->table_3(), this->table_4() };
        }
        RefArray<DataType, 6> get_non_gate_selectors()
        {
            return { this->q_m(), this->q_l(), this->q_r(), this->q_o(), this->q_4(), this->q_c() };
        }
        RefArray<const DataType, 6> get_non_gate_selectors() const
        {
            return { this->q_m(), this->q_l(), this->q_r(), this->q_o(), this->q_4(), this->q_c() };
        }
 
        // 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 = {
                "SIGMA_1",
                "SIGMA_2",
                "SIGMA_3",
                "SIGMA_4",
                "ID_1",
                "ID_2",
                "ID_3",
                "ID_4",
                "LAGRANGE_FIRST",
                "LAGRANGE_LAST",
                "Q_LOOKUP",
                "TABLE_1",
                "TABLE_2",
                "TABLE_3",
                "TABLE_4",
                "Q_M",
                "Q_R",
                "Q_O",
                "Q_C",
                "Q_L",
                "Q_4",
                "Q_ARITH",
                "Q_DELTA_RANGE",
                "Q_ELLIPTIC",
                "Q_MEMORY",
                "Q_NNF",
                "Q_POSEIDON2_EXTERNAL",
                "Q_POSEIDON2_INTERNAL",
            };
            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& lookup_inverses() { return data[5]; }
        const DataType& lookup_inverses() const { return data[5]; }
        DataType& lookup_read_counts() { return data[6]; }
        const DataType& lookup_read_counts() const { return data[6]; }
        DataType& lookup_read_tags() { return data[7]; }
        const DataType& lookup_read_tags() const { return data[7]; }
 
        // 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, 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", "LOOKUP_INVERSES", "LOOKUP_READ_COUNTS", "LOOKUP_READ_TAGS",
            };
            return labels;
        }
    };
};
 
} // namespace bb