translator_extra_relations_impl.hpp

Go to the documentation of this 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/relations/translator_vm/translator_extra_relations.hpp"
 
namespace bb {
 
template <typename FF>
template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
void TranslatorOpcodeConstraintRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulators,
                                                            const AllEntities& in,
                                                            const Parameters& /*unused*/,
                                                            const FF& scaling_factor)
{
 
    using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
    using View = typename Accumulator::View;
 
    auto op = View(in.op);
    const auto lagrange_even_in_minicircuit = View(in.lagrange_even_in_minicircuit);
    const auto lagrange_odd_in_minicircuit = View(in.lagrange_odd_in_minicircuit);
    static const FF minus_three = FF(-3);
    static const FF minus_four = FF(-4);
    static const FF minus_eight = FF(-8);
 
    // Contribution (1) opcode validity:
    //   - on even rows: op·(op-3)·(op-4)·(op-8) = 0, i.e. op ∈ {0,3,4,8}
    //   - on odd rows:  op = 0
    // The odd-row term forbids a genuine opcode from sitting on an odd row, where the non-native accumulator
    // (gated by lagrange_even·op) would skip it, letting a prover exclude an ECC op from the batched evaluation.
    // Random masking ops are unaffected because lagrange_even_in_minicircuit and lagrange_odd_in_minicircuit are
    // both zero in the masking regions.
    auto tmp_1 = op * (op + minus_three);
    tmp_1 *= (op + minus_four);
    tmp_1 *= (op + minus_eight);
    tmp_1 *= lagrange_even_in_minicircuit;
    tmp_1 += op * lagrange_odd_in_minicircuit;
    tmp_1 *= scaling_factor;
    std::get<0>(accumulators) += tmp_1;
 
    auto accumulators_binary_limbs_0 = View(in.accumulators_binary_limbs_0);
    auto accumulators_binary_limbs_1 = View(in.accumulators_binary_limbs_1);
    auto accumulators_binary_limbs_2 = View(in.accumulators_binary_limbs_2);
    auto accumulators_binary_limbs_3 = View(in.accumulators_binary_limbs_3);
    auto accumulators_binary_limbs_0_shift = View(in.accumulators_binary_limbs_0_shift);
    auto accumulators_binary_limbs_1_shift = View(in.accumulators_binary_limbs_1_shift);
    auto accumulators_binary_limbs_2_shift = View(in.accumulators_binary_limbs_2_shift);
    auto accumulators_binary_limbs_3_shift = View(in.accumulators_binary_limbs_3_shift);
 
    // Contribution (2) (2-5 ensure that the accumulator stays the same at even indices within the no-op range if
    // one exists)
    auto tmp_2 = (accumulators_binary_limbs_0 - accumulators_binary_limbs_0_shift);
    tmp_2 *= (op + minus_three);
    tmp_2 *= (op + minus_four);
    tmp_2 *= (op + minus_eight);
    tmp_2 *= lagrange_even_in_minicircuit;
    tmp_2 *= scaling_factor;
    std::get<1>(accumulators) += tmp_2;
 
    // Contribution (3)
    auto tmp_3 = (accumulators_binary_limbs_1 - accumulators_binary_limbs_1_shift);
    tmp_3 *= (op + minus_three);
    tmp_3 *= (op + minus_four);
    tmp_3 *= (op + minus_eight);
    tmp_3 *= lagrange_even_in_minicircuit;
    tmp_3 *= scaling_factor;
    std::get<2>(accumulators) += tmp_3;
 
    // Contribution (4)
    auto tmp_4 = (accumulators_binary_limbs_2 - accumulators_binary_limbs_2_shift);
    tmp_4 *= (op + minus_three);
    tmp_4 *= (op + minus_four);
    tmp_4 *= (op + minus_eight);
    tmp_4 *= lagrange_even_in_minicircuit;
    tmp_4 *= scaling_factor;
    std::get<3>(accumulators) += tmp_4;
 
    // Contribution (5)
    auto tmp_5 = (accumulators_binary_limbs_3 - accumulators_binary_limbs_3_shift);
    tmp_5 *= (op + minus_three);
    tmp_5 *= (op + minus_four);
    tmp_5 *= (op + minus_eight);
    tmp_5 *= lagrange_even_in_minicircuit;
    tmp_5 *= scaling_factor;
    std::get<4>(accumulators) += tmp_5;
};
 
template <typename FF>
template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
void TranslatorAccumulatorTransferRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulators,
                                                               const AllEntities& in,
                                                               const Parameters& params,
                                                               const FF& scaling_factor)
{
    using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
    using View = typename Accumulator::View;
    // Starting with 4th relation, we use shorter accumulators
    using ShorterAccumulator = std::tuple_element_t<4, ContainerOverSubrelations>;
    using ShorterView = typename ShorterAccumulator::View;
    // We use combination of lagrange polynomials at odd indices in the minicircuit for copying the accumulator
    const auto lagrange_odd_in_minicircuit = View(in.lagrange_odd_in_minicircuit);
 
    // Lagrange ensuring the accumulator result is validated at the correct row
    const auto lagrange_result_row_shorter = ShorterView(in.lagrange_result_row);
 
    // Lagrange at index (size of minicircuit without masking - 1) is used to enforce that the accumulator starts from
    // zero (recall that we accumulate in the reverse order of the ops)
    const auto lagrange_last_in_minicircuit = View(in.lagrange_last_in_minicircuit);
    const auto lagrange_last_in_minicircuit_shorter = ShorterView(in.lagrange_last_in_minicircuit);
 
    auto accumulators_binary_limbs_0 = View(in.accumulators_binary_limbs_0);
    auto accumulators_binary_limbs_1 = View(in.accumulators_binary_limbs_1);
    auto accumulators_binary_limbs_2 = View(in.accumulators_binary_limbs_2);
    auto accumulators_binary_limbs_3 = View(in.accumulators_binary_limbs_3);
    auto accumulators_binary_limbs_0_shift = View(in.accumulators_binary_limbs_0_shift);
    auto accumulators_binary_limbs_1_shift = View(in.accumulators_binary_limbs_1_shift);
    auto accumulators_binary_limbs_2_shift = View(in.accumulators_binary_limbs_2_shift);
    auto accumulators_binary_limbs_3_shift = View(in.accumulators_binary_limbs_3_shift);
 
    auto accumulators_binary_limbs_0_shorter = ShorterView(in.accumulators_binary_limbs_0);
    auto accumulators_binary_limbs_1_shorter = ShorterView(in.accumulators_binary_limbs_1);
    auto accumulators_binary_limbs_2_shorter = ShorterView(in.accumulators_binary_limbs_2);
    auto accumulators_binary_limbs_3_shorter = ShorterView(in.accumulators_binary_limbs_3);
 
    const FF minus_one = FF(-1);
 
    // Contribution (1) (1-4 ensure transfer of accumulator limbs at odd indices of the minicircuit)
    const auto is_row_odd_except_last = lagrange_odd_in_minicircuit * (lagrange_last_in_minicircuit + minus_one);
    auto tmp_1 = accumulators_binary_limbs_0 - accumulators_binary_limbs_0_shift;
    tmp_1 *= is_row_odd_except_last;
    tmp_1 *= scaling_factor;
    std::get<0>(accumulators) += tmp_1;
 
    // Contribution (2)
    auto tmp_2 = accumulators_binary_limbs_1 - accumulators_binary_limbs_1_shift;
    tmp_2 *= is_row_odd_except_last;
    tmp_2 *= scaling_factor;
    std::get<1>(accumulators) += tmp_2;
    // Contribution (3)
    auto tmp_3 = accumulators_binary_limbs_2 - accumulators_binary_limbs_2_shift;
    tmp_3 *= is_row_odd_except_last;
    tmp_3 *= scaling_factor;
    std::get<2>(accumulators) += tmp_3;
    // Contribution (4)
    auto tmp_4 = accumulators_binary_limbs_3 - accumulators_binary_limbs_3_shift;
    tmp_4 *= is_row_odd_except_last;
    tmp_4 *= scaling_factor;
    std::get<3>(accumulators) += tmp_4;
 
    // Contribution (5) (5-9 ensure that accumulator starts with zeroed-out limbs)
    const auto lagrange_last_in_minicircuit_by_scaling_factor = lagrange_last_in_minicircuit_shorter * scaling_factor;
    auto tmp_5 = accumulators_binary_limbs_0_shorter * lagrange_last_in_minicircuit_by_scaling_factor;
    std::get<4>(accumulators) += tmp_5;
 
    //    Contribution (6)
    auto tmp_6 = accumulators_binary_limbs_1_shorter * lagrange_last_in_minicircuit_by_scaling_factor;
    std::get<5>(accumulators) += tmp_6;
 
    // Contribution (7)
    auto tmp_7 = accumulators_binary_limbs_2_shorter * lagrange_last_in_minicircuit_by_scaling_factor;
    std::get<6>(accumulators) += tmp_7;
 
    // Contribution (8)
    auto tmp_8 = accumulators_binary_limbs_3_shorter * lagrange_last_in_minicircuit_by_scaling_factor;
    std::get<7>(accumulators) += tmp_8;
 
    // Contribution (9) (9-12 ensure the output is as stated, we basically use this to get the result out of the
    // proof)
    const auto lagrange_result_row_by_scaling_factor = lagrange_result_row_shorter * scaling_factor;
    auto tmp_9 =
        (accumulators_binary_limbs_0_shorter - params.accumulated_result[0]) * lagrange_result_row_by_scaling_factor;
    std::get<8>(accumulators) += tmp_9;
 
    // Contribution (10)
    auto tmp_10 =
        (accumulators_binary_limbs_1_shorter - params.accumulated_result[1]) * lagrange_result_row_by_scaling_factor;
    std::get<9>(accumulators) += tmp_10;
 
    // Contribution (11)
    auto tmp_11 =
        (accumulators_binary_limbs_2_shorter - params.accumulated_result[2]) * lagrange_result_row_by_scaling_factor;
    std::get<10>(accumulators) += tmp_11;
 
    // Contribution (12)
    auto tmp_12 =
        (accumulators_binary_limbs_3_shorter - params.accumulated_result[3]) * lagrange_result_row_by_scaling_factor;
    std::get<11>(accumulators) += tmp_12;
};
 
template <typename FF>
template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
void TranslatorZeroConstraintsRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulators,
                                                           const AllEntities& in,
                                                           const Parameters& /*unused*/,
                                                           const FF& scaling_factor)
{
    using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
    using View = typename Accumulator::View;
 
    // Minus one
    static const auto minus_one = -FF(1);
    const auto lagrange_even_in_minicircuit = View(in.lagrange_even_in_minicircuit);
    const auto lagrange_odd_in_minicircuit = View(in.lagrange_odd_in_minicircuit);
 
    auto p_x_low_limbs_range_constraint_0 = View(in.p_x_low_limbs_range_constraint_0);
    auto p_x_low_limbs_range_constraint_1 = View(in.p_x_low_limbs_range_constraint_1);
    auto p_x_low_limbs_range_constraint_2 = View(in.p_x_low_limbs_range_constraint_2);
    auto p_x_low_limbs_range_constraint_3 = View(in.p_x_low_limbs_range_constraint_3);
    auto p_x_low_limbs_range_constraint_4 = View(in.p_x_low_limbs_range_constraint_4);
    auto p_x_high_limbs_range_constraint_0 = View(in.p_x_high_limbs_range_constraint_0);
    auto p_x_high_limbs_range_constraint_1 = View(in.p_x_high_limbs_range_constraint_1);
    auto p_x_high_limbs_range_constraint_2 = View(in.p_x_high_limbs_range_constraint_2);
    auto p_x_high_limbs_range_constraint_3 = View(in.p_x_high_limbs_range_constraint_3);
    auto p_x_high_limbs_range_constraint_4 = View(in.p_x_high_limbs_range_constraint_4);
    auto p_y_low_limbs_range_constraint_0 = View(in.p_y_low_limbs_range_constraint_0);
    auto p_y_low_limbs_range_constraint_1 = View(in.p_y_low_limbs_range_constraint_1);
    auto p_y_low_limbs_range_constraint_2 = View(in.p_y_low_limbs_range_constraint_2);
    auto p_y_low_limbs_range_constraint_3 = View(in.p_y_low_limbs_range_constraint_3);
    auto p_y_low_limbs_range_constraint_4 = View(in.p_y_low_limbs_range_constraint_4);
    auto p_y_high_limbs_range_constraint_0 = View(in.p_y_high_limbs_range_constraint_0);
    auto p_y_high_limbs_range_constraint_1 = View(in.p_y_high_limbs_range_constraint_1);
    auto p_y_high_limbs_range_constraint_2 = View(in.p_y_high_limbs_range_constraint_2);
    auto p_y_high_limbs_range_constraint_3 = View(in.p_y_high_limbs_range_constraint_3);
    auto p_y_high_limbs_range_constraint_4 = View(in.p_y_high_limbs_range_constraint_4);
    auto z_low_limbs_range_constraint_0 = View(in.z_low_limbs_range_constraint_0);
    auto z_low_limbs_range_constraint_1 = View(in.z_low_limbs_range_constraint_1);
    auto z_low_limbs_range_constraint_2 = View(in.z_low_limbs_range_constraint_2);
    auto z_low_limbs_range_constraint_3 = View(in.z_low_limbs_range_constraint_3);
    auto z_low_limbs_range_constraint_4 = View(in.z_low_limbs_range_constraint_4);
    auto z_high_limbs_range_constraint_0 = View(in.z_high_limbs_range_constraint_0);
    auto z_high_limbs_range_constraint_1 = View(in.z_high_limbs_range_constraint_1);
    auto z_high_limbs_range_constraint_2 = View(in.z_high_limbs_range_constraint_2);
    auto z_high_limbs_range_constraint_3 = View(in.z_high_limbs_range_constraint_3);
    auto z_high_limbs_range_constraint_4 = View(in.z_high_limbs_range_constraint_4);
    auto accumulator_low_limbs_range_constraint_0 = View(in.accumulator_low_limbs_range_constraint_0);
    auto accumulator_low_limbs_range_constraint_1 = View(in.accumulator_low_limbs_range_constraint_1);
    auto accumulator_low_limbs_range_constraint_2 = View(in.accumulator_low_limbs_range_constraint_2);
    auto accumulator_low_limbs_range_constraint_3 = View(in.accumulator_low_limbs_range_constraint_3);
    auto accumulator_low_limbs_range_constraint_4 = View(in.accumulator_low_limbs_range_constraint_4);
    auto accumulator_high_limbs_range_constraint_0 = View(in.accumulator_high_limbs_range_constraint_0);
    auto accumulator_high_limbs_range_constraint_1 = View(in.accumulator_high_limbs_range_constraint_1);
    auto accumulator_high_limbs_range_constraint_2 = View(in.accumulator_high_limbs_range_constraint_2);
    auto accumulator_high_limbs_range_constraint_3 = View(in.accumulator_high_limbs_range_constraint_3);
    auto accumulator_high_limbs_range_constraint_4 = View(in.accumulator_high_limbs_range_constraint_4);
    auto quotient_low_limbs_range_constraint_0 = View(in.quotient_low_limbs_range_constraint_0);
    auto quotient_low_limbs_range_constraint_1 = View(in.quotient_low_limbs_range_constraint_1);
    auto quotient_low_limbs_range_constraint_2 = View(in.quotient_low_limbs_range_constraint_2);
    auto quotient_low_limbs_range_constraint_3 = View(in.quotient_low_limbs_range_constraint_3);
    auto quotient_low_limbs_range_constraint_4 = View(in.quotient_low_limbs_range_constraint_4);
    auto quotient_high_limbs_range_constraint_0 = View(in.quotient_high_limbs_range_constraint_0);
    auto quotient_high_limbs_range_constraint_1 = View(in.quotient_high_limbs_range_constraint_1);
    auto quotient_high_limbs_range_constraint_2 = View(in.quotient_high_limbs_range_constraint_2);
    auto quotient_high_limbs_range_constraint_3 = View(in.quotient_high_limbs_range_constraint_3);
    auto quotient_high_limbs_range_constraint_4 = View(in.quotient_high_limbs_range_constraint_4);
    auto relation_wide_limbs_range_constraint_0 = View(in.relation_wide_limbs_range_constraint_0);
    auto relation_wide_limbs_range_constraint_1 = View(in.relation_wide_limbs_range_constraint_1);
    auto relation_wide_limbs_range_constraint_2 = View(in.relation_wide_limbs_range_constraint_2);
    auto relation_wide_limbs_range_constraint_3 = View(in.relation_wide_limbs_range_constraint_3);
    auto p_x_low_limbs_range_constraint_tail = View(in.p_x_low_limbs_range_constraint_tail);
    auto p_x_high_limbs_range_constraint_tail = View(in.p_x_high_limbs_range_constraint_tail);
    auto p_y_low_limbs_range_constraint_tail = View(in.p_y_low_limbs_range_constraint_tail);
    auto p_y_high_limbs_range_constraint_tail = View(in.p_y_high_limbs_range_constraint_tail);
    auto z_low_limbs_range_constraint_tail = View(in.z_low_limbs_range_constraint_tail);
    auto z_high_limbs_range_constraint_tail = View(in.z_high_limbs_range_constraint_tail);
    auto accumulator_low_limbs_range_constraint_tail = View(in.accumulator_low_limbs_range_constraint_tail);
    auto accumulator_high_limbs_range_constraint_tail = View(in.accumulator_high_limbs_range_constraint_tail);
    auto quotient_low_limbs_range_constraint_tail = View(in.quotient_low_limbs_range_constraint_tail);
    auto quotient_high_limbs_range_constraint_tail = View(in.quotient_high_limbs_range_constraint_tail);
    auto op = View(in.op);
    auto x_lo_y_hi = View(in.x_lo_y_hi);
    auto x_hi_z_1 = View(in.x_hi_z_1);
    auto y_lo_z_2 = View(in.y_lo_z_2);
    const auto lagrange_mini_masking = View(in.lagrange_mini_masking);
 
    // 0 in the minicircuit, -1 outside
    const auto not_in_mininicircuit_or_masked =
        (lagrange_odd_in_minicircuit + lagrange_even_in_minicircuit + lagrange_mini_masking + minus_one) *
        scaling_factor;
 
    // Contribution 0, ensure p_x_low_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<0>(accumulators) += p_x_low_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 1, ensure p_x_low_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<1>(accumulators) += p_x_low_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 2, ensure p_x_low_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<2>(accumulators) += p_x_low_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 3, ensure p_x_low_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<3>(accumulators) += p_x_low_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 4, ensure p_x_low_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<4>(accumulators) += p_x_low_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 5, ensure p_x_high_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<5>(accumulators) += p_x_high_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 6, ensure p_x_high_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<6>(accumulators) += p_x_high_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 7, ensure p_x_high_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<7>(accumulators) += p_x_high_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 8, ensure p_x_high_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<8>(accumulators) += p_x_high_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 9, ensure p_x_high_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<9>(accumulators) += p_x_high_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 10, ensure p_y_low_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<10>(accumulators) += p_y_low_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 11, ensure p_y_low_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<11>(accumulators) += p_y_low_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 12, ensure p_y_low_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<12>(accumulators) += p_y_low_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 13, ensure p_y_low_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<13>(accumulators) += p_y_low_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 14, ensure p_y_low_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<14>(accumulators) += p_y_low_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 15, ensure p_y_high_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<15>(accumulators) += p_y_high_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 16, ensure p_y_high_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<16>(accumulators) += p_y_high_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 17, ensure p_y_high_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<17>(accumulators) += p_y_high_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 18, ensure p_y_high_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<18>(accumulators) += p_y_high_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 19, ensure p_y_high_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<19>(accumulators) += p_y_high_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 20, ensure z_low_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<20>(accumulators) += z_low_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 21, ensure z_low_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<21>(accumulators) += z_low_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 22, ensure z_low_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<22>(accumulators) += z_low_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 23, ensure z_low_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<23>(accumulators) += z_low_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 24, ensure z_low_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<24>(accumulators) += z_low_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 25, ensure z_high_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<25>(accumulators) += z_high_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 26, ensure z_high_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<26>(accumulators) += z_high_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 27, ensure z_high_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<27>(accumulators) += z_high_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 28, ensure z_high_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<28>(accumulators) += z_high_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 29, ensure z_high_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<29>(accumulators) += z_high_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 30, ensure accumulator_low_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<30>(accumulators) += accumulator_low_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 31, ensure accumulator_low_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<31>(accumulators) += accumulator_low_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 32, ensure accumulator_low_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<32>(accumulators) += accumulator_low_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 33, ensure accumulator_low_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<33>(accumulators) += accumulator_low_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 34, ensure accumulator_low_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<34>(accumulators) += accumulator_low_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 35, ensure accumulator_high_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<35>(accumulators) += accumulator_high_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 36, ensure accumulator_high_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<36>(accumulators) += accumulator_high_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 37, ensure accumulator_high_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<37>(accumulators) += accumulator_high_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 38, ensure accumulator_high_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<38>(accumulators) += accumulator_high_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 39, ensure accumulator_high_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<39>(accumulators) += accumulator_high_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 40, ensure quotient_low_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<40>(accumulators) += quotient_low_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 41, ensure quotient_low_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<41>(accumulators) += quotient_low_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 42, ensure quotient_low_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<42>(accumulators) += quotient_low_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 43, ensure quotient_low_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<43>(accumulators) += quotient_low_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 44, ensure quotient_low_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<44>(accumulators) += quotient_low_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 45, ensure quotient_high_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<45>(accumulators) += quotient_high_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 46, ensure quotient_high_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<46>(accumulators) += quotient_high_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 47, ensure quotient_high_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<47>(accumulators) += quotient_high_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 48, ensure quotient_high_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<48>(accumulators) += quotient_high_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 49, ensure quotient_high_limbs_range_constraint_4 is 0 outside of minicircuit
    std::get<49>(accumulators) += quotient_high_limbs_range_constraint_4 * not_in_mininicircuit_or_masked;
 
    // Contribution 50, ensure relation_wide_limbs_range_constraint_0 is 0 outside of minicircuit
    std::get<50>(accumulators) += relation_wide_limbs_range_constraint_0 * not_in_mininicircuit_or_masked;
 
    // Contribution 51, ensure relation_wide_limbs_range_constraint_1 is 0 outside of minicircuit
    std::get<51>(accumulators) += relation_wide_limbs_range_constraint_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 52, ensure relation_wide_limbs_range_constraint_2 is 0 outside of minicircuit
    std::get<52>(accumulators) += relation_wide_limbs_range_constraint_2 * not_in_mininicircuit_or_masked;
 
    // Contribution 53, ensure relation_wide_limbs_range_constraint_3 is 0 outside of minicircuit
    std::get<53>(accumulators) += relation_wide_limbs_range_constraint_3 * not_in_mininicircuit_or_masked;
 
    // Contribution 54, ensure p_x_low_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<54>(accumulators) += p_x_low_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 55, ensure p_x_high_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<55>(accumulators) += p_x_high_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 56, ensure p_y_low_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<56>(accumulators) += p_y_low_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 57, ensure p_y_high_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<57>(accumulators) += p_y_high_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 58, ensure z_low_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<58>(accumulators) += z_low_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 59, ensure z_high_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<59>(accumulators) += z_high_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 60, ensure accumulator_low_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<60>(accumulators) += accumulator_low_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 61, ensure accumulator_high_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<61>(accumulators) += accumulator_high_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 62, ensure quotient_low_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<62>(accumulators) += quotient_low_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 63, ensure quotient_high_limbs_range_constraint_tail is 0 outside of minicircuit
    std::get<63>(accumulators) += quotient_high_limbs_range_constraint_tail * not_in_mininicircuit_or_masked;
 
    // Contribution 64, ensure op is 0 outside of minicircuit
    std::get<64>(accumulators) += op * not_in_mininicircuit_or_masked;
 
    // Contribution 65, ensure x_lo_y_hi is 0 outside of minicircuit
    std::get<65>(accumulators) += x_lo_y_hi * not_in_mininicircuit_or_masked;
 
    // Contribution 66, ensure x_hi_z_1 is 0 outside of minicircuit
    std::get<66>(accumulators) += x_hi_z_1 * not_in_mininicircuit_or_masked;
 
    // Contribution 67, ensure y_lo_z_2 is 0 outside of minicircuit
    std::get<67>(accumulators) += y_lo_z_2 * not_in_mininicircuit_or_masked;
};
} // namespace bb