translator_proving_key.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Planned, auditors: [], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
 
#pragma once
#include <utility>
 
#include "barretenberg/common/assert.hpp"
#include "barretenberg/translator_vm/translator_flavor.hpp"
namespace bb {
// Bound to the short-monomial flavor to match TranslatorProver. The proving key uses no relations (only flavor
// entity/constant definitions, which the short-monomial flavor inherits unchanged from TranslatorFlavor), so the
// choice is functionally immaterial -- it just keeps the prover and proving key on a single flavor.
class TranslatorProvingKey {
  public:
    using Flavor = TranslatorShortMonomialFlavor;
    using Circuit = typename Flavor::CircuitBuilder;
    using FF = typename Flavor::FF;
    using BF = typename Flavor::BF;
    using ProvingKey = typename Flavor::ProvingKey;
    using Polynomial = typename Flavor::Polynomial;
    using ProverPolynomials = typename Flavor::ProverPolynomials;
    static constexpr size_t mini_circuit_dyadic_size = Flavor::MINI_CIRCUIT_SIZE;
    // The actual circuit size is several times bigger than the trace in the circuit, because we use concatenation
    // to bring the degree of relations down, while extending the length.
    static constexpr size_t dyadic_circuit_size = mini_circuit_dyadic_size * Flavor::CONCATENATION_GROUP_SIZE;
 
    // Real mini and full circuit sizes i.e. the number of rows excluding those reserved for randomness (to achieve
    // hiding of polynomial commitments and evaluation). Bound to change, but it has to be even as translator works two
    // rows at a time
    static constexpr size_t dyadic_mini_circuit_size_without_masking =
        mini_circuit_dyadic_size - Flavor::NUM_MASKED_ROWS_END;
    static constexpr size_t dyadic_circuit_size_without_masking =
        dyadic_circuit_size - Flavor::NUM_MASKED_ROWS_END * Flavor::CONCATENATION_GROUP_SIZE;
 
    std::shared_ptr<ProvingKey> proving_key;
 
    BF batching_challenge_v = { 0 };
    BF evaluation_input_x = { 0 };
 
    TranslatorProvingKey() = default;
 
    TranslatorProvingKey(const Circuit& circuit)
        : batching_challenge_v(circuit.batching_challenge_v)
        , evaluation_input_x(circuit.evaluation_input_x)
    {
        BB_BENCH_NAME("TranslatorProvingKey(TranslatorCircuit&)");
        // Check that the Translator Circuit does not exceed the fixed upper bound, the current value amounts to
        // a number of EccOps sufficient for 28 app circuits
        vinfo("Translator circuit size: ", circuit.num_gates());
        BB_ASSERT_LTE(circuit.num_gates(),
                      Flavor::MINI_CIRCUIT_SIZE,
                      "The Translator circuit size has exceeded the fixed upper bound");
 
        proving_key = std::make_shared<ProvingKey>();
        auto wires = proving_key->polynomials.get_wires();
        // Distribute wires across threads (one task per wire) rather than multithreading within each wire.
        parallel_for(wires.size(), [&](size_t wire_idx) {
            auto& wire_poly = wires[wire_idx];
            const auto& wire = circuit.wires[wire_idx];
            for (size_t i = 0; i < circuit.num_gates(); i++) {
                if (i >= wire_poly.start_index() && i < wire_poly.end_index()) {
                    wire_poly.at(i) = circuit.get_variable(wire[i]);
                } else {
                    BB_ASSERT_EQ(circuit.get_variable(wire[i]), 0);
                }
            }
        });
 
        // Iterate over all circuit wire polynomials, except the ones representing the op queue, and add random values
        // at the end.
        for (size_t idx = Flavor::NUM_OP_QUEUE_WIRES; idx < wires.size(); idx++) {
            auto& wire = wires[idx];
            for (size_t i = wire.end_index() - NUM_DISABLED_ROWS_IN_SUMCHECK; i < wire.end_index(); i++) {
                wire.at(i) = FF::random_element();
            }
        }
 
        compute_lagrange_polynomials();
 
        // Construct the extra range constraint numerator which contains all the additional values in ordered range
        // constraints not present in the concatenated polynomials
        // NB this will always have a fixed size unless we change the allowed range
        compute_extra_range_constraint_numerator();
 
        // Construct the concatenated polynomials from the groups of minicircuit wires
        compute_concatenated_polynomials();
 
        // Construct the ordered polynomials, containing the values of the concatenated polynomials + enough values to
        // bridge the range from 0 to 3 (3 is the maximum difference between two consecutive values in the ordered range
        // constraint).
        compute_translator_range_constraint_ordered_polynomials();
    };
 
    static std::array<size_t, Flavor::SORTED_STEPS_COUNT> get_sorted_steps()
    {
        static const std::array<size_t, Flavor::SORTED_STEPS_COUNT> sorted_elements = [] {
            std::array<size_t, Flavor::SORTED_STEPS_COUNT> inner_array{};
 
            // The value we have to end polynomials with, 2¹⁴ - 1
            const size_t max_value = (1 << Flavor::MICRO_LIMB_BITS) - 1;
 
            parallel_for([&](const ThreadChunk& chunk) {
                for (size_t idx : chunk.range(Flavor::SORTED_STEPS_COUNT)) {
                    inner_array[idx] = max_value - Flavor::SORT_STEP * idx;
                }
            });
 
            return inner_array;
        }();
 
        return sorted_elements;
    }
 
    void compute_lagrange_polynomials();
 
    void compute_extra_range_constraint_numerator();
 
    void compute_translator_range_constraint_ordered_polynomials();
 
    void compute_concatenated_polynomials();
 
    void split_concatenated_random_coefficients_to_ordered();
};
} // namespace bb