poseidon2_transition_entry_relation.hpp

Go to the documentation of this file.

#pragma once
#include "barretenberg/crypto/poseidon2/poseidon2_params.hpp"
#include "barretenberg/crypto/poseidon2/poseidon2_quad_params.hpp"
#include "relation_types.hpp"
 
namespace bb {
 
template <typename FF_> class Poseidon2TransitionEntryRelationImpl {
  public:
    using FF = FF_;
    using QuadParams = crypto::Poseidon2QuadBn254Params;
 
    static constexpr std::array<size_t, 3> SUBRELATION_PARTIAL_LENGTHS{
        7, // A_0: w_r_shift check  (state[0] at round 1)
        7, // A_1: w_o_shift check  (state[0] at round 2)
        7, // A_2: w_4_shift check  (state[0] at round 3)
    };
 
    static constexpr fr D1 = QuadParams::D1;
 
    // Linear round-propagation vectors shared with the closed-form interior relation:
    //   A_one[j]  = D_{j+1} + 2                    — wire coefs in A_1 (state[0] at round 2)
    //   A2_one[j] = D_{j+1}^2 + D_{j+1} + Σ + 4    — wire coefs in A_2 (state[0] at round 3)
    //   sum_A_one = Σ + 6                          — u_0 coefficient in A_2
    static constexpr auto& A_one = QuadParams::A_one;
    static constexpr auto& A2_one = QuadParams::A2_one;
    static constexpr fr sum_A_one = QuadParams::sum_A_one;
 
    template <typename AllEntities> inline static bool skip(const AllEntities& in)
    {
        return in.q_poseidon2_transition_entry.is_zero();
    }
 
    template <typename ContainerOverSubrelations, typename AllEntities, typename Parameters>
    void static accumulate(ContainerOverSubrelations& evals,
                           const AllEntities& in,
                           const Parameters& /*params*/,
                           const FF& scaling_factor)
    {
        using Accumulator = std::tuple_element_t<0, ContainerOverSubrelations>;
        using CoeffAcc = typename Accumulator::CoefficientAccumulator;
 
        const auto w_l = CoeffAcc(in.w_l);
        const auto w_r = CoeffAcc(in.w_r);
        const auto w_o = CoeffAcc(in.w_o);
        const auto w_4 = CoeffAcc(in.w_4);
 
        const auto w_r_shift = CoeffAcc(in.w_r_shift);
        const auto w_o_shift = CoeffAcc(in.w_o_shift);
        const auto w_4_shift = CoeffAcc(in.w_4_shift);
 
        const auto q_l = CoeffAcc(in.q_l);
        const auto q_r = CoeffAcc(in.q_r);
        const auto q_o = CoeffAcc(in.q_o);
        const auto q_sel = CoeffAcc(in.q_poseidon2_transition_entry);
 
        auto pow5 = [](const Accumulator& x) -> Accumulator {
            auto sq = x.sqr();
            auto quart = sq.sqr();
            return quart * x;
        };
 
        // u_0 = (w_l + q_l)^5
        auto u_0 = pow5(Accumulator(w_l + q_l));
        // u_1 = (w_r_shift + q_r)^5
        auto u_1 = pow5(Accumulator(w_r_shift + q_r));
        // u_2 = (w_o_shift + q_o)^5
        auto u_2 = pow5(Accumulator(w_o_shift + q_o));
 
        const auto q_by_scaling_m = q_sel * scaling_factor;
        const auto q_by_scaling = Accumulator(q_by_scaling_m);
 
        // Wire parts of the three subrelations, including shifted-row targets.
        auto wp_0 = w_r + w_o + w_4 - w_r_shift;
        auto wp_1 = w_r * A_one[0] + w_o * A_one[1] + w_4 * A_one[2] - w_o_shift;
        auto wp_2 = w_r * A2_one[0] + w_o * A2_one[1] + w_4 * A2_one[2] - w_4_shift;
 
        // A_0: D_1 u_0 + (w_r + w_o + w_4) - w_r_shift = 0.
        auto a0_body = u_0 * D1 + Accumulator(wp_0);
        std::get<0>(evals) += q_by_scaling * a0_body;
 
        // A_1: D_1 u_1 + 3 u_0 + (A·1)_j-weighted wire combo - w_o_shift = 0.
        auto a1_body = u_1 * D1 + u_0 * fr(3) + Accumulator(wp_1);
        std::get<1>(evals) += q_by_scaling * a1_body;
 
        // A_2: D_1 u_2 + 3 u_1 + (Σ+6) u_0 + (A^2·1)_j-weighted wire combo - w_4_shift = 0.
        auto a2_body = u_2 * D1 + u_1 * fr(3) + u_0 * sum_A_one + Accumulator(wp_2);
        std::get<2>(evals) += q_by_scaling * a2_body;
    }
};
 
template <typename FF> using Poseidon2TransitionEntryRelation = Relation<Poseidon2TransitionEntryRelationImpl<FF>>;
 
} // namespace bb