Barretenberg: src/barretenberg/relations/ecc_vm/ecc_msm_short_relation_impl.hpp Source 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/ecc/curves/bn254/g1.hpp"

#include "barretenberg/ecc/groups/precomputed_generators_bn254_impl.hpp"

#include "barretenberg/relations/ecc_vm/ecc_msm_short_relation.hpp"


namespace bb {


template <typename FF>

template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>


void ECCVMMSMAddShortRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulator,

                                                  const AllEntities& in,

                                                  const Parameters& /*unused*/,

                                                  const FF& scaling_factor)

{

    using Accumulator = typename std::tuple_element_t<ADD_ACC_X, ContainerOverSubrelations>;

    using ShortView = ECCVMShortMonomialView<Accumulator>;


    const auto add2_s = ShortView(in.msm_add2);

    const auto add3_s = ShortView(in.msm_add3);

    const auto add4_s = ShortView(in.msm_add4);

    const auto q_add_s = ShortView(in.msm_add);

    const auto msm_transition_s = ShortView(in.msm_transition);


    const auto x1 = Accumulator(ShortView(in.msm_x1));

    const auto y1 = Accumulator(ShortView(in.msm_y1));

    const auto x2 = Accumulator(ShortView(in.msm_x2));

    const auto y2 = Accumulator(ShortView(in.msm_y2));

    const auto x3 = Accumulator(ShortView(in.msm_x3));

    const auto y3 = Accumulator(ShortView(in.msm_y3));

    const auto x4 = Accumulator(ShortView(in.msm_x4));

    const auto y4 = Accumulator(ShortView(in.msm_y4));

    const auto lambda1 = Accumulator(ShortView(in.msm_lambda1));

    const auto lambda2 = Accumulator(ShortView(in.msm_lambda2));

    const auto lambda3 = Accumulator(ShortView(in.msm_lambda3));

    const auto lambda4 = Accumulator(ShortView(in.msm_lambda4));

    const auto acc_x = Accumulator(ShortView(in.msm_accumulator_x));

    const auto acc_y = Accumulator(ShortView(in.msm_accumulator_y));

    const auto acc_x_shift = Accumulator(ShortView(in.msm_accumulator_x_shift));

    const auto acc_y_shift = Accumulator(ShortView(in.msm_accumulator_y_shift));

    const auto msm_transition_acc = Accumulator(msm_transition_s);


    auto add = [&](auto& xb, auto& yb, auto& xa, auto& ya, auto& lambda, auto& selector) {

        auto slope_relation = selector * (lambda * (xb - xa - 1) - (yb - ya)) + lambda;

        auto x_out = lambda.sqr() + (-xb - xa - xa) * selector + xa;

        auto y_out = lambda * (xa - x_out) + (-ya - ya) * selector + ya;

        return std::array<Accumulator, 3>{ x_out, y_out, slope_relation };

    };


    auto first_add = [&](auto& xb, auto& yb, auto& xa, auto& ya, auto& lambda, auto& selector) {

        constexpr auto offset_generator = get_precomputed_generators<g1, "ECCVM_OFFSET_GENERATOR", 1>()[0];

        constexpr uint256_t oxu = offset_generator.x;

        constexpr uint256_t oyu = offset_generator.y;

        const Accumulator xo(oxu);

        const Accumulator yo(oyu);

        auto x = xo * selector + xb * (-selector + 1);

        auto y = yo * selector + yb * (-selector + 1);

        auto slope_relation = lambda * (x - xa) - (y - ya);

        auto x_out = lambda * lambda + (-x - xa);

        auto y_out = lambda * (xa - x_out) - ya;

        return std::array<Accumulator, 3>{ x_out, y_out, slope_relation };

    };


    const auto add2_acc = Accumulator(add2_s);

    const auto add3_acc = Accumulator(add3_s);

    const auto add4_acc = Accumulator(add4_s);

    auto [x_t1, y_t1, add_slope_relation1] = first_add(acc_x, acc_y, x1, y1, lambda1, msm_transition_acc);

    auto [x_t2, y_t2, add_slope_relation2] = add(x2, y2, x_t1, y_t1, lambda2, add2_acc);

    auto [x_t3, y_t3, add_slope_relation3] = add(x3, y3, x_t2, y_t2, lambda3, add3_acc);

    auto [x_t4, y_t4, add_slope_relation4] = add(x4, y4, x_t3, y_t3, lambda4, add4_acc);


    const auto q_add_scaled = Accumulator(q_add_s * scaling_factor);

    std::get<ADD_ACC_X>(accumulator) += q_add_scaled * (acc_x_shift - x_t4);

    std::get<ADD_ACC_Y>(accumulator) += q_add_scaled * (acc_y_shift - y_t4);

    std::get<ADD_SLOPE_1>(accumulator) += q_add_scaled * add_slope_relation1;

    std::get<ADD_SLOPE_2>(accumulator) += q_add_scaled * add_slope_relation2;

    std::get<ADD_SLOPE_3>(accumulator) += q_add_scaled * add_slope_relation3;

    std::get<ADD_SLOPE_4>(accumulator) += q_add_scaled * add_slope_relation4;

}


template <typename FF>

template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>


void ECCVMMSMDoubleShortRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulator,

                                                     const AllEntities& in,

                                                     const Parameters& /*unused*/,

                                                     const FF& scaling_factor)

{

    using Accumulator = typename std::tuple_element_t<DOUBLE_ACC_X, ContainerOverSubrelations>;

    using ShortView = ECCVMShortMonomialView<Accumulator>;


    const auto q_double_s = ShortView(in.msm_double);

    const auto lambda1 = Accumulator(ShortView(in.msm_lambda1));

    const auto lambda2 = Accumulator(ShortView(in.msm_lambda2));

    const auto lambda3 = Accumulator(ShortView(in.msm_lambda3));

    const auto lambda4 = Accumulator(ShortView(in.msm_lambda4));

    const auto acc_x = Accumulator(ShortView(in.msm_accumulator_x));

    const auto acc_y = Accumulator(ShortView(in.msm_accumulator_y));

    const auto acc_x_shift = Accumulator(ShortView(in.msm_accumulator_x_shift));

    const auto acc_y_shift = Accumulator(ShortView(in.msm_accumulator_y_shift));


    auto dbl = [&](auto& x, auto& y, auto& lambda) {

        auto two_x = x + x;

        auto slope_relation = lambda * (y + y) - (two_x + x) * x;

        auto x_out = lambda.sqr() - two_x;

        auto y_out = lambda * (x - x_out) - y;

        return std::array<Accumulator, 3>{ x_out, y_out, slope_relation };

    };


    auto [x_d1, y_d1, double_slope_relation1] = dbl(acc_x, acc_y, lambda1);

    auto [x_d2, y_d2, double_slope_relation2] = dbl(x_d1, y_d1, lambda2);

    auto [x_d3, y_d3, double_slope_relation3] = dbl(x_d2, y_d2, lambda3);

    auto [x_d4, y_d4, double_slope_relation4] = dbl(x_d3, y_d3, lambda4);


    const auto q_double_scaled = Accumulator(q_double_s * scaling_factor);

    std::get<DOUBLE_ACC_X>(accumulator) += q_double_scaled * (acc_x_shift - x_d4);

    std::get<DOUBLE_ACC_Y>(accumulator) += q_double_scaled * (acc_y_shift - y_d4);

    std::get<DOUBLE_SLOPE_1>(accumulator) += q_double_scaled * double_slope_relation1;

    std::get<DOUBLE_SLOPE_2>(accumulator) += q_double_scaled * double_slope_relation2;

    std::get<DOUBLE_SLOPE_3>(accumulator) += q_double_scaled * double_slope_relation3;

    std::get<DOUBLE_SLOPE_4>(accumulator) += q_double_scaled * double_slope_relation4;

}


template <typename FF>

template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>


void ECCVMMSMSkewShortRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulator,

                                                   const AllEntities& in,

                                                   const Parameters& /*unused*/,

                                                   const FF& scaling_factor)

{

    using Accumulator = typename std::tuple_element_t<SKEW_ACC_X, ContainerOverSubrelations>;

    using ShortView = ECCVMShortMonomialView<Accumulator>;


    const auto q_skew_s = ShortView(in.msm_skew);

    const auto slice1_s = ShortView(in.msm_slice1);

    const auto slice2_s = ShortView(in.msm_slice2);

    const auto slice3_s = ShortView(in.msm_slice3);

    const auto slice4_s = ShortView(in.msm_slice4);


    const auto x1 = Accumulator(ShortView(in.msm_x1));

    const auto y1 = Accumulator(ShortView(in.msm_y1));

    const auto x2 = Accumulator(ShortView(in.msm_x2));

    const auto y2 = Accumulator(ShortView(in.msm_y2));

    const auto x3 = Accumulator(ShortView(in.msm_x3));

    const auto y3 = Accumulator(ShortView(in.msm_y3));

    const auto x4 = Accumulator(ShortView(in.msm_x4));

    const auto y4 = Accumulator(ShortView(in.msm_y4));

    const auto lambda1 = Accumulator(ShortView(in.msm_lambda1));

    const auto lambda2 = Accumulator(ShortView(in.msm_lambda2));

    const auto lambda3 = Accumulator(ShortView(in.msm_lambda3));

    const auto lambda4 = Accumulator(ShortView(in.msm_lambda4));

    const auto acc_x = Accumulator(ShortView(in.msm_accumulator_x));

    const auto acc_y = Accumulator(ShortView(in.msm_accumulator_y));

    const auto acc_x_shift = Accumulator(ShortView(in.msm_accumulator_x_shift));

    const auto acc_y_shift = Accumulator(ShortView(in.msm_accumulator_y_shift));


    auto add = [&](auto& xb, auto& yb, auto& xa, auto& ya, auto& lambda, auto& selector) {

        auto slope_relation = selector * (lambda * (xb - xa - 1) - (yb - ya)) + lambda;

        auto x_out = lambda.sqr() + (-xb - xa - xa) * selector + xa;

        auto y_out = lambda * (xa - x_out) + (-ya - ya) * selector + ya;

        return std::array<Accumulator, 3>{ x_out, y_out, slope_relation };

    };


    static const FF inverse_seven_static = FF(7).invert();

    const auto skew1_select = Accumulator(slice1_s * inverse_seven_static);

    const auto skew2_select = Accumulator(slice2_s * inverse_seven_static);

    const auto skew3_select = Accumulator(slice3_s * inverse_seven_static);

    const auto skew4_select = Accumulator(slice4_s * inverse_seven_static);

    auto [x_s1, y_s1, skew_slope_relation1] = add(x1, y1, acc_x, acc_y, lambda1, skew1_select);

    auto [x_s2, y_s2, skew_slope_relation2] = add(x2, y2, x_s1, y_s1, lambda2, skew2_select);

    auto [x_s3, y_s3, skew_slope_relation3] = add(x3, y3, x_s2, y_s2, lambda3, skew3_select);

    auto [x_s4, y_s4, skew_slope_relation4] = add(x4, y4, x_s3, y_s3, lambda4, skew4_select);


    const auto q_skew_scaled = Accumulator(q_skew_s * scaling_factor);

    std::get<SKEW_ACC_X>(accumulator) += q_skew_scaled * (acc_x_shift - x_s4);

    std::get<SKEW_ACC_Y>(accumulator) += q_skew_scaled * (acc_y_shift - y_s4);

    std::get<SKEW_SLOPE_1>(accumulator) += q_skew_scaled * skew_slope_relation1;

    std::get<SKEW_SLOPE_2>(accumulator) += q_skew_scaled * skew_slope_relation2;

    std::get<SKEW_SLOPE_3>(accumulator) += q_skew_scaled * skew_slope_relation3;

    std::get<SKEW_SLOPE_4>(accumulator) += q_skew_scaled * skew_slope_relation4;

}


template <typename FF>

template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>


void ECCVMMSMShortRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulator,

                                               const AllEntities& in,

                                               const Parameters& /*unused*/,

                                               const FF& scaling_factor)

{

    using Accumulator = typename std::tuple_element_t<COLLISION_CHECK_1, ContainerOverSubrelations>;

    using ShortView = ECCVMShortMonomialView<Accumulator>;

    using Acc5 = typename std::tuple_element_t<ROUND_TRANSITION_SKEW_IMPLIES_ROUND_31, ContainerOverSubrelations>;

    using Acc4 = typename std::tuple_element_t<ROUND_TRANSITION_FORCES_DELTA_ONE, ContainerOverSubrelations>;

    using Acc3 = typename std::tuple_element_t<INACTIVE_SLICE_1, ContainerOverSubrelations>;

    using Acc2 = typename std::tuple_element_t<ADD1_DECOMPOSITION, ContainerOverSubrelations>;


    const auto add1_s = ShortView(in.msm_add1);

    const auto add1_shift_s = ShortView(in.msm_add1_shift);

    const auto add2_s = ShortView(in.msm_add2);

    const auto add3_s = ShortView(in.msm_add3);

    const auto add4_s = ShortView(in.msm_add4);

    const auto q_add_s = ShortView(in.msm_add);

    const auto q_add_shift_s = ShortView(in.msm_add_shift);

    const auto q_skew_s = ShortView(in.msm_skew);

    const auto q_skew_shift_s = ShortView(in.msm_skew_shift);

    const auto q_double_s = ShortView(in.msm_double);

    const auto q_double_shift_s = ShortView(in.msm_double_shift);

    const auto msm_transition_s = ShortView(in.msm_transition);

    const auto msm_transition_shift_s = ShortView(in.msm_transition_shift);

    const auto lagrange_first_s = ShortView(in.lagrange_first);

    const auto round_s = ShortView(in.msm_round);

    const auto round_shift_s = ShortView(in.msm_round_shift);

    const auto count_s = ShortView(in.msm_count);

    const auto count_shift_s = ShortView(in.msm_count_shift);

    const auto pc_s = ShortView(in.msm_pc);

    const auto pc_shift_s = ShortView(in.msm_pc_shift);

    const auto msm_size_s = ShortView(in.msm_size_of_msm);

    const auto slice1_s = ShortView(in.msm_slice1);

    const auto slice2_s = ShortView(in.msm_slice2);

    const auto slice3_s = ShortView(in.msm_slice3);

    const auto slice4_s = ShortView(in.msm_slice4);


    const auto x1 = Accumulator(ShortView(in.msm_x1));

    const auto x2 = Accumulator(ShortView(in.msm_x2));

    const auto x3 = Accumulator(ShortView(in.msm_x3));

    const auto x4 = Accumulator(ShortView(in.msm_x4));

    const auto collision_inverse1 = ShortView(in.msm_collision_x1);

    const auto collision_inverse2 = ShortView(in.msm_collision_x2);

    const auto collision_inverse3 = ShortView(in.msm_collision_x3);

    const auto collision_inverse4 = ShortView(in.msm_collision_x4);

    const auto lambda1 = Accumulator(ShortView(in.msm_lambda1));

    const auto lambda2 = Accumulator(ShortView(in.msm_lambda2));

    const auto lambda3 = Accumulator(ShortView(in.msm_lambda3));

    const auto lambda4 = Accumulator(ShortView(in.msm_lambda4));

    const auto acc_x = Accumulator(ShortView(in.msm_accumulator_x));

    const auto acc_y = Accumulator(ShortView(in.msm_accumulator_y));

    const auto acc_x_shift = Accumulator(ShortView(in.msm_accumulator_x_shift));

    const auto acc_y_shift = Accumulator(ShortView(in.msm_accumulator_y_shift));

    const auto msm_transition_acc = Accumulator(msm_transition_s);


    auto add_x = [&](auto& xb, auto& xa, auto& lambda, auto& selector, auto& collision_relation) {

        collision_relation += selector * (xb - xa);

        return lambda.sqr() + (-xb - xa - xa) * selector + xa;

    };


    auto first_add_x = [&](auto& xb, auto& xa, auto& lambda, auto& selector, auto& collision_relation) {

        constexpr auto offset_generator = get_precomputed_generators<g1, "ECCVM_OFFSET_GENERATOR", 1>()[0];

        constexpr uint256_t oxu = offset_generator.x;

        const Accumulator xo(oxu);

        auto x = xo * selector + xb * (-selector + 1);

        collision_relation += (xa - x);

        return lambda * lambda + (-x - xa);

    };


    const auto add2_acc = Accumulator(add2_s);

    const auto add3_acc = Accumulator(add3_s);

    const auto add4_acc = Accumulator(add4_s);

    Accumulator x1_collision_relation(0);

    Accumulator x2_collision_relation(0);

    Accumulator x3_collision_relation(0);

    Accumulator x4_collision_relation(0);

    auto x_t1 = first_add_x(acc_x, x1, lambda1, msm_transition_acc, x1_collision_relation);

    auto x_t2 = add_x(x2, x_t1, lambda2, add2_acc, x2_collision_relation);

    auto x_t3 = add_x(x3, x_t2, lambda3, add3_acc, x3_collision_relation);

    add_x(x4, x_t3, lambda4, add4_acc, x4_collision_relation);


    static const FF inverse_seven_static = FF(7).invert();

    const auto skew1_select = Accumulator(slice1_s * inverse_seven_static);

    const auto skew2_select = Accumulator(slice2_s * inverse_seven_static);

    const auto skew3_select = Accumulator(slice3_s * inverse_seven_static);

    const auto skew4_select = Accumulator(slice4_s * inverse_seven_static);

    Accumulator x1_skew_collision_relation(0);

    Accumulator x2_skew_collision_relation(0);

    Accumulator x3_skew_collision_relation(0);

    Accumulator x4_skew_collision_relation(0);

    auto x_s1 = add_x(x1, acc_x, lambda1, skew1_select, x1_skew_collision_relation);

    auto x_s2 = add_x(x2, x_s1, lambda2, skew2_select, x2_skew_collision_relation);

    auto x_s3 = add_x(x3, x_s2, lambda3, skew3_select, x3_skew_collision_relation);

    add_x(x4, x_s3, lambda4, skew4_select, x4_skew_collision_relation);


    const auto add_first_point_short = add1_s * q_add_s + q_skew_s * (slice1_s * inverse_seven_static);

    const auto add_second_point_short = add2_s * q_add_s + q_skew_s * (slice2_s * inverse_seven_static);

    const auto add_third_point_short = add3_s * q_add_s + q_skew_s * (slice3_s * inverse_seven_static);

    const auto add_fourth_point_short = add4_s * q_add_s + q_skew_s * (slice4_s * inverse_seven_static);

    const auto q_skew_acc = Accumulator(q_skew_s);

    const auto q_add_acc = Accumulator(q_add_s);

    const auto x1_delta = x1_skew_collision_relation * q_skew_acc + x1_collision_relation * q_add_acc;

    const auto x2_delta = x2_skew_collision_relation * q_skew_acc + x2_collision_relation * q_add_acc;

    const auto x3_delta = x3_skew_collision_relation * q_skew_acc + x3_collision_relation * q_add_acc;

    const auto x4_delta = x4_skew_collision_relation * q_skew_acc + x4_collision_relation * q_add_acc;

    std::get<COLLISION_CHECK_1>(accumulator) += x1_delta * Accumulator(collision_inverse1 * scaling_factor) -

                                                Accumulator(add_first_point_short * scaling_factor);

    std::get<COLLISION_CHECK_2>(accumulator) += x2_delta * Accumulator(collision_inverse2 * scaling_factor) -

                                                Accumulator(add_second_point_short * scaling_factor);

    std::get<COLLISION_CHECK_3>(accumulator) += x3_delta * Accumulator(collision_inverse3 * scaling_factor) -

                                                Accumulator(add_third_point_short * scaling_factor);

    std::get<COLLISION_CHECK_4>(accumulator) += x4_delta * Accumulator(collision_inverse4 * scaling_factor) -

                                                Accumulator(add_fourth_point_short * scaling_factor);


    std::get<INACTIVE_SLICE_1>(accumulator) += Acc3(((-add1_s + FF(1)) * slice1_s) * scaling_factor);

    std::get<INACTIVE_SLICE_2>(accumulator) += Acc3(((-add2_s + FF(1)) * slice2_s) * scaling_factor);

    std::get<INACTIVE_SLICE_3>(accumulator) += Acc3(((-add3_s + FF(1)) * slice3_s) * scaling_factor);

    std::get<INACTIVE_SLICE_4>(accumulator) += Acc3(((-add4_s + FF(1)) * slice4_s) * scaling_factor);


    {

        const auto sum = q_add_s * q_double_s + q_add_s * q_skew_s + q_double_s * q_skew_s; // length 3

        std::get<PHASE_SELECTOR_MUTUAL_EXCLUSIVITY>(accumulator) += Acc3(sum * scaling_factor);

    }


    const auto no_op_selector_short_a = (-q_add_s + FF(1)) * (-q_double_s + FF(1));        // length 3

    const auto no_op_selector_short_b = (-q_skew_s + FF(1)) * (-msm_transition_s + FF(1)); // length 3

    const auto no_op_selector_short_c = -lagrange_first_s + FF(1);                         // length 2

    const auto no_op_selector_scaled_acc = Accumulator(no_op_selector_short_a * scaling_factor) *

                                           Accumulator(no_op_selector_short_b) * Accumulator(no_op_selector_short_c);

    std::get<IDLE_ROW_PRESERVES_ACC_X>(accumulator) += no_op_selector_scaled_acc * (acc_x_shift - acc_x);

    std::get<IDLE_ROW_PRESERVES_ACC_Y>(accumulator) += no_op_selector_scaled_acc * (acc_y_shift - acc_y);


    std::get<ADD1_DECOMPOSITION>(accumulator) += Acc2((add1_s - q_add_s - q_skew_s) * scaling_factor);


    const auto round_delta_short = round_shift_s - round_s;                                          // length 2

    const auto neg_msm_transition_shift_plus_one_short = -msm_transition_shift_s + FF(1);            // length 2

    const auto round_transition_short = round_delta_short * neg_msm_transition_shift_plus_one_short; // length 3

    {

        const auto round_delta_minus_one_short = round_delta_short - FF(1); // length 2

        std::get<ROUND_TRANSITION_FORCES_DELTA_ONE>(accumulator) +=

            Acc4(round_transition_short * scaling_factor) * Acc4(round_delta_minus_one_short);

    }

    {

        const auto round_minus_31_short = round_s - FF(31);

        std::get<ROUND_TRANSITION_SKEW_IMPLIES_ROUND_31>(accumulator) +=

            Acc5(round_transition_short * scaling_factor) * Acc5(q_skew_shift_s * round_minus_31_short);

    }

    {

        const auto q_skew_plus_q_double_minus_one_short = (q_skew_shift_s + q_double_shift_s) - FF(1); // length 2

        std::get<ROUND_TRANSITION_EXACTLY_ONE_DOUBLE_OR_SKEW>(accumulator) +=

            Acc4(round_transition_short * scaling_factor) * Acc4(q_skew_plus_q_double_minus_one_short);

    }

    {

        const auto neg_double_short = -q_double_shift_s + FF(1);                  // length 2

        const auto neg_skew_short = -q_skew_shift_s + FF(1);                      // length 2

        const auto not_double_not_skew_short = neg_double_short * neg_skew_short; // length 3

        std::get<ROUND_TRANSITION_NEEDS_DOUBLE_OR_SKEW>(accumulator) +=

            Acc5(round_transition_short * scaling_factor) * Acc5(not_double_not_skew_short);

    }


    std::get<DOUBLE_IMPLIES_NEXT_IS_ADD>(accumulator) += Acc3((q_double_s * (-q_add_shift_s + FF(1))) * scaling_factor);

    std::get<COUNT_SHIFT_ZERO_ON_ROUND_CHANGE>(accumulator) +=

        Acc3((round_delta_short * count_shift_s) * scaling_factor);

    {

        const auto neg_round_delta_plus_one_short = -round_delta_short + FF(1);                            // length 2

        const auto outer_short = neg_msm_transition_shift_plus_one_short * neg_round_delta_plus_one_short; // length 3

        const auto inner_short = ((count_shift_s - count_s) - add1_s - add2_s - add3_s) - add4_s;          // length 2

        std::get<COUNT_INCREMENT_WITHIN_ROUND>(accumulator) += Acc4(outer_short * scaling_factor) * Acc4(inner_short);

    }

    {

        const auto is_not_first_row_short = -lagrange_first_s + FF(1);                               // length 2

        const auto outer_a_short = is_not_first_row_short * neg_msm_transition_shift_plus_one_short; // length 3

        const auto outer_b_short = round_delta_short * count_shift_s;                                // length 3

        std::get<COUNT_ZERO_AT_ROUND_BOUNDARY_OR_TRANSITION>(accumulator) +=

            Acc5(outer_a_short * scaling_factor) * Acc5(outer_b_short);

    }


    std::get<MSM_TRANSITION_ROUND_ZERO>(accumulator) += Acc3((msm_transition_s * round_s) * scaling_factor);

    {

        const auto is_not_first_row_short = -lagrange_first_s + FF(1);

        const auto outer_short = is_not_first_row_short * msm_transition_shift_s; // length 3

        const auto inner_short = (msm_size_s + pc_shift_s) - pc_s;                // length 2

        std::get<MSM_TRANSITION_PC>(accumulator) += Acc4(outer_short * scaling_factor) * Acc4(inner_short);

    }


    std::get<ADD_CONTINUITY_2>(accumulator) += Acc3((add2_s * (-add1_s + FF(1))) * scaling_factor);

    std::get<ADD_CONTINUITY_3>(accumulator) += Acc3((add3_s * (-add2_s + FF(1))) * scaling_factor);

    std::get<ADD_CONTINUITY_4>(accumulator) += Acc3((add4_s * (-add3_s + FF(1))) * scaling_factor);


    {

        const auto outer_short = q_add_s * q_add_shift_s + q_skew_s * q_skew_shift_s; // length 3

        const auto inner_short = (-add4_s + FF(1)) * add1_shift_s;                    // length 3

        std::get<ADD_CROSS_ROW_CONTINUITY>(accumulator) += Acc5(outer_short * scaling_factor) * Acc5(inner_short);

    }


    {

        const auto neg_skew_shift_short = -q_skew_shift_s + FF(1);                   // length 2

        const auto outer_short = neg_msm_transition_shift_plus_one_short * q_skew_s; // length 3

        std::get<SKEW_PERSISTS_UNTIL_MSM_TRANSITION>(accumulator) +=

            Acc4(outer_short * scaling_factor) * Acc4(neg_skew_shift_short);

    }

    std::get<SKEW_IMPLIES_ROUND_32>(accumulator) += Acc3((q_skew_s * (-round_s + FF(32))) * scaling_factor);

    std::get<DOUBLE_REQUIRES_ROUND_CHANGE>(accumulator) +=

        Acc3(((-round_delta_short + FF(1)) * q_double_shift_s) * scaling_factor);

}


} // namespace bb

FF
bb::field< bb::Bn254FrParams > FF
Definition field.cpp:24

bb::ECCVMMSMAddShortRelationImpl::accumulate
static void accumulate(ContainerOverSubrelations &accumulator, const AllEntities &in, const Parameters &params, const FF &scaling_factor)
Definition ecc_msm_short_relation_impl.hpp:17

bb::ECCVMMSMAddShortRelationImpl::FF
FF_ FF
Definition ecc_msm_short_relation.hpp:17

bb::ECCVMMSMDoubleShortRelationImpl::accumulate
static void accumulate(ContainerOverSubrelations &accumulator, const AllEntities &in, const Parameters &params, const FF &scaling_factor)
Definition ecc_msm_short_relation_impl.hpp:89

bb::ECCVMMSMDoubleShortRelationImpl::FF
FF_ FF
Definition ecc_msm_short_relation.hpp:46

bb::ECCVMMSMShortRelationImpl::accumulate
static void accumulate(ContainerOverSubrelations &accumulator, const AllEntities &in, const Parameters &params, const FF &scaling_factor)
Definition ecc_msm_short_relation_impl.hpp:190

bb::ECCVMMSMShortRelationImpl::FF
FF_ FF
Definition ecc_msm_short_relation.hpp:104

bb::ECCVMMSMSkewShortRelationImpl::accumulate
static void accumulate(ContainerOverSubrelations &accumulator, const AllEntities &in, const Parameters &params, const FF &scaling_factor)
Definition ecc_msm_short_relation_impl.hpp:131

bb::ECCVMMSMSkewShortRelationImpl::FF
FF_ FF
Definition ecc_msm_short_relation.hpp:75

bb::numeric::uint256_t
Definition uint256.hpp:32

ecc_msm_short_relation.hpp

g1.hpp

bb
Entry point for Barretenberg command-line interface.
Definition api.hpp:5

bb::g1
group< fq, fr, Bn254G1Params > g1
Definition g1.hpp:34

bb::sum
Inner sum(Cont< Inner, Args... > const &in)
Definition container.hpp:70

bb::get_precomputed_generators
constexpr std::span< const typename Group::affine_element > get_precomputed_generators()
Definition precomputed_generators.hpp:51

bb::ECCVMShortMonomialView
typename Accumulator::CoefficientAccumulator ECCVMShortMonomialView
Definition ecc_short_monomial_relation_utils.hpp:11

std::get
constexpr decltype(auto) get(::tuplet::tuple< T... > &&t) noexcept
Definition tuple.hpp:13

precomputed_generators_bn254_impl.hpp

bb::field::invert
constexpr field invert() const noexcept
Definition field_impl.hpp:388