feat(bb): towards reduced polynomial memory usage

barretenberg/cpp/src/barretenberg/benchmark/basics_bench/basics.bench.cpp

@@ -455,10 +455,10 @@ void pippenger(State& state)
         size_t num_cycles = 1 << static_cast<size_t>(state.range(0));
         Polynomial<Fr> pol(num_cycles);
         for (size_t i = 0; i < num_cycles; i++) {
-            *(uint256_t*)&pol[i] = engine.get_random_uint256();
-            pol[i].self_reduce_once();
-            pol[i].self_reduce_once();
-            pol[i].self_reduce_once();
+            *(uint256_t*)&pol.at(i) = engine.get_random_uint256();
+            pol.at(i).self_reduce_once();
+            pol.at(i).self_reduce_once();
+            pol.at(i).self_reduce_once();
         }
 
         auto ck = std::make_shared<CommitmentKey<curve::BN254>>(num_cycles);

barretenberg/cpp/src/barretenberg/benchmark/ipa_bench/ipa.bench.cpp

@@ -35,7 +35,7 @@ void ipa_open(State& state) noexcept
         // Construct the polynomial
         Polynomial poly(n);
         for (size_t i = 0; i < n; ++i) {
-            poly[i] = Fr::random_element(&engine);
+            poly.at(i) = Fr::random_element(&engine);
         }
         auto x = Fr::random_element(&engine);
         auto eval = poly.evaluate(x);

barretenberg/cpp/src/barretenberg/commitment_schemes/commit.bench.cpp

@@ -21,7 +21,7 @@ template <typename FF> Polynomial<FF> sparse_random_poly(const size_t size, cons
 
     for (size_t i = 0; i < num_nonzero; i++) {
         size_t idx = engine.get_random_uint32() % size;
-        polynomial[idx] = FF::random_element();
+        polynomial.at(idx) = FF::random_element();
     }
 
     return polynomial;
@@ -55,7 +55,7 @@ template <typename Curve> void bench_commit_sparse(::benchmark::State& state)
 
     auto polynomial = Polynomial<Fr>(num_points);
     for (size_t i = 0; i < num_nonzero; i++) {
-        polynomial[i] = 1;
+        polynomial.at(i) = 1;
     }
 
     for (auto _ : state) {
@@ -74,7 +74,7 @@ template <typename Curve> void bench_commit_sparse_preprocessed(::benchmark::Sta
 
     auto polynomial = Polynomial<Fr>(num_points);
     for (size_t i = 0; i < num_nonzero; i++) {
-        polynomial[i] = 1;
+        polynomial.at(i) = 1;
     }
 
     for (auto _ : state) {
@@ -121,8 +121,8 @@ template <typename Curve> void bench_commit_random(::benchmark::State& state)
     auto key = create_commitment_key<Curve>(MAX_NUM_POINTS);
 
     const size_t num_points = 1 << state.range(0);
-    auto polynomial = Polynomial<Fr>(num_points);
-    for (auto& coeff : polynomial) {
+    Polynomial<Fr> polynomial{ num_points };
+    for (auto& coeff : polynomial.coeffs()) {
         coeff = Fr::random_element();
     }
     for (auto _ : state) {

barretenberg/cpp/src/barretenberg/commitment_schemes/commitment_key.hpp

@@ -7,9 +7,11 @@
  * simplify the codebase.
  */
 
+#include "barretenberg/common/debug_log.hpp"
 #include "barretenberg/common/op_count.hpp"
 #include "barretenberg/ecc/scalar_multiplication/scalar_multiplication.hpp"
 #include "barretenberg/numeric/bitop/pow.hpp"
+#include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/polynomials/polynomial_arithmetic.hpp"
 #include "barretenberg/srs/factories/crs_factory.hpp"
 #include "barretenberg/srs/factories/file_crs_factory.hpp"
@@ -67,7 +69,7 @@ template <class Curve> class CommitmentKey {
      * @param polynomial a univariate polynomial p(X) = ∑ᵢ aᵢ⋅Xⁱ
      * @return Commitment computed as C = [p(x)] = ∑ᵢ aᵢ⋅Gᵢ
      */
-    Commitment commit(std::span<const Fr> polynomial)
+    Commitment commit(PolynomialSpan<const Fr> polynomial)
     {
         BB_OP_COUNT_TIME();
         const size_t degree = polynomial.size();
@@ -78,8 +80,16 @@ template <class Curve> class CommitmentKey {
                  srs->get_monomial_size());
             ASSERT(false);
         }
-        return scalar_multiplication::pippenger_unsafe<Curve>(
-            const_cast<Fr*>(polynomial.data()), srs->get_monomial_points(), degree, pippenger_runtime_state);
+
+        // Extract the precomputed point table (contains raw SRS points at even indices and the corresponding
+        // endomorphism point (\beta*x, -y) at odd indices). We offset by polynomial.start_index * 2 to align
+        // with our polynomial span.
+        G1* point_table = srs->get_monomial_points() + polynomial.start_index * 2;
+        DEBUG_LOG_ALL(polynomial.span);
+        Commitment point = scalar_multiplication::pippenger_unsafe<Curve>(
+            polynomial.data(), point_table, degree, pippenger_runtime_state);
+        DEBUG_LOG(point);
+        return point;
     };
 
     /**
@@ -92,19 +102,20 @@ template <class Curve> class CommitmentKey {
      * @param polynomial
      * @return Commitment
      */
-    Commitment commit_sparse(std::span<const Fr> polynomial)
+    Commitment commit_sparse(PolynomialSpan<const Fr> polynomial)
     {
         BB_OP_COUNT_TIME();
-        const size_t degree = polynomial.size();
-        ASSERT(degree <= srs->get_monomial_size());
+        const size_t poly_size = polynomial.size();
+        ASSERT(poly_size + polynomial.start_index * 2 <= srs->get_monomial_size());
 
         // Extract the precomputed point table (contains raw SRS points at even indices and the corresponding
-        // endomorphism point (\beta*x, -y) at odd indices).
-        G1* point_table = srs->get_monomial_points();
+        // endomorphism point (\beta*x, -y) at odd indices). We offset by polynomial.start_index * 2 to align
+        // with our polynomial spann.
+        G1* point_table = srs->get_monomial_points() + polynomial.start_index * 2;
 
         // Define structures needed to multithread the extraction of non-zero inputs
-        const size_t num_threads = degree >= get_num_cpus_pow2() ? get_num_cpus_pow2() : 1;
-        const size_t block_size = degree / num_threads;
+        const size_t num_threads = poly_size >= get_num_cpus_pow2() ? get_num_cpus_pow2() : 1;
+        const size_t block_size = poly_size / num_threads;
         std::vector<std::vector<Fr>> thread_scalars(num_threads);
         std::vector<std::vector<G1>> thread_points(num_threads);
 
@@ -115,7 +126,7 @@ template <class Curve> class CommitmentKey {
 
             for (size_t idx = start; idx < end; ++idx) {
 
-                const Fr& scalar = polynomial[idx];
+                const Fr& scalar = polynomial.span[idx];
 
                 if (!scalar.is_zero()) {
                     thread_scalars[thread_idx].emplace_back(scalar);

barretenberg/cpp/src/barretenberg/commitment_schemes/commitment_key.test.hpp

@@ -76,7 +76,7 @@ template <typename Curve> class CommitmentTest : public ::testing::Test {
     {
         Polynomial p(n);
         for (size_t i = 0; i < n; ++i) {
-            p[i] = Fr::random_element(engine);
+            p.at(i) = Fr::random_element(engine);
         }
         return p;
     }

barretenberg/cpp/src/barretenberg/commitment_schemes/gemini/gemini.test.cpp

@@ -44,12 +44,13 @@ template <class Curve> class GeminiTest : public CommitmentTest<Curve> {
         const size_t num_unshifted = multilinear_polynomials.size();
         const size_t num_shifted = multilinear_polynomials_to_be_shifted.size();
         for (size_t i = 0; i < num_unshifted; ++i) {
-            batched_unshifted.add_scaled(multilinear_polynomials[i], rhos[i]);
+            batched_unshifted.add_scaled({ /*start index*/ 0, multilinear_polynomials[i] }, rhos[i]);
             batched_commitment_unshifted += multilinear_commitments[i] * rhos[i];
         }
         for (size_t i = 0; i < num_shifted; ++i) {
             size_t rho_idx = num_unshifted + i;
-            batched_to_be_shifted.add_scaled(multilinear_polynomials_to_be_shifted[i], rhos[rho_idx]);
+            batched_to_be_shifted.add_scaled({ /*start index*/ 0, multilinear_polynomials_to_be_shifted[i] },
+                                             rhos[rho_idx]);
             batched_commitment_to_be_shifted += multilinear_commitments_to_be_shifted[i] * rhos[rho_idx];
         }
 
@@ -119,7 +120,7 @@ TYPED_TEST(GeminiTest, Single)
 
     // Collect multilinear polynomials evaluations, and commitments for input to prover/verifier
     std::vector<Fr> multilinear_evaluations = { eval };
-    std::vector<std::span<Fr>> multilinear_polynomials = { poly };
+    std::vector<std::span<Fr>> multilinear_polynomials = { poly.coeffs() };
     std::vector<std::span<Fr>> multilinear_polynomials_to_be_shifted = {};
     std::vector<GroupElement> multilinear_commitments = { commitment };
     std::vector<GroupElement> multilinear_commitments_to_be_shifted = {};
@@ -145,15 +146,15 @@ TYPED_TEST(GeminiTest, SingleShift)
 
     // shiftable polynomial must have 0 as last coefficient
     auto poly = this->random_polynomial(n);
-    poly[0] = Fr::zero();
+    poly.at(0) = Fr::zero();
 
     auto commitment = this->commit(poly);
     auto eval_shift = poly.evaluate_mle(u, true);
 
     // Collect multilinear polynomials evaluations, and commitments for input to prover/verifier
     std::vector<Fr> multilinear_evaluations = { eval_shift };
     std::vector<std::span<Fr>> multilinear_polynomials = {};
-    std::vector<std::span<Fr>> multilinear_polynomials_to_be_shifted = { poly };
+    std::vector<std::span<Fr>> multilinear_polynomials_to_be_shifted = { poly.coeffs() };
     std::vector<GroupElement> multilinear_commitments = {};
     std::vector<GroupElement> multilinear_commitments_to_be_shifted = { commitment };
 
@@ -187,7 +188,7 @@ TYPED_TEST(GeminiTest, Double)
 
     // Collect multilinear polynomials evaluations, and commitments for input to prover/verifier
     std::vector<Fr> multilinear_evaluations = { eval1, eval2 };
-    std::vector<std::span<Fr>> multilinear_polynomials = { poly1, poly2 };
+    std::vector<std::span<Fr>> multilinear_polynomials = { poly1.coeffs(), poly2.coeffs() };
     std::vector<std::span<Fr>> multilinear_polynomials_to_be_shifted = {};
     std::vector<GroupElement> multilinear_commitments = { commitment1, commitment2 };
     std::vector<GroupElement> multilinear_commitments_to_be_shifted = {};
@@ -212,8 +213,7 @@ TYPED_TEST(GeminiTest, DoubleWithShift)
     auto u = this->random_evaluation_point(log_n);
 
     auto poly1 = this->random_polynomial(n);
-    auto poly2 = this->random_polynomial(n);
-    poly2[0] = Fr::zero(); // necessary for polynomial to be 'shiftable'
+    auto poly2 = this->random_polynomial(n).unshifted(); // make 'shiftable'
 
     auto commitment1 = this->commit(poly1);
     auto commitment2 = this->commit(poly2);
@@ -224,8 +224,8 @@ TYPED_TEST(GeminiTest, DoubleWithShift)
 
     // Collect multilinear polynomials evaluations, and commitments for input to prover/verifier
     std::vector<Fr> multilinear_evaluations = { eval1, eval2, eval2_shift };
-    std::vector<std::span<Fr>> multilinear_polynomials = { poly1, poly2 };
-    std::vector<std::span<Fr>> multilinear_polynomials_to_be_shifted = { poly2 };
+    std::vector<std::span<Fr>> multilinear_polynomials = { poly1.coeffs(), poly2.coeffs() };
+    std::vector<std::span<Fr>> multilinear_polynomials_to_be_shifted = { poly2.coeffs() };
     std::vector<GroupElement> multilinear_commitments = { commitment1, commitment2 };
     std::vector<GroupElement> multilinear_commitments_to_be_shifted = { commitment2 };
 

barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.hpp

@@ -161,7 +161,8 @@ template <typename Curve_> class IPA {
 
         // Step 4.
         // Set initial vector a to the polynomial monomial coefficients and load vector G
-        auto a_vec = polynomial;
+        // Ensure the polynomial copy is fully-formed
+        auto a_vec = polynomial.expand(polynomial.start_index());
         auto* srs_elements = ck->srs->get_monomial_points();
         std::vector<Commitment> G_vec_local(poly_length);
 
@@ -212,16 +213,16 @@ template <typename Curve_> class IPA {
                 }, thread_heuristics::FF_ADDITION_COST * 2 + thread_heuristics::FF_MULTIPLICATION_COST * 2);
             // Sum inner product contributions computed in parallel and unpack the std::pair
             auto [inner_prod_L, inner_prod_R] = sum_pairs(inner_prods);
-            // Step 6.a (using letters, because doxygen automaticall converts the sublist counters to letters :( )
+            // Step 6.a (using letters, because doxygen automatically converts the sublist counters to letters :( )
             // L_i = < a_vec_lo, G_vec_hi > + inner_prod_L * aux_generator
             L_i = bb::scalar_multiplication::pippenger_without_endomorphism_basis_points<Curve>(
-                &a_vec[0], &G_vec_local[round_size], round_size, ck->pippenger_runtime_state);
+                a_vec.data(), &G_vec_local[round_size], round_size, ck->pippenger_runtime_state);
             L_i += aux_generator * inner_prod_L;
 
             // Step 6.b
             // R_i = < a_vec_hi, G_vec_lo > + inner_prod_R * aux_generator
             R_i = bb::scalar_multiplication::pippenger_without_endomorphism_basis_points<Curve>(
-                &a_vec[round_size], &G_vec_local[0], round_size, ck->pippenger_runtime_state);
+                &a_vec.data()[round_size], &G_vec_local[0], round_size, ck->pippenger_runtime_state);
             R_i += aux_generator * inner_prod_R;
 
             // Step 6.c
@@ -257,7 +258,7 @@ template <typename Curve_> class IPA {
             parallel_for_heuristic(
                 round_size,
                 [&](size_t j) {
-                    a_vec[j] += round_challenge * a_vec[round_size + j];
+                    a_vec.at(j) += round_challenge * a_vec[round_size + j];
                     b_vec[j] += round_challenge_inv * b_vec[round_size + j];
                 }, thread_heuristics::FF_ADDITION_COST * 2 + thread_heuristics::FF_MULTIPLICATION_COST * 2);
         }

barretenberg/cpp/src/barretenberg/commitment_schemes/ipa/ipa.test.cpp

@@ -33,9 +33,9 @@ TEST_F(IPATest, CommitOnManyZeroCoeffPolyWorks)
     constexpr size_t n = 4;
     Polynomial p(n);
     for (size_t i = 0; i < n - 1; i++) {
-        p[i] = Fr::zero();
+        p.at(i) = Fr::zero();
     }
-    p[3] = Fr::one();
+    p.at(3) = Fr::one();
     GroupElement commitment = this->commit(p);
     auto* srs_elements = this->ck()->srs->get_monomial_points();
     GroupElement expected = srs_elements[0] * p[0];
@@ -156,8 +156,8 @@ TEST_F(IPATest, AIsZeroAfterOneRound)
     size_t n = 4;
     auto poly = Polynomial(n);
     for (size_t i = 0; i < n / 2; i++) {
-        poly[i] = Fr::random_element();
-        poly[i + (n / 2)] = poly[i];
+        poly.at(i) = Fr::random_element();
+        poly.at(i + (n / 2)) = poly[i];
     }
     auto [x, eval] = this->random_eval(poly);
     auto commitment = this->commit(poly);
@@ -249,7 +249,7 @@ TEST_F(IPATest, GeminiShplonkIPAWithShift)
     const auto mle_opening_point = this->random_evaluation_point(log_n); // sometimes denoted 'u'
     auto poly1 = this->random_polynomial(n);
     auto poly2 = this->random_polynomial(n);
-    poly2[0] = Fr::zero(); // this property is required of polynomials whose shift is used
+    poly2.at(0) = Fr::zero(); // this property is required of polynomials whose shift is used
 
     GroupElement commitment1 = this->commit(poly1);
     GroupElement commitment2 = this->commit(poly2);

barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.hpp

@@ -36,7 +36,7 @@ template <typename Curve_> class KZG {
     {
         Polynomial quotient = opening_claim.polynomial;
         OpeningPair<Curve> pair = opening_claim.opening_pair;
-        quotient[0] -= pair.evaluation;
+        quotient.at(0) = quotient[0] - pair.evaluation;
         // Computes the coefficients for the quotient polynomial q(X) = (p(X) - v) / (X - r) through an FFT
         quotient.factor_roots(pair.challenge);
         auto quotient_commitment = ck->commit(quotient);

barretenberg/cpp/src/barretenberg/commitment_schemes/kzg/kzg.test.cpp

@@ -74,8 +74,7 @@ TYPED_TEST(KZGTest, GeminiShplonkKzgWithShift)
     // point.
     const auto mle_opening_point = this->random_evaluation_point(log_n); // sometimes denoted 'u'
     auto poly1 = this->random_polynomial(n);
-    auto poly2 = this->random_polynomial(n);
-    poly2[0] = Fr::zero(); // this property is required of polynomials whose shift is used
+    auto poly2 = this->random_polynomial(n).unshifted(); // shiftable
 
     GroupElement commitment1 = this->commit(poly1);
     GroupElement commitment2 = this->commit(poly2);

barretenberg/cpp/src/barretenberg/commitment_schemes/shplonk/shplonk.hpp

@@ -54,7 +54,7 @@ template <typename Curve> class ShplonkProver_ {
 
             // Compute individual claim quotient tmp = ( fⱼ(X) − vⱼ) / ( X − xⱼ )
             tmp = claim.polynomial;
-            tmp[0] -= claim.opening_pair.evaluation;
+            tmp.at(0) = tmp[0] - claim.opening_pair.evaluation;
             tmp.factor_roots(claim.opening_pair.challenge);
 
             // Add the claim quotient to the batched quotient polynomial
@@ -103,7 +103,7 @@ template <typename Curve> class ShplonkProver_ {
         for (const auto& claim : opening_claims) {
             // tmp = ρʲ ⋅ ( fⱼ(X) − vⱼ) / ( r − xⱼ )
             tmp = claim.polynomial;
-            tmp[0] -= claim.opening_pair.evaluation;
+            tmp.at(0) = tmp[0] - claim.opening_pair.evaluation;
             Fr scaling_factor = current_nu * inverse_vanishing_evals[idx]; // = ρʲ / ( r − xⱼ )
 
             // G -= ρʲ ⋅ ( fⱼ(X) − vⱼ) / ( r − xⱼ )

barretenberg/cpp/src/barretenberg/commitment_schemes/sparse_commitment.test.cpp

@@ -55,7 +55,7 @@ TYPED_TEST(CommitmentKeyTest, CommitSparse)
     Polynomial poly{ num_points };
     for (size_t i = 0; i < num_nonzero; ++i) {
         size_t idx = (i + 1) * (i + 1) % num_points;
-        poly[idx] = Fr::random_element();
+        poly.at(idx) = Fr::random_element();
     }
 
     // Commit to the polynomial using both the conventional commit method and the sparse commitment method