ecc_point_table_relation_impl.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 "ecc_point_table_relation.hpp"
 
#include "barretenberg/eccvm/eccvm_flavor.hpp"
#include "barretenberg/flavor/relation_definitions.hpp"
#include "ecc_point_table_relation_impl.hpp"
 
namespace bb {
 
template <typename FF>
template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
void ECCVMPointTableRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulator,
                                                 const AllEntities& in,
                                                 const Parameters& /*unused*/,
                                                 const FF& scaling_factor)
{
    using Accumulator = typename std::tuple_element_t<0, ContainerOverSubrelations>;
    using View = typename Accumulator::View;
 
    const auto& Tx = View(in.precompute_tx);
    const auto& Tx_shift = View(in.precompute_tx_shift);
    const auto& Ty = View(in.precompute_ty);
    const auto& Ty_shift = View(in.precompute_ty_shift);
    const auto& Dx = View(in.precompute_dx);
    const auto& Dx_shift = View(in.precompute_dx_shift);
    const auto& Dy = View(in.precompute_dy);
    const auto& Dy_shift = View(in.precompute_dy_shift);
    const auto& precompute_point_transition = View(in.precompute_point_transition);
    const auto& lagrange_first = View(in.lagrange_first);
 
    auto two_x = Tx + Tx;
    auto three_x = two_x + Tx;
    auto three_xx = Tx * three_x;
    auto nine_xxxx = three_xx.sqr();
    auto two_y = Ty + Ty;
    auto four_yy = two_y.sqr();
    auto x_double_check = (Dx + two_x) * four_yy - nine_xxxx;
    auto y_double_check = (Ty + Dy) * two_y + three_xx * (Dx - Tx);
    std::get<0>(accumulator) += precompute_point_transition * x_double_check * scaling_factor;
    std::get<1>(accumulator) += precompute_point_transition * y_double_check * scaling_factor;
 
    std::get<2>(accumulator) +=
        (-lagrange_first + 1) * (-precompute_point_transition + 1) * (Dx - Dx_shift) * scaling_factor;
    std::get<3>(accumulator) +=
        (-lagrange_first + 1) * (-precompute_point_transition + 1) * (Dy - Dy_shift) * scaling_factor;
 
    const auto& x1 = Tx_shift;
    const auto& y1 = Ty_shift;
    const auto& x2 = Dx;
    const auto& y2 = Dy;
    const auto& x3 = Tx;
    const auto& y3 = Ty;
    const auto lambda_numerator = y2 - y1;
    const auto lambda_denominator = x2 - x1;
    auto x_add_check = (x3 + x2 + x1) * lambda_denominator.sqr() - lambda_numerator.sqr();
    auto y_add_check = (y3 + y1) * lambda_denominator + (x3 - x1) * lambda_numerator;
    std::get<4>(accumulator) +=
        (-lagrange_first + 1) * (-precompute_point_transition + 1) * x_add_check * scaling_factor;
    std::get<5>(accumulator) +=
        (-lagrange_first + 1) * (-precompute_point_transition + 1) * y_add_check * scaling_factor;
}
 
} // namespace bb