proof_length.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 "barretenberg/constants.hpp"
#include "barretenberg/ecc/fields/field_conversion.hpp"
#include "barretenberg/flavor/flavor.hpp"
#include <cstddef>
 
namespace bb::ProofLength {
 
template <typename Flavor> struct CodecConstants {
    using Codec = typename Flavor::Codec;
    using Commitment = typename Flavor::Commitment;
    using FF = typename Flavor::FF;
 
    static constexpr size_t num_frs_in_comm = Codec::template calc_num_fields<Commitment>();
    static constexpr size_t num_frs_in_scalar = Codec::template calc_num_fields<FF>();
};
 
template <typename Flavor> struct Oink : CodecConstants<Flavor> {
    using CodecConstants<Flavor>::num_frs_in_comm;
 
    static constexpr size_t LENGTH_WITHOUT_PUB_INPUTS = Flavor::NUM_WITNESS_ENTITIES * num_frs_in_comm;
};
 
template <typename Flavor> struct Sumcheck : CodecConstants<Flavor> {
    using CodecConstants<Flavor>::num_frs_in_scalar;
    using CodecConstants<Flavor>::num_frs_in_comm;
 
    static constexpr size_t LENGTH(size_t log_n)
    {
        size_t base_length =
            /* univariates */ (log_n * Flavor::BATCHED_RELATION_PARTIAL_LENGTH * num_frs_in_scalar) +
            /* evaluations */ (Flavor::NUM_ALL_ENTITIES * num_frs_in_scalar);
 
        if constexpr (Flavor::HasZK) {
            // Libra adds: concatenation_commitment, grand_sum_commitment, quotient_commitment (3 comms)
            //           + Sum, claimed_evaluation (2 scalars)
            return base_length + (3 * num_frs_in_comm) + (2 * num_frs_in_scalar);
        } else {
            return base_length;
        }
    }
};
 
template <typename Flavor> struct Shplemini : CodecConstants<Flavor> {
    using CodecConstants<Flavor>::num_frs_in_scalar;
    using CodecConstants<Flavor>::num_frs_in_comm;
 
    static constexpr size_t LENGTH(size_t log_n)
    {
        size_t base_length =
            /* Gemini:FOLD_1..FOLD_{log_n-1} */ ((log_n - 1) * num_frs_in_comm) +
            /* Gemini:a_1..a_{log_n} */ (log_n * num_frs_in_scalar) +
            /* Shplonk:Q */ num_frs_in_comm +
            /* KZG:W */ num_frs_in_comm;
 
        if constexpr (Flavor::HasZK) {
            // ZK adds: Libra evaluations (concatenation, shifted_grand_sum, grand_sum, quotient)
            return base_length + (NUM_SMALL_IPA_EVALUATIONS * num_frs_in_scalar);
        } else {
            return base_length;
        }
    }
};
 
template <typename Flavor> struct Honk {
    static constexpr size_t LENGTH_WITHOUT_PUB_INPUTS(size_t log_n)
    {
        return Oink<Flavor>::LENGTH_WITHOUT_PUB_INPUTS + Sumcheck<Flavor>::LENGTH(log_n) +
               Shplemini<Flavor>::LENGTH(log_n);
    }
 
    static size_t derive_num_public_inputs(size_t proof_size, size_t log_n)
    {
        const size_t overhead = LENGTH_WITHOUT_PUB_INPUTS(log_n);
        BB_ASSERT_GTE(proof_size, overhead, "Honk proof too short to derive num_public_inputs");
        return proof_size - overhead;
    }
 
    template <typename IO> static constexpr size_t expected_proof_size(size_t log_n)
    {
        size_t size = IO::PUBLIC_INPUTS_SIZE + LENGTH_WITHOUT_PUB_INPUTS(log_n);
        if constexpr (IO::HasIPA) {
            size += IPA_PROOF_LENGTH;
        }
        return size;
    }
};
 
template <typename Flavor> struct HypernovaInstanceToAccum {
    static constexpr size_t LENGTH_WITHOUT_PUB_INPUTS(size_t log_n)
    {
        return Oink<Flavor>::LENGTH_WITHOUT_PUB_INPUTS + Sumcheck<Flavor>::LENGTH(log_n);
    }
 
    static size_t derive_num_public_inputs(size_t proof_size, size_t log_n)
    {
        const size_t overhead = LENGTH_WITHOUT_PUB_INPUTS(log_n);
        BB_ASSERT_GTE(proof_size, overhead, "HypernovaInstanceToAccum proof too short to derive num_public_inputs");
        return proof_size - overhead;
    }
};
 
template <typename Flavor> struct MultilinearBatching : CodecConstants<Flavor> {
    using CodecConstants<Flavor>::num_frs_in_scalar;
    using CodecConstants<Flavor>::num_frs_in_comm;
 
    static constexpr size_t LENGTH =
        /* accumulator commitments (non_shifted + shifted) */ (Flavor::NUM_ACCUMULATOR_COMMITMENTS * num_frs_in_comm) +
        /* multivariate challenges */ (Flavor::VIRTUAL_LOG_N * num_frs_in_scalar) +
        /* accumulator evaluations (non_shifted + shifted) */
        (Flavor::NUM_ACCUMULATOR_EVALUATIONS * num_frs_in_scalar) + Sumcheck<Flavor>::LENGTH(Flavor::VIRTUAL_LOG_N);
};
 
template <typename Flavor, typename BatchingFlavor> struct HypernovaFolding {
    static constexpr size_t LENGTH_WITHOUT_PUB_INPUTS(size_t log_n)
    {
        return HypernovaInstanceToAccum<Flavor>::LENGTH_WITHOUT_PUB_INPUTS(log_n) +
               MultilinearBatching<BatchingFlavor>::LENGTH;
    }
 
    static size_t derive_num_public_inputs(size_t proof_size, size_t log_n)
    {
        const size_t overhead = LENGTH_WITHOUT_PUB_INPUTS(log_n);
        BB_ASSERT_GTE(proof_size, overhead, "HypernovaFolding proof too short to derive num_public_inputs");
        return proof_size - overhead;
    }
};
 
} // namespace bb::ProofLength