translator_permutation_short_relation_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_permutation_short_relation.hpp"
 
namespace bb {
 
template <typename FF>
template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
void TranslatorPermutationShortRelationImpl<FF>::accumulate(ContainerOverSubrelations& accumulators,
                                                            const AllEntities& in,
                                                            const Parameters& params,
                                                            const FF& scaling_factor)
{
    [&]() {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
        using View = TranslatorShortMonomialView<Accumulator>;
 
        const auto z_perm = View(in.z_perm);
        const auto z_perm_shift = View(in.z_perm_shift);
        const auto lagrange_first = View(in.lagrange_first);
        const auto lagrange_last = View(in.lagrange_last);
        const auto z_perm_and_first_scaled = (z_perm + lagrange_first) * scaling_factor;
        const auto z_perm_shift_and_last_scaled = (z_perm_shift + lagrange_last) * scaling_factor;
 
        // Contribution (1)
        std::get<0>(accumulators) +=
            (compute_grand_product_numerator_with_factor<Accumulator>(in, params, z_perm_and_first_scaled) -
             compute_grand_product_denominator_with_factor<Accumulator>(in, params, z_perm_shift_and_last_scaled));
    }();
 
    [&]() {
        using Accumulator = std::tuple_element_t<1, ContainerOverSubrelations>;
        using View = TranslatorShortMonomialView<Accumulator>;
 
        const auto z_perm_shift = View(in.z_perm_shift);
        const auto lagrange_last = View(in.lagrange_last);
        const auto lagrange_last_scaled = lagrange_last * scaling_factor;
 
        // Contribution (2): lagrange_last is nonzero only on the last row, so on the prover this contribution
        // vanishes on every edge that does not touch it; skip the product there. The verifier (incl. the
        // in-circuit recursive verifier) evaluates a single point and must compute unconditionally.
        if constexpr (std::is_same_v<Accumulator, FF>) {
            std::get<1>(accumulators) += Accumulator(lagrange_last_scaled * z_perm_shift);
        } else if (!in.lagrange_last.is_zero()) {
            std::get<1>(accumulators) += Accumulator(lagrange_last_scaled * z_perm_shift);
        }
    }();
 
    [&]() {
        using Accumulator = std::tuple_element_t<2, ContainerOverSubrelations>;
        using View = TranslatorShortMonomialView<Accumulator>;
 
        const auto z_perm = View(in.z_perm);
        const auto lagrange_first = View(in.lagrange_first);
        const auto lagrange_first_scaled = lagrange_first * scaling_factor;
 
        // Contribution (3): Enforce z_perm starts at 0. The grand product initialization relies on
        // z_perm[0] = 0 so that (z_perm + lagrange_first) evaluates to 1 at the first row.
        // lagrange_first is nonzero only on the first row; the prover skips it elsewhere, the verifier computes
        // unconditionally.
        if constexpr (std::is_same_v<Accumulator, FF>) {
            std::get<2>(accumulators) += Accumulator(lagrange_first_scaled * z_perm);
        } else if (!in.lagrange_first.is_zero()) {
            std::get<2>(accumulators) += Accumulator(lagrange_first_scaled * z_perm);
        }
    }();
};
} // namespace bb