hypernova_recursion_constraint.cpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: Complete, auditors: [Sergei], commit: }
// external_1:  { status: not started, auditors: [], commit: }
// external_2:  { status: not started, auditors: [], commit: }
// =====================
#include "hypernova_recursion_constraint.hpp"
#include "barretenberg/common/assert.hpp"
#include "barretenberg/common/throw_or_abort.hpp"
#include "barretenberg/dsl/acir_format/mock_verifier_inputs.hpp"
 
namespace acir_format {
 
using namespace bb;
 
std::shared_ptr<Chonk> create_mock_chonk_from_constraints(const std::vector<RecursionConstraint>& constraints)
{
    auto ivc = std::make_shared<Chonk>(std::max(constraints.size(), static_cast<size_t>(MAX_APPS_PER_KERNEL + 1)));
    // Check constraint proof type. Throws if proof_type is not a valid HyperNova type
    auto constraint_has_type = [](const RecursionConstraint& c, Chonk::QUEUE_TYPE expected) {
        return proof_type_to_chonk_queue_type(c.proof_type) == expected;
    };
 
    BB_ASSERT(!constraints.empty(), "At least one recursion constraint is required to determine Chonk state");
    const bool is_init = constraint_has_type(constraints[0], Chonk::QUEUE_TYPE::OINK);
    const bool is_reset = (constraints.size() == 1 && constraint_has_type(constraints[0], Chonk::QUEUE_TYPE::HN));
    const bool is_tail = (constraints.size() == 1 && constraint_has_type(constraints[0], Chonk::QUEUE_TYPE::HN_TAIL));
    const bool is_hiding =
        (constraints.size() == 1 && constraint_has_type(constraints[0], Chonk::QUEUE_TYPE::HN_FINAL));
    const size_t upper_bound = is_init ? MAX_APPS_PER_KERNEL : MAX_APPS_PER_KERNEL + 1;
    BB_ASSERT_LTE(constraints.size(), upper_bound, "Too many recursion constraints encountered when mocking IVC state");
 
    // Match constraint patterns to kernel types and populate appropriate mock data:
 
    // INIT kernel: Verifies first app circuit (no prior accumulator exists)
    if (is_init) {
        mock_chonk_accumulation(ivc, Chonk::QUEUE_TYPE::OINK, /*is_kernel=*/false);
        for (size_t idx = 1; idx < constraints.size(); idx++) {
            BB_ASSERT(constraint_has_type(constraints[idx], Chonk::QUEUE_TYPE::HN),
                      "Subsequent constraints in init kernel must be HN type");
            mock_chonk_accumulation(ivc, Chonk::QUEUE_TYPE::HN, /*is_kernel=*/false);
        }
        return ivc;
    }
 
    // RESET kernel: Verifies only a previous kernel (resets the IVC accumulation)
    if (is_reset) {
        mock_chonk_accumulation(ivc, Chonk::QUEUE_TYPE::HN, /*is_kernel=*/true);
        return ivc;
    }
 
    // TAIL kernel: Final kernel in the chain before hiding kernel
    if (is_tail) {
        mock_chonk_accumulation(ivc, Chonk::QUEUE_TYPE::HN_TAIL, /*is_kernel=*/true);
        return ivc;
    }
 
    // HIDING kernel: Adds zero-knowledge hiding to the final proof
    if (is_hiding) {
        mock_chonk_accumulation(ivc, Chonk::QUEUE_TYPE::HN_FINAL, /*is_kernel=*/true);
        return ivc;
    }
 
    // INNER kernel: Verifies previous kernel + app circuits
    bool is_kernel = true;
    for (const auto& constraint : constraints) {
        BB_ASSERT(constraint_has_type(constraint, Chonk::QUEUE_TYPE::HN),
                  "All constraints in inner kernel must be HN type");
        mock_chonk_accumulation(ivc, Chonk::QUEUE_TYPE::HN, /*is_kernel=*/is_kernel);
        is_kernel = false; // First constraint verifies previous kernel, subsequent constraints verify apps
    }
    return ivc;
}
 
Chonk::VerifierInputs create_mock_verification_queue_entry(const Chonk::QUEUE_TYPE verification_type,
                                                           const bool is_kernel)
{
    using IvcType = Chonk;
    using FF = IvcType::FF;
    using MegaVerificationKey = IvcType::MegaVerificationKey;
    using Flavor = IvcType::Flavor;
 
    size_t dyadic_size = 1 << Flavor::VIRTUAL_LOG_N; // maybe doesnt need to be correct
 
    std::vector<FF> proof;
    std::shared_ptr<MegaVerificationKey> verification_key;
 
    if (is_kernel) {
        using KernelIO = stdlib::recursion::honk::KernelIO;
        BB_ASSERT_EQ(verification_type == Chonk::QUEUE_TYPE::HN || verification_type == Chonk::QUEUE_TYPE::HN_TAIL ||
                         verification_type == Chonk::QUEUE_TYPE::HN_FINAL,
                     true);
 
        // Kernel circuits always have a prior accumulator, so fold proof is always included
        constexpr bool include_fold = true;
        proof = create_mock_hyper_nova_proof<Flavor, KernelIO>(include_fold);
 
        verification_key = create_mock_honk_vk<Flavor, KernelIO>(dyadic_size);
    } else {
        using AppIO = stdlib::recursion::honk::AppIO;
        BB_ASSERT_EQ(verification_type == Chonk::QUEUE_TYPE::OINK || verification_type == Chonk::QUEUE_TYPE::HN, true);
 
        // First app (OINK) has no prior accumulator; subsequent apps (HN) do
        bool include_fold = (verification_type != Chonk::QUEUE_TYPE::OINK);
        proof = create_mock_hyper_nova_proof<Flavor, AppIO>(include_fold);
 
        verification_key = create_mock_honk_vk<Flavor, AppIO>(dyadic_size);
    }
 
    return Chonk::VerifierInputs{ proof, verification_key, verification_type, is_kernel };
}
 
void mock_chonk_accumulation(const std::shared_ptr<Chonk>& ivc, Chonk::QUEUE_TYPE type, const bool is_kernel)
{
    using FF = Chonk::FF;
    using Commitment = Chonk::Commitment;
 
    // Initialize verifier accumulator with proper structure
    ivc->recursive_verifier_native_accum.challenge = std::vector<FF>(Chonk::Flavor::VIRTUAL_LOG_N, FF::zero());
    ivc->recursive_verifier_native_accum.non_shifted_evaluation = FF::zero();
    ivc->recursive_verifier_native_accum.shifted_evaluation = FF::zero();
    ivc->recursive_verifier_native_accum.non_shifted_commitment = Commitment::one();
    ivc->recursive_verifier_native_accum.shifted_commitment = Commitment::one();
 
    Chonk::VerifierInputs entry = acir_format::create_mock_verification_queue_entry(type, is_kernel);
    ivc->verification_queue.emplace_back(entry);
    if (type == Chonk::QUEUE_TYPE::HN_FINAL) {
        ivc->goblin.batch_merge_proof = acir_format::create_mock_batch_merge_proof();
        ivc->decider_proof = acir_format::create_mock_pcs_proof<Chonk::Flavor>();
    }
    ivc->num_circuits_accumulated++;
}
 
} // namespace acir_format