feat(sumcheck): [PR06] row-parallel compute_univariate via VectorField (WASM SIMD) (#186)

Introduce a row-parallel WASM-SIMD path for the sumcheck prover round. The round
is written once against an `Element` template parameter that is either scalar `FF`
(one trace row per iteration) or `VectorField<FF::Params>`, which packs 5 trace
rows per SIMD lane on WASM-SIMD builds of opted-in flavors. Scalar is the width-1
special case -- `FF`'s `from_lanes`, `horizontal_sum`, and `convert_to` are
identities -- so one code path serves both and element-type branches survive in
only a few named helpers.

Key points:

- Element-generic accumulate path. `accumulate_edge_chunks<Element>` drives the
  main loop with `EDGE_STRIDE = 2 * lane_count<Element>` (1 for `FF`, 5 for
  `VectorField`). `for_each_edge_group` sweeps full SIMD groups then a scalar
  leftover-pair tail; `reduce_accumulator<Element>` horizontally sums lanes into
  the FF round accumulator (a plain add for `FF`).

- Dispatch. `compute_univariate<Element = void>` resolves the element from an
  explicit per-flavor `USE_SIMD_SUMCHECK` opt-in, gated by
  `SupportsSimdSumcheck<Flavor> && simd_available_v<FF::Params> &&
  !USES_ROW_MANIFEST`; `BB_FORCE_SCALAR_LANE` forces scalar (A/B benchmarks).
  Ultra/Mega opt in; AVM stays scalar (it proves natively, SIMD is WASM-only).
  Parity tests pass the concrete element explicitly.

- VectorField primitives. `from_lanes` / `horizontal_sum` / `gather`, and
  `is_zero()` / `eq()` returning a bool with all-lanes semantics (per-lane mask
  forms live at `is_zero_mask` / `eq_mask`). The bool form is what the batched
  relation-skip and selector-gated subrelations require; the earlier raw-mask
  signature silently disabled gated subrelations on the SIMD path.

- Edge gather / parameters. `LazyExtendedEdges` is generalized over the element
  type, so columns of relations that skip a row are never gathered; its cache is
  heap-backed for `VectorField` (~33 KB on Mega would overflow thin WASM worker
  stacks) and stays inline for `FF`. `RelationParameters::convert_to<Element>`
  broadcasts every parameter next to its declaration; `GateSeparatorPolynomial::
  gather<Element>` does the stride-2 pow_beta read.

- Tuning. `ROWS_PER_CHUNK = 50` on the SIMD path (5 lane-batches per chunk, no
  scalar tail).

Correctness: bit-identical to the prior scalar path for both `FF` and
`VectorField`; `RowParallelParity` tests green across Mega/MegaZK/Ultra/UltraZK.
Performance: +5.02% aggregate chonk-prove (V8 / M3 Pro, threads = 8) across the
11 pinned flows.

Co-authored-by: iakovenkos <sergey.s.yakovenko@gmail.com>

Author: notnotraju

barretenberg/cpp/src/barretenberg/ecc/fields/field_declarations.hpp

@@ -333,6 +333,14 @@ template <class Params_> struct alignas(32) field {
     BB_INLINE constexpr field sqr() const noexcept;
     BB_INLINE constexpr void self_sqr() & noexcept;
 
+    // Reducing a scalar field's single lane returns itself. Lets `field` substitute for `VectorField` as a
+    // lane element type so per-lane reduction code (e.g. sumcheck's `reduce_accumulator`) needs no branch.
+    BB_INLINE constexpr field horizontal_sum() const noexcept { return *this; }
+
+    // Width-1 counterpart of `VectorField::from_lanes`: a scalar field has one lane, so it just evaluates
+    // `value_at` at lane 0. Lets `field` be gathered through the same lane-generic edge code as `VectorField`.
+    template <typename Fn> BB_INLINE static field from_lanes(const Fn& value_at) noexcept { return value_at(0); }
+
     BB_INLINE constexpr field pow(const uint256_t& exponent) const noexcept;
     BB_INLINE constexpr field pow(uint64_t exponent) const noexcept;
     // STARKNET: next line was commented as stark252 violates the assertion

barretenberg/cpp/src/barretenberg/ecc/fields/vector_field.bench.cpp

@@ -210,7 +210,7 @@ static void bench_vector_eq(State& state)
     volatile uint32_t sink = 0;
     for (auto _ : state) {
         for (int64_t it = 0; it < ITERATIONS; ++it) {
-            sink += a.eq(b);
+            sink += a.eq_mask(b);
             DoNotOptimize(sink);
         }
     }
@@ -225,7 +225,7 @@ static void bench_vector_is_zero(State& state)
     volatile uint32_t sink = 0;
     for (auto _ : state) {
         for (int64_t it = 0; it < ITERATIONS; ++it) {
-            sink += a.is_zero();
+            sink += a.is_zero_mask();
             DoNotOptimize(sink);
         }
     }

barretenberg/cpp/src/barretenberg/ecc/fields/vector_field.hpp

@@ -57,6 +57,9 @@
 
 namespace bb {
 
+// `if constexpr`-friendly form of BB_VECTOR_FIELD_SIMD: lets dispatch sites stay templated instead of `#if`d.
+inline constexpr bool vector_field_simd_enabled = BB_VECTOR_FIELD_SIMD;
+
 // ---------------------------------------------------------------------------
 // Compile-time constants derived from Params.
 // ---------------------------------------------------------------------------
@@ -129,7 +132,12 @@ inline constexpr bool simd_available_v = (BB_VECTOR_FIELD_SIMD != 0) && has_simd
 template <class Params> struct alignas(32) VectorField {
     using Field = field<Params>;
     using scalar_type = Field;
+    // Relation algebra resolves View / CoefficientAccumulator / modulus off the element type, so
+    // VectorField must mirror those names from `field<Params>` to drop in as the element type.
+    using View = VectorField;
+    using CoefficientAccumulator = VectorField;
     static constexpr size_t SIZE = 5;
+    static constexpr auto modulus = Field::modulus;
 
     // load_contiguous, store_contiguous, and the linear-memory ctor read/write
     // raw Field bytes at fixed offsets (+32, +48, ...). Catch any future drift
@@ -173,6 +181,31 @@ template <class Params> struct alignas(32) VectorField {
     // native).
     explicit VectorField(const std::array<Field, 5>& in) noexcept { store_from_array(in); }
 
+    // Implicit broadcast ctors -- mirror `field<Params>(int)`, `field<Params>(uint64_t)`, `field<Params>(Field)`
+    // so generic relation code like `q_arith_m - FF(1)` or multiplying an accumulator by a loop-invariant scalar
+    // constant (e.g. Poseidon round constants, typed as raw `fr`) compiles unchanged when FF=VectorField. The
+    // scalar value is broadcast to every lane.
+    VectorField(const Field& s) noexcept { *this = broadcast(s); }
+    VectorField(int s) noexcept { *this = broadcast(Field(s)); }
+    VectorField(uint64_t s) noexcept { *this = broadcast(Field(s)); }
+
+    static VectorField zero() noexcept { return broadcast(Field::zero()); }
+    static VectorField one() noexcept { return broadcast(Field::one()); }
+
+    VectorField sqr() const noexcept { return (*this) * (*this); }
+    void self_sqr() noexcept { *this = (*this) * (*this); }
+    VectorField operator-() const noexcept { return zero() - *this; }
+    // Per-lane scalar invert. Slow path -- for static-init constants and rare relation use. For batched
+    // inversions of independent values use the K=5 batch-inversion pattern in ecc/groups/element_impl.hpp.
+    VectorField invert() const noexcept
+    {
+        auto a = to_array();
+        for (auto& v : a) {
+            v = v.invert();
+        }
+        return VectorField(a);
+    }
+
     // Construct from 5 fields linear in memory (lane L = base[L] for L in
     // 0..4). This is the canonical construction path used by the
     // vectorised loop abstraction in place of `gather` — no random-access
@@ -193,6 +226,16 @@ template <class Params> struct alignas(32) VectorField {
         return out;
     }
 
+    Field horizontal_sum() const noexcept
+    {
+        const std::array<Field, SIZE> lanes = to_array();
+        Field sum = lanes[0];
+        for (size_t lane = 1; lane < SIZE; ++lane) {
+            sum += lanes[lane];
+        }
+        return sum;
+    }
+
     // Test/debug helpers — both pack/unpack the full 5-lane payload. Do not
     // use in hot code. For element-wise access use `to_array()` once and read
     // the result; for write-back use `load_contiguous` / `store_contiguous`.
@@ -217,6 +260,22 @@ template <class Params> struct alignas(32) VectorField {
     // the declaration is left unconstrained and callers route unsupported Params through the scalar path.
     VectorField operator*(const VectorField& other) const noexcept;
 
+    VectorField& operator+=(const VectorField& other) noexcept
+    {
+        *this = (*this) + other;
+        return *this;
+    }
+    VectorField& operator-=(const VectorField& other) noexcept
+    {
+        *this = (*this) - other;
+        return *this;
+    }
+    VectorField& operator*=(const VectorField& other) noexcept
+    {
+        *this = (*this) * other;
+        return *this;
+    }
+
     // SLOW PATH — for random-access patterns only. For contiguous loads/stores
     // use `load_contiguous` / `store_contiguous`, which avoid the per-lane
     // scalar pack/unpack and dispatch a single SIMD shuffle.
@@ -312,8 +371,15 @@ template <class Params> struct alignas(32) VectorField {
     }
 
     // Returns a 5-bit mask: bit 0 = scalar, bits 1..4 = quad lanes 0..3.
-    uint32_t eq(const VectorField& other) const noexcept;
-    uint32_t is_zero() const noexcept;
+    uint32_t eq_mask(const VectorField& other) const noexcept;
+    uint32_t is_zero_mask() const noexcept;
+
+    // Bool form: true iff EVERY lane satisfies the predicate. Prover relation gates coerce these to bool
+    // (e.g. `if (selector.is_zero()) skip`); a partially-non-zero lane pattern must read as not-zero, or
+    // the gate skips a subrelation that should fire on at least one of the rows packed into the lanes.
+    // The `_mask` form stays available for tests/microbenches that need per-lane visibility.
+    bool eq(const VectorField& other) const noexcept { return eq_mask(other) == 0b11111u; }
+    bool is_zero() const noexcept { return is_zero_mask() == 0b11111u; }
 
   private:
     void store_from_array(const std::array<Field, 5>& in) noexcept;
@@ -1035,7 +1101,7 @@ template <class Params>
 // a 4-lane all-ones/zero compare into a 4-bit integer mask in one instruction.
 
 template <class Params>
-[[gnu::always_inline]] inline uint32_t VectorField<Params>::eq(const VectorField& other) const noexcept
+[[gnu::always_inline]] inline uint32_t VectorField<Params>::eq_mask(const VectorField& other) const noexcept
 {
     const VectorField d = (*this) - other;
 
@@ -1119,7 +1185,7 @@ template <class Params>
     return scalar_eq | (lanes_eq << 1);
 }
 
-template <class Params> [[gnu::always_inline]] inline uint32_t VectorField<Params>::is_zero() const noexcept
+template <class Params> [[gnu::always_inline]] inline uint32_t VectorField<Params>::is_zero_mask() const noexcept
 {
     // Same pattern as eq, but on (*this) directly (no subtract).
     uint64_t sacc_z = scalar_data[0];
@@ -1316,7 +1382,7 @@ inline VectorField<Params> VectorField<Params>::operator*(const VectorField& oth
     return r;
 }
 
-template <class Params> inline uint32_t VectorField<Params>::eq(const VectorField& other) const noexcept
+template <class Params> inline uint32_t VectorField<Params>::eq_mask(const VectorField& other) const noexcept
 {
     uint32_t m = 0;
     for (size_t i = 0; i < 5; ++i) {
@@ -1327,7 +1393,7 @@ template <class Params> inline uint32_t VectorField<Params>::eq(const VectorFiel
     return m;
 }
 
-template <class Params> inline uint32_t VectorField<Params>::is_zero() const noexcept
+template <class Params> inline uint32_t VectorField<Params>::is_zero_mask() const noexcept
 {
     uint32_t m = 0;
     for (size_t i = 0; i < 5; ++i) {

barretenberg/cpp/src/barretenberg/ecc/fields/vector_field.test.cpp

@@ -98,19 +98,19 @@ TEST(VectorFieldTest, EqualityDetectsMatchesAndMismatches)
 
     // Same values — all 5 bits set.
     Vec vb(a);
-    EXPECT_EQ(va.eq(vb), 0b11111u);
+    EXPECT_EQ(va.eq_mask(vb), 0b11111u);
 
     // Flip lane 0: bit 0 clears.
     auto a2 = a;
     a2[0] = a2[0] + fr(1);
     Vec vc(a2);
-    EXPECT_EQ(va.eq(vc), 0b11110u);
+    EXPECT_EQ(va.eq_mask(vc), 0b11110u);
 
     // Flip lane 3: bit 3 clears.
     auto a3 = a;
     a3[3] = a3[3] + fr(1);
     Vec vd(a3);
-    EXPECT_EQ(va.eq(vd), 0b10111u);
+    EXPECT_EQ(va.eq_mask(vd), 0b10111u);
 }
 
 TEST(VectorFieldTest, EqualityAcceptsAliasedCoarseRepresentations)
@@ -131,7 +131,7 @@ TEST(VectorFieldTest, EqualityAcceptsAliasedCoarseRepresentations)
 
     Vec va(a);
     Vec vb(a_plus_p);
-    EXPECT_EQ(va.eq(vb), 0b11111u);
+    EXPECT_EQ(va.eq_mask(vb), 0b11111u);
 }
 
 TEST(VectorFieldTest, IsZeroDetectsZeroAndP)
@@ -144,7 +144,7 @@ TEST(VectorFieldTest, IsZeroDetectsZeroAndP)
     vals[4] = fr::zero();
 
     Vec v(vals);
-    uint32_t iz = v.is_zero();
+    uint32_t iz = v.is_zero_mask();
     // Lanes 0, 2, 4 should be zero; lanes 1, 3 non-zero.
     EXPECT_EQ(iz & 1u, 1u);
     EXPECT_EQ(iz & 2u, 0u);
@@ -162,7 +162,7 @@ TEST(VectorFieldTest, IsZeroAcceptsAliasedZero)
                              bb::Bn254FrParams::modulus_3 };
     std::array<fr, 5> vals{ fr::zero(), p_as_field, fr::zero(), p_as_field, fr::one() };
     Vec v(vals);
-    uint32_t iz = v.is_zero();
+    uint32_t iz = v.is_zero_mask();
     EXPECT_EQ(iz, 0b01111u);
 }
 
@@ -620,12 +620,12 @@ TEST(VectorFieldFqTest, EqualityDetectsMatchesAndMismatches)
     VecFq va(a);
 
     VecFq vb(a);
-    EXPECT_EQ(va.eq(vb), 0b11111u);
+    EXPECT_EQ(va.eq_mask(vb), 0b11111u);
 
     auto a_flipped = a;
     a_flipped[0] = a[0] + fq::one();
     VecFq vc(a_flipped);
-    EXPECT_EQ(va.eq(vc), 0b11110u);
+    EXPECT_EQ(va.eq_mask(vc), 0b11110u);
 }
 
 TEST(VectorFieldFqTest, IsZeroDetectsZeroAndP)
@@ -635,12 +635,12 @@ TEST(VectorFieldFqTest, IsZeroDetectsZeroAndP)
         x = fq::zero();
     }
     VecFq v_zero(zeros);
-    EXPECT_EQ(v_zero.is_zero(), 0b11111u);
+    EXPECT_EQ(v_zero.is_zero_mask(), 0b11111u);
 
     auto non_zero = random_five_fq();
     non_zero[0] = fq::one();
     VecFq v_nz(non_zero);
-    EXPECT_EQ(v_nz.is_zero(), 0u);
+    EXPECT_EQ(v_nz.is_zero_mask(), 0u);
 }
 
 TEST(VectorFieldFqTest, DistributivityMulOverAdd)
@@ -677,6 +677,76 @@ TEST(VectorFieldFqTest, ScalarTypeAlias)
     SUCCEED();
 }
 
+// `Vec` as a drop-in for `field<Params>` in templated relations / Univariate<Vec, K>: the static
+// identities, scalar-broadcast ctors, sqr, and lane-wise invert.
+
+TEST(VectorFieldTest, OneIsAllOnes)
+{
+    auto a = Vec::one().to_array();
+    for (size_t k = 0; k < 5; ++k) {
+        EXPECT_EQ(a[k], fr::one()) << "lane " << k;
+    }
+}
+
+TEST(VectorFieldTest, ZeroIsAllZeros)
+{
+    auto a = Vec::zero().to_array();
+    for (size_t k = 0; k < 5; ++k) {
+        EXPECT_TRUE(a[k].is_zero()) << "lane " << k;
+    }
+}
+
+TEST(VectorFieldTest, ScalarBroadcastCtors)
+{
+    fr s = fr::random_element();
+    auto a = Vec(s).to_array();
+    for (size_t k = 0; k < 5; ++k) {
+        EXPECT_EQ(a[k], s) << "lane " << k;
+    }
+
+    auto b = Vec(-2).to_array();
+    fr neg2 = fr(-2);
+    for (size_t k = 0; k < 5; ++k) {
+        EXPECT_EQ(b[k], neg2) << "lane " << k;
+    }
+
+    auto c = Vec(uint64_t{ 42 }).to_array();
+    fr forty_two = fr(uint64_t{ 42 });
+    for (size_t k = 0; k < 5; ++k) {
+        EXPECT_EQ(c[k], forty_two) << "lane " << k;
+    }
+}
+
+TEST(VectorFieldTest, SqrMatchesSelfMul)
+{
+    for (int trial = 0; trial < 16; ++trial) {
+        auto a = random_five();
+        std::array<fr, 5> expected;
+        for (size_t k = 0; k < 5; ++k) {
+            expected[k] = a[k] * a[k];
+        }
+        auto got = Vec(a).sqr().to_array();
+        EXPECT_TRUE(field_array_eq(expected, got)) << "trial " << trial;
+    }
+}
+
+TEST(VectorFieldTest, InvertLanewise)
+{
+    auto a = random_five();
+    std::array<fr, 5> expected;
+    for (size_t k = 0; k < 5; ++k) {
+        expected[k] = a[k].invert();
+    }
+    auto got = Vec(a).invert().to_array();
+    EXPECT_TRUE(field_array_eq(expected, got));
+
+    // x * x.invert() == 1 lane-wise.
+    auto prod = (Vec(a) * Vec(a).invert()).to_array();
+    for (size_t k = 0; k < 5; ++k) {
+        EXPECT_EQ(prod[k], fr::one()) << "lane " << k;
+    }
+}
+
 // Contiguous/gather transposes for Fq — the MSM production path (g1 coordinates are Fq),
 // mirroring the Fr round-trips above.
 TEST(VectorFieldFqTest, LinearMemoryCtorAndStoreToRoundTrip)

barretenberg/cpp/src/barretenberg/flavor/flavor_concepts.hpp

@@ -68,6 +68,16 @@ concept isMultilinearBatchingFlavor = IsMultilinearBatchingFlavorImpl<T>::value
 // flavors that don't declare the flag default to the serial loop.
 template <typename T> concept ParallelizesRelationBatching = requires { requires T::PARALLELIZE_RELATION_BATCHING; };
 
+// Sumcheck-prover opt-in: a flavor declares USE_SIMD_SUMCHECK = true to route compute_univariate through the
+// row-parallel SimdLane, which packs several trace rows into each SIMD lane and evaluates the relation set with
+// VectorField as the element type. Flavors that don't declare the flag default to the scalar lane. Requires a
+// Relations_<T> template so the relation set can re-instantiate over the lane element. Whether the SIMD path is
+// actually taken is gated at dispatch on simd_available_v<FF::Params> (build target + field capability), so on
+// native or non-SIMD fields these flavors still run scalar; see SumcheckProverRound::compute_univariate.
+template <typename T>
+concept SupportsSimdSumcheck =
+    requires { requires T::USE_SIMD_SUMCHECK; } && requires { typename T::template Relations_<typename T::FF>; };
+
 // Short-monomial flavors that expose the codegen'd array layout -- a `Generated` member (the generated
 // relation/entity definitions) together with an EntityId-keyed ProverUnivariates -- i.e. native Ultra/Mega.
 // The sumcheck prover materializes their edges lazily per column. ECCVM/Translator are short-monomial but lack the

barretenberg/cpp/src/barretenberg/flavor/mega_app_flavor.hpp

@@ -44,6 +44,8 @@ class MegaAppFlavor : public MegaAppFlavor_Generated {
 
     static constexpr size_t VIRTUAL_LOG_N = CONST_FOLDING_LOG_N;
     static constexpr bool USE_SHORT_MONOMIALS = true;
+    // opt in to the row-parallel (SIMD) sumcheck path; see SupportsSimdSumcheck in flavor_concepts.hpp
+    static constexpr bool USE_SIMD_SUMCHECK = true;
     static constexpr bool HasZK = false;
     static constexpr bool USE_PADDING = true;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;

barretenberg/cpp/src/barretenberg/flavor/mega_avm_flavor.hpp

@@ -43,6 +43,8 @@ class MegaAvmFlavor : public MegaAVMFlavor_Generated {
 
     static constexpr size_t VIRTUAL_LOG_N = MEGA_AVM_LOG_N;
     static constexpr bool USE_SHORT_MONOMIALS = true;
+    // No USE_SIMD_SUMCHECK: the SIMD sumcheck path is WASM-only today and the AVM proves natively. Opt in
+    // here once native SIMD field operations exist and can be routed through sumcheck's relation evaluation.
     static constexpr bool HasZK = false;
     static constexpr bool USE_PADDING = true;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;

barretenberg/cpp/src/barretenberg/flavor/mega_flavor.hpp

@@ -45,6 +45,8 @@ class MegaFlavor : public MegaFlavor_Generated {
     static constexpr size_t VIRTUAL_LOG_N = CONST_FOLDING_LOG_N;
     // indicates when evaluating sumcheck, edges can be left as degree-1 monomials
     static constexpr bool USE_SHORT_MONOMIALS = true;
+    // opt in to the row-parallel (SIMD) sumcheck path; see SupportsSimdSumcheck in flavor_concepts.hpp
+    static constexpr bool USE_SIMD_SUMCHECK = true;
     // Indicates that this flavor runs with non-ZK Sumcheck.
     static constexpr bool HasZK = false;
     // To achieve fixed proof size and that the recursive verifier circuit is constant, we are using padding in Sumcheck

barretenberg/cpp/src/barretenberg/flavor/mega_kernel_flavor.hpp

@@ -45,6 +45,8 @@ class MegaKernelFlavor : public MegaKernelFlavor_Generated {
 
     static constexpr size_t VIRTUAL_LOG_N = CONST_FOLDING_LOG_N;
     static constexpr bool USE_SHORT_MONOMIALS = true;
+    // opt in to the row-parallel (SIMD) sumcheck path; see SupportsSimdSumcheck in flavor_concepts.hpp
+    static constexpr bool USE_SIMD_SUMCHECK = true;
     static constexpr bool HasZK = false;
     static constexpr bool USE_PADDING = true;
     static constexpr size_t NUM_WIRES = CircuitBuilder::NUM_WIRES;