test_class_predicate.hpp

Go to the documentation of this file.

// === AUDIT STATUS ===
// internal:    { status: not started, auditors: [], date: YYYY-MM-DD }
// external_1:  { status: not started, auditors: [], date: YYYY-MM-DD }
// external_2:  { status: not started, auditors: [], date: YYYY-MM-DD }
// =====================
 
#pragma once
 
#include "barretenberg/dsl/acir_format/acir_format.hpp"
#include "barretenberg/dsl/acir_format/acir_format_mocks.hpp"
#include "barretenberg/dsl/acir_format/test_class.hpp"
#include "barretenberg/stdlib/primitives/field/field.hpp"
#include "gtest/gtest.h"
#include <vector>
 
namespace acir_format {
 
using namespace bb;
using namespace bb::stdlib;
 
enum class PredicateTestCase : uint8_t { ConstantTrue, WitnessTrue, WitnessFalse };
 
template <typename InvalidWitnessTarget> struct Predicate {
    PredicateTestCase test_case;
    InvalidWitnessTarget invalid_witness;
 
    std::vector<PredicateTestCase> static get_all()
    {
        return { PredicateTestCase::ConstantTrue, PredicateTestCase::WitnessTrue, PredicateTestCase::WitnessFalse };
    }
 
    std::vector<std::string> static get_labels() { return { "ConstantTrue", "WitnessTrue", "WitnessFalse" }; }
};
 
template <typename T>
concept TestBaseWithPredicate = requires {
    // Required type aliases
    typename T::Builder;
    typename T::InvalidWitness;
    typename T::InvalidWitness::Target;
    typename T::AcirConstraint;
 
    // Ensure InvalidWitness::Target is an enum
    requires std::is_enum_v<typename T::InvalidWitness::Target>;
 
    // Ensure that InvalidWitness::Target has a None value
    { T::InvalidWitness::Target::None };
 
    // InvalidWitness must provide static methods for test iteration
    { T::InvalidWitness::get_all() } -> std::same_as<std::vector<typename T::InvalidWitness::Target>>;
    { T::InvalidWitness::get_labels() } -> std::same_as<std::vector<std::string>>;
 
    // Required static constraint manipulation methods
    requires requires(typename T::AcirConstraint& constraint,
                      WitnessVector& witness_values,
                      const typename T::InvalidWitness::Target& invalid_witness_target) {
        { T::invalidate_witness(constraint, witness_values, invalid_witness_target) } -> std::same_as<void>;
 
        { T::generate_constraints(constraint, witness_values) } -> std::same_as<void>;
    };
};
 
template <TestBaseWithPredicate Base> class TestClassWithPredicate {
  public:
    using Builder = Base::Builder;
    using InvalidWitness = Base::InvalidWitness;
    using InvalidWitnessTarget = InvalidWitness::Target;
    using AcirConstraint = Base::AcirConstraint;
 
    static void update_witness_based_on_predicate(AcirConstraint& constraint,
                                                  WitnessVector& witness_values,
                                                  const Predicate<InvalidWitnessTarget>& mode)
    {
        switch (mode.test_case) {
        case PredicateTestCase::ConstantTrue:
            constraint.predicate = WitnessOrConstant<bb::fr>::from_constant(bb::fr(1));
            witness_values.pop_back();
            break;
        case PredicateTestCase::WitnessTrue:
            // Nothing to do - keep default witness predicate
            break;
        case PredicateTestCase::WitnessFalse:
            witness_values[constraint.predicate.index] = bb::fr(0);
            break;
        }
        // Apply witness invalidation for all cases
        Base::invalidate_witness(constraint, witness_values, mode.invalid_witness);
    }
 
    static std::pair<AcirConstraint, WitnessVector> generate_constraints(const Predicate<InvalidWitnessTarget>& mode)
    {
        AcirConstraint constraint;
        WitnessVector witness_values;
        Base::generate_constraints(constraint, witness_values);
        update_witness_based_on_predicate(constraint, witness_values, mode);
 
        return { constraint, witness_values };
    }
 
    static std::tuple<bool, bool, std::string> test_constraints(const PredicateTestCase& test_case,
                                                                const InvalidWitnessTarget& invalid_witness_target)
    {
        Predicate<InvalidWitnessTarget> predicate = { .test_case = test_case,
                                                      .invalid_witness = invalid_witness_target };
        auto [constraint, witness_values] = generate_constraints(predicate);
 
        // Use the full ACIR flow: constraint -> Acir::Opcode -> Acir::Circuit -> circuit_serde_to_acir_format
        AcirFormat constraint_system = constraint_to_acir_format(
            constraint, /*max_witness_index=*/static_cast<uint32_t>(witness_values.size()) - 1);
 
        AcirProgram program{ constraint_system, witness_values };
        auto builder = create_circuit<Builder>(program);
 
        return { CircuitChecker::check(builder), builder.failed(), builder.err() };
    }
 
    template <typename Flavor> static std::vector<size_t> test_vk_independence()
    {
        using ProverInstance = ProverInstance_<Flavor>;
        using VerificationKey = Flavor::VerificationKey;
 
        std::vector<size_t> num_gates;
 
        for (auto [predicate_case, label] :
             zip_view(Predicate<InvalidWitnessTarget>::get_all(), Predicate<InvalidWitnessTarget>::get_labels())) {
            vinfo("Testing vk independence for predicate case: ", label);
 
            // Generate the constraint system
            Predicate<InvalidWitnessTarget> predicate = { .test_case = predicate_case,
                                                          .invalid_witness = InvalidWitnessTarget::None };
            auto [constraint, witness_values] = generate_constraints(predicate);
 
            // Use the full ACIR flow
            AcirFormat constraint_system = constraint_to_acir_format(
                constraint, /*max_witness_index=*/static_cast<uint32_t>(witness_values.size()) - 1);
 
            // Construct the vks
            std::shared_ptr<VerificationKey> vk_from_witness;
            {
                AcirProgram program{ constraint_system, witness_values };
                auto builder = create_circuit<Builder>(program);
                num_gates.emplace_back(builder.get_num_finalized_gates_inefficient());
 
                auto prover_instance = std::make_shared<ProverInstance>(builder);
                vk_from_witness = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
 
                // Validate the builder
                EXPECT_TRUE(CircuitChecker::check(builder));
            }
 
            std::shared_ptr<VerificationKey> vk_from_constraint;
            {
                AcirProgram program{ constraint_system, /*witness=*/{} };
                auto builder = create_circuit<Builder>(program);
                auto prover_instance = std::make_shared<ProverInstance>(builder);
                vk_from_constraint = std::make_shared<VerificationKey>(prover_instance->get_precomputed());
            }
 
            EXPECT_EQ(*vk_from_witness, *vk_from_constraint) << "Mismatch in the vks for predicate case " << label;
            vinfo("VK independence passed for predicate case: ", label);
        }
 
        return num_gates;
    }
 
    static void test_constant_true(InvalidWitnessTarget default_invalid_witness_target)
    {
        // Constant true, no invalidation
        {
            auto [circuit_checker_result, builder_failed, _] =
                test_constraints(PredicateTestCase::ConstantTrue, InvalidWitnessTarget::None);
            EXPECT_TRUE(circuit_checker_result) << "Circuit checker failed.";
            EXPECT_FALSE(builder_failed) << "Builder failed unexpectedly.";
        }
 
        // Constant true, default invalidation
        {
            auto [circuit_checker_result, builder_failed, builder_err] =
                test_constraints(PredicateTestCase::ConstantTrue, default_invalid_witness_target);
            // As `assert_equal` doesn't make the CircuitChecker fail, we need to check that either the CircuitChecker
            // failed, or the builder error resulted from an assert_eq.
            bool circuit_check_failed = !circuit_checker_result;
            bool assert_eq_error_present = (builder_err.find("assert_eq") != std::string::npos);
            EXPECT_TRUE(circuit_check_failed || assert_eq_error_present)
                << "Circuit checker succeeded unexpectedly and no assert_eq failure.";
            EXPECT_TRUE(builder_failed) << "Builder succeeded unexpectedly.";
        }
    }
 
    static void test_witness_true(InvalidWitnessTarget default_invalid_witness_target)
    {
        // Witness true, no invalidation
        {
            auto [circuit_checker_result, builder_failed, _] =
                test_constraints(PredicateTestCase::WitnessTrue, InvalidWitnessTarget::None);
            EXPECT_TRUE(circuit_checker_result) << "Circuit checker failed.";
            EXPECT_FALSE(builder_failed) << "Builder failed unexpectedly.";
        }
 
        // Witness true, default invalidation
        {
            auto [circuit_checker_result, builder_failed, builder_err] =
                test_constraints(PredicateTestCase::WitnessTrue, default_invalid_witness_target);
            // As `assert_equal` doesn't make the CircuitChecker fail, we need to check that either the CircuitChecker
            // failed, or the builder error resulted from an assert_eq.
            bool circuit_check_failed = !circuit_checker_result;
            bool assert_eq_error_present = (builder_err.find("assert_eq") != std::string::npos);
            EXPECT_TRUE(circuit_check_failed || assert_eq_error_present)
                << "Circuit checker succeeded unexpectedly and no assert_eq failure.";
            EXPECT_TRUE(builder_failed) << "Builder succeeded unexpectedly.";
        }
    }
 
    static void test_witness_false()
    {
        for (auto [invalid_witness_target, target_label] :
             zip_view(InvalidWitness::get_all(), InvalidWitness::get_labels())) {
            vinfo("Testing invalid witness target: ", target_label);
 
            auto [circuit_checker_result, builder_failed, _] =
                test_constraints(PredicateTestCase::WitnessFalse, invalid_witness_target);
 
            EXPECT_TRUE(circuit_checker_result) << "Check builder failed for invalid witness target " + target_label;
            EXPECT_FALSE(builder_failed) << "Builder failed for invalid witness target " + target_label;
            vinfo("Passed invalid witness target: ", target_label);
        }
    }
 
    static void test_witness_false_slow()
    {
        for (auto [invalid_witness_target, target_label] :
             zip_view(InvalidWitness::get_all(), InvalidWitness::get_labels())) {
            vinfo("Testing invalid witness target: ", target_label);
 
            auto [circuit_checker_result, builder_failed, _] =
                test_constraints(PredicateTestCase::WitnessFalse, invalid_witness_target);
 
            EXPECT_TRUE(circuit_checker_result) << "Check builder failed for invalid witness target " + target_label;
            EXPECT_FALSE(builder_failed) << "Builder failed for invalid witness target " + target_label;
            vinfo("Passed invalid witness target: ", target_label);
 
            // Only validate witness true failure for actual invalidation targets (skip None)
            if (invalid_witness_target != InvalidWitnessTarget::None) {
                // Check that the same configuration would have failed if the predicate was witness true
                auto [circuit_checker_result, builder_failed, builder_err] =
                    test_constraints(PredicateTestCase::WitnessTrue, invalid_witness_target);
 
                // As `assert_equal` doesn't make the CircuitChecker fail, we need to check that either the
                // CircuitChecker failed, or the builder error resulted from an assert_eq.
                bool circuit_check_failed = !circuit_checker_result;
                bool assert_eq_error_present = (builder_err.find("assert_eq") != std::string::npos);
                EXPECT_TRUE(circuit_check_failed || assert_eq_error_present)
                    << "Circuit checker succeeded unexpectedly and no assert_eq failure for invalid witness target " +
                           target_label;
                EXPECT_TRUE(builder_failed) << "Builder succeeded for invalid witness target " + target_label;
                vinfo("Passed invalid witness target (witness true confirmation): ", target_label);
            }
        }
    }
 
    static std::vector<std::string> test_invalid_witnesses()
    {
        std::vector<std::string> error_msgs;
        for (auto [predicate_case, predicate_label] :
             zip_view(Predicate<InvalidWitnessTarget>::get_all(), Predicate<InvalidWitnessTarget>::get_labels())) {
            for (auto [target, label] : zip_view(InvalidWitness::get_all(), InvalidWitness::get_labels())) {
                auto [circuit_checker_result, builder_failed, builder_err] = test_constraints(predicate_case, target);
                error_msgs.emplace_back(builder_err);
 
                if (predicate_case != PredicateTestCase::WitnessFalse) {
                    // If the predicate is not witness false, invalid witnesses should cause failure
                    if (target != InvalidWitnessTarget::None) {
                        bool circuit_check_failed = !circuit_checker_result;
                        bool assert_eq_error_present = (builder_err.find("assert_eq") != std::string::npos);
                        EXPECT_TRUE(circuit_check_failed || assert_eq_error_present)
                            << "Circuit checker succeeded unexpectedly and no assert_eq failure for invalid witness "
                               "target " +
                                   label + " with predicate " + predicate_label;
                        EXPECT_TRUE(builder_failed) << "Builder succeeded unexpectedly for invalid witness target " +
                                                           label + " with predicate " + predicate_label;
                    } else {
                        EXPECT_TRUE(circuit_checker_result)
                            << "Circuit checker failed unexpectedly for invalid witness target " + label +
                                   " with predicate " + predicate_label;
                        EXPECT_FALSE(builder_failed) << "Builder failed unexpectedly for invalid witness target " +
                                                            label + " with predicate " + predicate_label;
                    }
                } else {
                    // If the predicate is witness false, all cases should succeed
                    EXPECT_TRUE(circuit_checker_result) << "Circuit checker failed unexpectedly for invalid witness "
                                                           "target " +
                                                               label + " with predicate " + predicate_label;
                    EXPECT_FALSE(builder_failed) << "Builder failed unexpectedly for invalid witness target " + label +
                                                        " with predicate " + predicate_label;
                }
            }
        }
        return error_msgs;
    }
};
 
} // namespace acir_format