ec_operations.test.cpp

Go to the documentation of this file.

#include "ec_operations.hpp"
#include "acir_format.hpp"
#include "acir_format_mocks.hpp"
 
#include "barretenberg/dsl/acir_format/test_class_predicate.hpp"
#include "barretenberg/dsl/acir_format/utils.hpp"
#include "barretenberg/stdlib/primitives/group/cycle_group.hpp"
 
#include <gtest/gtest.h>
#include <vector>
 
using namespace ::acir_format;
 
enum class InputConstancy : uint8_t { None, Input1, Input2, Both };
 
template <typename Builder_, InputConstancy Constancy> class EcOperationsTestingFunctions {
  public:
    using Builder = Builder_;
    using AcirConstraint = EcAdd;
    using G1 = bb::grumpkin::g1;
    using GrumpkinPoint = G1::affine_element;
    using FF = bb::fr;
 
    class InvalidWitness {
      public:
        enum class Target : uint8_t {
            None,
            Input1, // Invalidate first input point
            Input2, // Invalidate second input point
            Result  // Invalidate result output
        };
 
        static std::vector<Target> get_all()
        {
            return { Target::None, Target::Input1, Target::Input2, Target::Result };
        }
 
        static std::vector<std::string> get_labels() { return { "None", "Input1", "Input2", "Result" }; }
    };
 
    static void generate_constraints(AcirConstraint& ec_add_constraint, WitnessVector& witness_values)
    {
        // Generate points on Grumpkin
        GrumpkinPoint input1 = GrumpkinPoint::random_element();
        GrumpkinPoint input2 = GrumpkinPoint::random_element();
        GrumpkinPoint result = input1 + input2;
        BB_ASSERT(result != GrumpkinPoint::one()); // Ensure that tampering works correctly
 
        // Helper to add a point: either as witness or constant
        auto construct_point = [&](const GrumpkinPoint& point, bool as_constant) -> std::vector<WitnessOrConstant<FF>> {
            if (as_constant) {
                // Point is constant
                return { WitnessOrConstant<FF>::from_constant(point.x),
                         WitnessOrConstant<FF>::from_constant(point.y),
                         WitnessOrConstant<FF>::from_constant(point.is_point_at_infinity() ? FF(1) : FF(0)) };
            }
            // Point is witness
            std::vector<uint32_t> point_indices = add_to_witness_and_track_indices(witness_values, point);
            return { WitnessOrConstant<FF>::from_index(point_indices[0]),
                     WitnessOrConstant<FF>::from_index(point_indices[1]),
                     WitnessOrConstant<FF>::from_index(point_indices[2]) };
        };
 
        // Determine which inputs are constants based on the Constancy template parameter
        constexpr bool input1_is_constant = (Constancy == InputConstancy::Input1 || Constancy == InputConstancy::Both);
        constexpr bool input2_is_constant = (Constancy == InputConstancy::Input2 || Constancy == InputConstancy::Both);
 
        // Add inputs according to constancy template parameter
        auto input1_fields = construct_point(input1, input1_is_constant);
        auto input2_fields = construct_point(input2, input2_is_constant);
 
        // Construct result and predicate as witnesses
        std::vector<uint32_t> result_indices = add_to_witness_and_track_indices(witness_values, result);
        uint32_t predicate_index = add_to_witness_and_track_indices(witness_values, FF(1));
 
        // Build the constraint
        ec_add_constraint = EcAdd{
            .input1_x = input1_fields[0],
            .input1_y = input1_fields[1],
            .input1_infinite = input1_fields[2],
            .input2_x = input2_fields[0],
            .input2_y = input2_fields[1],
            .input2_infinite = input2_fields[2],
            .predicate = WitnessOrConstant<FF>::from_index(predicate_index),
            .result_x = result_indices[0],
            .result_y = result_indices[1],
            .result_infinite = result_indices[2],
        };
    }
 
    static void invalidate_witness(AcirConstraint& constraint,
                                   WitnessVector& witness_values,
                                   const InvalidWitness::Target& invalid_witness_target)
    {
        switch (invalid_witness_target) {
        case InvalidWitness::Target::Input1: {
            // Invalidate the first input by adding 1 to x coordinate
            if constexpr (Constancy == InputConstancy::None || Constancy == InputConstancy::Input2) {
                witness_values[constraint.input1_x.index] += bb::fr(1);
            } else {
                constraint.input1_x = WitnessOrConstant<FF>::from_constant(constraint.input1_x.value + bb::fr(1));
            }
            break;
        }
        case InvalidWitness::Target::Input2: {
            // Invalidate the second input by adding 1 to x coordinate
            if constexpr (Constancy == InputConstancy::None || Constancy == InputConstancy::Input1) {
                witness_values[constraint.input2_x.index] += bb::fr(1);
            } else {
                constraint.input2_x = WitnessOrConstant<FF>::from_constant(constraint.input2_x.value + bb::fr(1));
            }
            break;
        }
        case InvalidWitness::Target::Result: {
            // Tamper with the result (always a witness) by setting it to the generator point
            witness_values[constraint.result_x] = GrumpkinPoint::one().x;
            witness_values[constraint.result_y] = GrumpkinPoint::one().y;
            witness_values[constraint.result_infinite] = FF::zero();
            break;
        }
        case InvalidWitness::Target::None:
        default:
            break;
        }
    };
};
 
template <typename Builder>
class EcOperationsTestsNoneConstant
    : public ::testing::Test,
      public TestClassWithPredicate<EcOperationsTestingFunctions<Builder, InputConstancy::None>> {
  protected:
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
};
 
template <typename Builder>
class EcOperationsTestsInput1Constant
    : public ::testing::Test,
      public TestClassWithPredicate<EcOperationsTestingFunctions<Builder, InputConstancy::Input1>> {
  protected:
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
};
 
template <typename Builder>
class EcOperationsTestsInput2Constant
    : public ::testing::Test,
      public TestClassWithPredicate<EcOperationsTestingFunctions<Builder, InputConstancy::Input2>> {
  protected:
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
};
 
template <typename Builder>
class EcOperationsTestsBothConstant
    : public ::testing::Test,
      public TestClassWithPredicate<EcOperationsTestingFunctions<Builder, InputConstancy::Both>> {
  protected:
    static void SetUpTestSuite() { bb::srs::init_file_crs_factory(bb::srs::bb_crs_path()); }
};
 
using BuilderTypes = testing::Types<UltraCircuitBuilder, MegaCircuitBuilder>;
 
TYPED_TEST_SUITE(EcOperationsTestsNoneConstant, BuilderTypes);
TYPED_TEST_SUITE(EcOperationsTestsInput1Constant, BuilderTypes);
TYPED_TEST_SUITE(EcOperationsTestsInput2Constant, BuilderTypes);
TYPED_TEST_SUITE(EcOperationsTestsBothConstant, BuilderTypes);
 
TYPED_TEST(EcOperationsTestsNoneConstant, GenerateVKFromConstraints)
{
    using Flavor = std::conditional_t<std::is_same_v<TypeParam, UltraCircuitBuilder>, UltraFlavor, MegaFlavor>;
    TestFixture::template test_vk_independence<Flavor>();
}
 
TYPED_TEST(EcOperationsTestsNoneConstant, ConstantTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_constant_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsNoneConstant, WitnessTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsNoneConstant, WitnessFalseSlow)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_false_slow();
}
 
TYPED_TEST(EcOperationsTestsNoneConstant, InvalidWitnesses)
{
    BB_DISABLE_ASSERTS();
    [[maybe_unused]] std::vector<std::string> _ = TestFixture::test_invalid_witnesses();
}
 
TYPED_TEST(EcOperationsTestsInput1Constant, GenerateVKFromConstraints)
{
    using Flavor = std::conditional_t<std::is_same_v<TypeParam, UltraCircuitBuilder>, UltraFlavor, MegaFlavor>;
    TestFixture::template test_vk_independence<Flavor>();
}
 
TYPED_TEST(EcOperationsTestsInput1Constant, ConstantTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_constant_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsInput1Constant, WitnessTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsInput1Constant, WitnessFalseSlow)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_false_slow();
}
 
TYPED_TEST(EcOperationsTestsInput1Constant, InvalidWitnesses)
{
    BB_DISABLE_ASSERTS();
    [[maybe_unused]] std::vector<std::string> _ = TestFixture::test_invalid_witnesses();
}
 
TYPED_TEST(EcOperationsTestsInput2Constant, GenerateVKFromConstraints)
{
    using Flavor = std::conditional_t<std::is_same_v<TypeParam, UltraCircuitBuilder>, UltraFlavor, MegaFlavor>;
    TestFixture::template test_vk_independence<Flavor>();
}
 
TYPED_TEST(EcOperationsTestsInput2Constant, ConstantTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_constant_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsInput2Constant, WitnessTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsInput2Constant, WitnessFalseSlow)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_false_slow();
}
 
TYPED_TEST(EcOperationsTestsInput2Constant, InvalidWitnesses)
{
    BB_DISABLE_ASSERTS();
    [[maybe_unused]] std::vector<std::string> _ = TestFixture::test_invalid_witnesses();
}
 
TYPED_TEST(EcOperationsTestsBothConstant, GenerateVKFromConstraints)
{
    using Flavor = std::conditional_t<std::is_same_v<TypeParam, UltraCircuitBuilder>, UltraFlavor, MegaFlavor>;
    TestFixture::template test_vk_independence<Flavor>();
}
 
TYPED_TEST(EcOperationsTestsBothConstant, ConstantTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_constant_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsBothConstant, WitnessTrue)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_true(TestFixture::InvalidWitnessTarget::Result);
}
 
TYPED_TEST(EcOperationsTestsBothConstant, WitnessFalseSlow)
{
    BB_DISABLE_ASSERTS();
    TestFixture::test_witness_false_slow();
}
 
TYPED_TEST(EcOperationsTestsBothConstant, InvalidWitnesses)
{
    BB_DISABLE_ASSERTS();
    [[maybe_unused]] std::vector<std::string> _ = TestFixture::test_invalid_witnesses();
}