From 35407e25081744702ec35efe3f95aa0137fe0ebb Mon Sep 17 00:00:00 2001
From: Cody Gunton <codygunton@gmail.com>
Date: Thu, 7 Sep 2023 14:41:14 -0400
Subject: [PATCH] refactor: protogalaxy relations (#1897)

Will resolve https://github.com/AztecProtocol/barretenberg/issues/682
and https://github.com/AztecProtocol/barretenberg/issues/685

- Add optimization to `extend` functions in `BarycentricData`.
- Move barycentric evaluation, univariate, and relations classes for
organizations and more efficient iteration.
- Simplify relations classes.
- Simplify relation consistency tests.

Cf also my comments below.

# Checklist:
Remove the checklist to signal you've completed it. Enable auto-merge if
the PR is ready to merge.
- [x] If the pull request requires a cryptography review (e.g.
cryptographic algorithm implementations) I have added the 'crypto' tag.
- [x] I have reviewed my diff in github, line by line and removed
unexpected formatting changes, testing logs, or commented-out code.
- [x] Every change is related to the PR description.
- [x] I have
[linked](https://docs.github.com/en/issues/tracking-your-work-with-issues/linking-a-pull-request-to-an-issue)
this pull request to relevant issues (if any exist).
---
 .../src/barretenberg/benchmark/CMakeLists.txt |   3 +-
 ...eline.sh => compare_branch_vs_baseline.sh} |   4 +-
 .../benchmark/relations_bench/CMakeLists.txt  |  19 +
 .../relations_bench/barycentric.bench.cpp     |  29 +
 .../benchmark/relations_bench/main.bench.cpp  |   3 +
 .../relations_bench/relations.bench.cpp       |  98 +++
 .../honk/composer/standard_composer.hpp       |   6 +-
 .../honk/composer/standard_composer.test.cpp  |   4 +-
 .../honk/composer/ultra_composer.test.cpp     |   4 +-
 .../barretenberg/honk/flavor/goblin_ultra.hpp |  48 +-
 .../src/barretenberg/honk/flavor/standard.hpp |  22 +-
 .../honk/flavor/standard_grumpkin.hpp         |  15 +-
 .../src/barretenberg/honk/flavor/ultra.hpp    |  43 +-
 .../honk/flavor/ultra_grumpkin.hpp            |  36 +-
 .../honk/flavor/ultra_recursive.hpp           |  29 +-
 .../proof_system/grand_product_library.hpp    |  11 +-
 .../barretenberg/honk/proof_system/prover.cpp |   2 +-
 .../barretenberg/honk/proof_system/prover.hpp |   2 +-
 .../honk/proof_system/prover_library.test.cpp |  12 +-
 .../honk/proof_system/ultra_prover.cpp        |  13 -
 .../honk/proof_system/ultra_prover.hpp        |   4 +-
 .../honk/proof_system/ultra_verifier.cpp      |   2 +-
 .../honk/proof_system/verifier.cpp            |   2 +-
 ...s.test.cpp => partial_evaluation.test.cpp} |  21 +-
 .../relation_correctness.test.cpp             |  56 +-
 .../relations/arithmetic_relation.hpp         |  59 --
 .../relations/relation_consistency.test.cpp   | 294 --------
 .../ultra_relation_consistency.test.cpp       | 681 ------------------
 .../barretenberg/honk/sumcheck/sumcheck.hpp   |  23 +-
 .../honk/sumcheck/sumcheck.test.cpp           |  38 +-
 .../honk/sumcheck/sumcheck_round.hpp          |  56 +-
 .../honk/sumcheck/sumcheck_round.test.cpp     |   7 +-
 .../honk/transcript/transcript.test.cpp       |   7 +-
 .../barycentric.hpp}                          | 103 +--
 .../barycentric.test.cpp}                     |   9 +-
 .../barretenberg/polynomials/polynomial.hpp   |   4 +-
 .../{honk/sumcheck => }/polynomials/pow.hpp   |   4 +-
 .../sumcheck => }/polynomials/pow.test.cpp    |  19 +-
 .../sumcheck => }/polynomials/univariate.hpp  |  26 +-
 .../polynomials/univariate.test.cpp           |  20 +-
 .../proof_system/flavor/flavor.hpp            |   6 +-
 .../relations/arithmetic_relation.hpp         |  57 ++
 .../relations/auxiliary_relation.hpp          |  26 +-
 .../relations/ecc_op_queue_relation.hpp       |  25 +-
 .../relations/elliptic_relation.hpp           |  26 +-
 .../relations/gen_perm_sort_relation.hpp      |  26 +-
 .../relations/lookup_relation.hpp             |  26 +-
 .../relations/permutation_relation.hpp        |  47 +-
 .../relations/relation_parameters.hpp         |  16 +-
 .../relations/relation_types.hpp              |  75 +-
 .../standard_relation_consistency.test.cpp    | 147 ++++
 .../relations/ultra_arithmetic_relation.hpp   |  26 +-
 .../ultra_relation_consistency.test.cpp       | 533 ++++++++++++++
 .../recursion/honk/transcript/transcript.hpp  |   3 +-
 .../honk/transcript/transcript.test.cpp       |   6 +-
 .../verifier/ultra_recursive_verifier.cpp     |   2 +-
 .../barretenberg/stdlib/utility/utility.hpp   |   7 +-
 .../transcript/transcript.test.cpp            |   4 +-
 58 files changed, 1351 insertions(+), 1545 deletions(-)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/{honk_bench/compare_honk_branch_vs_baseline.sh => compare_branch_vs_baseline.sh} (93%)
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/CMakeLists.txt
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/barycentric.bench.cpp
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/main.bench.cpp
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/relations.bench.cpp
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/{polynomials/multivariates.test.cpp => partial_evaluation.test.cpp} (95%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/{relations => }/relation_correctness.test.cpp (92%)
 delete mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp
 delete mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
 delete mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_relation_consistency.test.cpp
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck/polynomials/barycentric_data.hpp => polynomials/barycentric.hpp} (82%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck/polynomials/barycentric_data.test.cpp => polynomials/barycentric.test.cpp} (93%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => }/polynomials/pow.hpp (98%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => }/polynomials/pow.test.cpp (65%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => }/polynomials/univariate.hpp (92%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => }/polynomials/univariate.test.cpp (88%)
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/arithmetic_relation.hpp
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/auxiliary_relation.hpp (94%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/ecc_op_queue_relation.hpp (84%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/elliptic_relation.hpp (86%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/gen_perm_sort_relation.hpp (80%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/lookup_relation.hpp (91%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/permutation_relation.hpp (86%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/relation_parameters.hpp (53%)
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/relation_types.hpp (58%)
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/standard_relation_consistency.test.cpp
 rename circuits/cpp/barretenberg/cpp/src/barretenberg/{honk/sumcheck => proof_system}/relations/ultra_arithmetic_relation.hpp (87%)
 create mode 100644 circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_relation_consistency.test.cpp

diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/CMakeLists.txt
index 6387aa089ef..16f375379bb 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/CMakeLists.txt
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/CMakeLists.txt
@@ -1,4 +1,5 @@
 add_subdirectory(decrypt_bench)
 add_subdirectory(pippenger_bench)
 add_subdirectory(plonk_bench)
-add_subdirectory(honk_bench)
\ No newline at end of file
+add_subdirectory(honk_bench)
+add_subdirectory(relations_bench)
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/honk_bench/compare_honk_branch_vs_baseline.sh b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/compare_branch_vs_baseline.sh
similarity index 93%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/honk_bench/compare_honk_branch_vs_baseline.sh
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/compare_branch_vs_baseline.sh
index 612514c4149..f0105bb7a34 100755
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/honk_bench/compare_honk_branch_vs_baseline.sh
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/compare_branch_vs_baseline.sh
@@ -1,11 +1,11 @@
 #!/bin/bash
 
-# This script is used to compare the honk benchmarks between baseline (default: master) and
+# This script is used to compare a suite of benchmarks between baseline (default: master) and
 # the branch from which the script is run. Simply check out the branch of interest, ensure 
 # it is up to date with local master, and run the script.
 
 # Specify the benchmark suite and the "baseline" branch against which to compare
-BENCH_TARGET="ultra_honk_bench"
+BENCH_TARGET=${1:?"Please provide the name of a benchmark target."}
 BASELINE_BRANCH="master"
 
 echo -e "\nComparing $BENCH_TARGET between $BASELINE_BRANCH and current branch:"
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/CMakeLists.txt b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/CMakeLists.txt
new file mode 100644
index 00000000000..7fd8082895c
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/CMakeLists.txt
@@ -0,0 +1,19 @@
+# Each source represents a separate benchmark suite 
+set(BENCHMARK_SOURCES
+barycentric.bench.cpp
+relations.bench.cpp
+)
+
+# Required libraries for benchmark suites
+set(LINKED_LIBRARIES
+  polynomials
+  benchmark::benchmark
+)
+
+# Add executable and custom target for each suite, e.g. standard_honk_bench
+foreach(BENCHMARK_SOURCE ${BENCHMARK_SOURCES})
+  get_filename_component(BENCHMARK_NAME ${BENCHMARK_SOURCE} NAME_WE) # extract name without extension
+  add_executable(${BENCHMARK_NAME}_bench main.bench.cpp ${BENCHMARK_SOURCE})
+  target_link_libraries(${BENCHMARK_NAME}_bench ${LINKED_LIBRARIES})
+  add_custom_target(run_${BENCHMARK_NAME} COMMAND ${BENCHMARK_NAME} WORKING_DIRECTORY ${CMAKE_BINARY_DIR})
+endforeach()
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/barycentric.bench.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/barycentric.bench.cpp
new file mode 100644
index 00000000000..f6d4580fadf
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/barycentric.bench.cpp
@@ -0,0 +1,29 @@
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include <benchmark/benchmark.h>
+
+using namespace benchmark;
+
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
+using FF = barretenberg::fr;
+using barretenberg::Univariate;
+using barretenberg::BarycentricData;
+
+
+namespace proof_system::benchmark {
+
+void extend_2_to_6(State& state) noexcept
+{
+    auto univariate = Univariate<FF, 2>::get_random();
+    BarycentricData<FF, 2, 6> barycentric_2_to_6;
+    for (auto _ : state)
+    {
+        DoNotOptimize(barycentric_2_to_6.extend(univariate));
+    }
+}
+BENCHMARK(extend_2_to_6);
+
+} // namespace proof_system::benchmark
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/main.bench.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/main.bench.cpp
new file mode 100644
index 00000000000..71fefa04722
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/main.bench.cpp
@@ -0,0 +1,3 @@
+#include <benchmark/benchmark.h>
+
+BENCHMARK_MAIN();
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/relations.bench.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/relations.bench.cpp
new file mode 100644
index 00000000000..362d5b15b6c
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/benchmark/relations_bench/relations.bench.cpp
@@ -0,0 +1,98 @@
+#include "barretenberg/honk/flavor/goblin_ultra.hpp"
+#include "barretenberg/honk/flavor/standard.hpp"
+#include "barretenberg/honk/flavor/ultra.hpp"
+#include "barretenberg/proof_system/relations/arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/ecc_op_queue_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
+#include <benchmark/benchmark.h>
+
+namespace {
+auto& engine = numeric::random::get_debug_engine();
+}
+
+namespace proof_system::benchmark::relations {
+
+using FF = barretenberg::fr;
+
+template <typename Flavor, typename Relation> void execute_relation(::benchmark::State& state)
+{
+    // Generate beta and gamma
+    auto beta = FF::random_element();
+    auto gamma = FF::random_element();
+    auto public_input_delta = FF::random_element();
+
+    RelationParameters<FF> params{
+        .beta = beta,
+        .gamma = gamma,
+        .public_input_delta = public_input_delta,
+    };
+
+    using ClaimedEvaluations = typename Flavor::ClaimedEvaluations;
+    using RelationValues = typename Relation::RelationValues;
+
+    // Extract an array containing all the polynomial evaluations at a given row i
+    ClaimedEvaluations new_value;
+    // Define the appropriate RelationValues type for this relation and initialize to zero
+    RelationValues accumulator;
+    // Evaluate each constraint in the relation and check that each is satisfied
+
+    Relation relation;
+    for (auto _ : state) {
+        relation.add_full_relation_value_contribution(accumulator, new_value, params);
+    }
+}
+
+void arithmetic_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Standard, ArithmeticRelation<FF>>(state);
+}
+BENCHMARK(arithmetic_relation);
+
+void auxiliary_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Ultra, AuxiliaryRelation<FF>>(state);
+}
+BENCHMARK(auxiliary_relation);
+
+void elliptic_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Ultra, EllipticRelation<FF>>(state);
+}
+BENCHMARK(elliptic_relation);
+
+void ecc_op_queue_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::GoblinUltra, EccOpQueueRelation<FF>>(state);
+}
+BENCHMARK(ecc_op_queue_relation);
+
+void gen_perm_sort_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Ultra, GenPermSortRelation<FF>>(state);
+}
+BENCHMARK(gen_perm_sort_relation);
+
+void lookup_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Ultra, LookupRelation<FF>>(state);
+}
+BENCHMARK(lookup_relation);
+
+void permutation_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Standard, PermutationRelation<FF>>(state);
+}
+BENCHMARK(permutation_relation);
+
+void ultra_arithmetic_relation(::benchmark::State& state) noexcept
+{
+    execute_relation<honk::flavor::Ultra, UltraArithmeticRelation<FF>>(state);
+}
+BENCHMARK(ultra_arithmetic_relation);
+
+} // namespace proof_system::benchmark::relations
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp
index 9d94311686b..2117058d747 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.hpp
@@ -25,7 +25,7 @@ template <StandardFlavor Flavor> class StandardComposer_ {
     std::shared_ptr<VerificationKey> verification_key;
 
     // The crs_factory holds the path to the srs and exposes methods to extract the srs elements
-    std::shared_ptr<srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory_;
+    std::shared_ptr<barretenberg::srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory_;
 
     // The commitment key is passed to the prover but also used herein to compute the verfication key commitments
     std::shared_ptr<CommitmentKey> commitment_key;
@@ -47,11 +47,11 @@ template <StandardFlavor Flavor> class StandardComposer_ {
         }
     }
 
-    StandardComposer_(std::shared_ptr<srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory)
+    StandardComposer_(std::shared_ptr<barretenberg::srs::factories::CrsFactory<typename Flavor::Curve>> crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
 
-    StandardComposer_(std::unique_ptr<srs::factories::CrsFactory<typename Flavor::Curve>>&& crs_factory)
+    StandardComposer_(std::unique_ptr<barretenberg::srs::factories::CrsFactory<typename Flavor::Curve>>&& crs_factory)
         : crs_factory_(std::move(crs_factory))
     {}
     StandardComposer_(std::shared_ptr<ProvingKey> p_key, std::shared_ptr<VerificationKey> v_key)
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp
index 21872ce863f..56568cbbf11 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/standard_composer.test.cpp
@@ -5,8 +5,8 @@
 
 #include "barretenberg/honk/composer/standard_composer.hpp"
 #include "barretenberg/honk/proof_system/prover.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/relation_parameters.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/relation_parameters.hpp"
 #include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
 #include "barretenberg/honk/utils/grand_product_delta.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp
index 9cc1b3b088f..777242c05f2 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/composer/ultra_composer.test.cpp
@@ -8,8 +8,8 @@
 #include "barretenberg/honk/composer/ultra_composer.hpp"
 #include "barretenberg/honk/proof_system/prover.hpp"
 #include "barretenberg/honk/proof_system/ultra_prover.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/relation_parameters.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/relation_parameters.hpp"
 #include "barretenberg/honk/sumcheck/sumcheck_round.hpp"
 #include "barretenberg/honk/utils/grand_product_delta.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp
index 2b56c16e6cc..894fe54304d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/goblin_ultra.hpp
@@ -1,27 +1,16 @@
 #pragma once
-#include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/kzg/kzg.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ecc_op_queue_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/ecc_op_queue_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
-#include "barretenberg/polynomials/evaluation_domain.hpp"
-#include "barretenberg/polynomials/polynomial.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
 #include "barretenberg/proof_system/flavor/flavor.hpp"
-#include "barretenberg/srs/factories/crs_factory.hpp"
-#include <array>
-#include <concepts>
-#include <span>
-#include <string>
-#include <type_traits>
-#include <vector>
 
 namespace proof_system::honk::flavor {
 
@@ -50,16 +39,17 @@ class GoblinUltra {
     // The total number of witness entities not including shifts.
     static constexpr size_t NUM_WITNESS_ENTITIES = 15; // 11 (UH) + 4 op wires
 
-    using GrandProductRelations = std::tuple<sumcheck::UltraPermutationRelation<FF>, sumcheck::LookupRelation<FF>>;
+    using GrandProductRelations =
+        std::tuple<proof_system::UltraPermutationRelation<FF>, proof_system::LookupRelation<FF>>;
 
     // define the tuple of Relations that comprise the Sumcheck relation
-    using Relations = std::tuple<sumcheck::UltraArithmeticRelation<FF>,
-                                 sumcheck::UltraPermutationRelation<FF>,
-                                 sumcheck::LookupRelation<FF>,
-                                 sumcheck::GenPermSortRelation<FF>,
-                                 sumcheck::EllipticRelation<FF>,
-                                 sumcheck::AuxiliaryRelation<FF>,
-                                 sumcheck::EccOpQueueRelation<FF>>;
+    using Relations = std::tuple<proof_system::UltraArithmeticRelation<FF>,
+                                 proof_system::UltraPermutationRelation<FF>,
+                                 proof_system::LookupRelation<FF>,
+                                 proof_system::GenPermSortRelation<FF>,
+                                 proof_system::EllipticRelation<FF>,
+                                 proof_system::AuxiliaryRelation<FF>,
+                                 proof_system::EccOpQueueRelation<FF>>;
 
     static constexpr size_t MAX_RELATION_LENGTH = get_max_relation_length<Relations>();
 
@@ -338,8 +328,8 @@ class GoblinUltra {
      * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
     template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges =
-        AllEntities<sumcheck::Univariate<FF, MAX_RELATION_LENGTH>, sumcheck::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
+                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
 
     /**
      * @brief A container for the polynomials evaluations produced during sumcheck, which are purported to be the
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp
index 91324a69ea1..c0a4a53776e 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard.hpp
@@ -1,22 +1,16 @@
 #pragma once
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/kzg/kzg.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
-#include "barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/proof_system/circuit_builder/standard_circuit_builder.hpp"
 #include "barretenberg/proof_system/flavor/flavor.hpp"
 #include "barretenberg/srs/factories/crs_factory.hpp"
-#include <array>
-#include <concepts>
-#include <span>
-#include <string>
-#include <type_traits>
-#include <vector>
 
 namespace proof_system::honk::flavor {
 
@@ -52,9 +46,9 @@ class Standard {
     // The total number of witness entities not including shifts.
     static constexpr size_t NUM_WITNESS_ENTITIES = 4;
 
-    using GrandProductRelations = std::tuple<sumcheck::PermutationRelation<FF>>;
+    using GrandProductRelations = std::tuple<proof_system::PermutationRelation<FF>>;
     // define the tuple of Relations that comprise the Sumcheck relation
-    using Relations = std::tuple<sumcheck::ArithmeticRelation<FF>, sumcheck::PermutationRelation<FF>>;
+    using Relations = std::tuple<proof_system::ArithmeticRelation<FF>, proof_system::PermutationRelation<FF>>;
 
     static constexpr size_t MAX_RELATION_LENGTH = get_max_relation_length<Relations>();
 
@@ -234,8 +228,8 @@ class Standard {
      * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
     template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges =
-        AllEntities<sumcheck::Univariate<FF, MAX_RELATION_LENGTH>, sumcheck::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
+                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
 
     /**
      * @brief A container for the polynomials evaluations produced during sumcheck, which are purported to be the
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp
index bf9ecbaadee..957c52aceb4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/standard_grumpkin.hpp
@@ -1,10 +1,11 @@
 #pragma once
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/ipa/ipa.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
-#include "barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
+#include "barretenberg/proof_system/relations/arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
@@ -45,9 +46,9 @@ class StandardGrumpkin {
     static constexpr size_t NUM_WITNESS_ENTITIES = 4;
 
     // define the tuple of Relations that require grand products
-    using GrandProductRelations = std::tuple<sumcheck::PermutationRelation<FF>>;
+    using GrandProductRelations = std::tuple<proof_system::PermutationRelation<FF>>;
     // define the tuple of Relations that comprise the Sumcheck relation
-    using Relations = std::tuple<sumcheck::ArithmeticRelation<FF>, sumcheck::PermutationRelation<FF>>;
+    using Relations = std::tuple<proof_system::ArithmeticRelation<FF>, proof_system::PermutationRelation<FF>>;
 
     static constexpr size_t MAX_RELATION_LENGTH = get_max_relation_length<Relations>();
 
@@ -226,7 +227,7 @@ class StandardGrumpkin {
      */
     template <size_t MAX_RELATION_LENGTH>
     using ExtendedEdges =
-        AllEntities<sumcheck::Univariate<FF, MAX_RELATION_LENGTH>, sumcheck::Univariate<FF, MAX_RELATION_LENGTH>>;
+        AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>, barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
 
     /**
      * @brief A container for the polynomials evaluations produced during sumcheck, which are purported to be the
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp
index d5c348f2df6..1323ed98874 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra.hpp
@@ -1,26 +1,20 @@
 #pragma once
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/kzg/kzg.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/proof_system/circuit_builder/ultra_circuit_builder.hpp"
 #include "barretenberg/proof_system/flavor/flavor.hpp"
-#include "barretenberg/srs/factories/crs_factory.hpp"
-#include <array>
-#include <concepts>
-#include <span>
-#include <string>
-#include <type_traits>
-#include <vector>
 
 namespace proof_system::honk::flavor {
 
@@ -49,14 +43,15 @@ class Ultra {
     // The total number of witness entities not including shifts.
     static constexpr size_t NUM_WITNESS_ENTITIES = 11;
 
-    using GrandProductRelations = std::tuple<sumcheck::UltraPermutationRelation<FF>, sumcheck::LookupRelation<FF>>;
+    using GrandProductRelations =
+        std::tuple<proof_system::UltraPermutationRelation<FF>, proof_system::LookupRelation<FF>>;
     // define the tuple of Relations that comprise the Sumcheck relation
-    using Relations = std::tuple<sumcheck::UltraArithmeticRelation<FF>,
-                                 sumcheck::UltraPermutationRelation<FF>,
-                                 sumcheck::LookupRelation<FF>,
-                                 sumcheck::GenPermSortRelation<FF>,
-                                 sumcheck::EllipticRelation<FF>,
-                                 sumcheck::AuxiliaryRelation<FF>>;
+    using Relations = std::tuple<proof_system::UltraArithmeticRelation<FF>,
+                                 proof_system::UltraPermutationRelation<FF>,
+                                 proof_system::LookupRelation<FF>,
+                                 proof_system::GenPermSortRelation<FF>,
+                                 proof_system::EllipticRelation<FF>,
+                                 proof_system::AuxiliaryRelation<FF>>;
 
     static constexpr size_t MAX_RELATION_LENGTH = get_max_relation_length<Relations>();
 
@@ -302,8 +297,8 @@ class Ultra {
      * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
     template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges =
-        AllEntities<sumcheck::Univariate<FF, MAX_RELATION_LENGTH>, sumcheck::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
+                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
 
     /**
      * @brief A container for the polynomials evaluations produced during sumcheck, which are purported to be the
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp
index 173ee9de622..260b2f44b76 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_grumpkin.hpp
@@ -2,14 +2,15 @@
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/ipa/ipa.hpp"
 #include "barretenberg/honk/pcs/kzg/kzg.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
@@ -51,14 +52,15 @@ class UltraGrumpkin {
     // The total number of witness entities not including shifts.
     static constexpr size_t NUM_WITNESS_ENTITIES = 11;
 
-    using GrandProductRelations = std::tuple<sumcheck::UltraPermutationRelation<FF>, sumcheck::LookupRelation<FF>>;
+    using GrandProductRelations =
+        std::tuple<proof_system::UltraPermutationRelation<FF>, proof_system::LookupRelation<FF>>;
     // define the tuple of Relations that comprise the Sumcheck relation
-    using Relations = std::tuple<sumcheck::UltraArithmeticRelation<FF>,
-                                 sumcheck::UltraPermutationRelation<FF>,
-                                 sumcheck::LookupRelation<FF>,
-                                 sumcheck::GenPermSortRelation<FF>,
-                                 sumcheck::EllipticRelation<FF>,
-                                 sumcheck::AuxiliaryRelation<FF>>;
+    using Relations = std::tuple<proof_system::UltraArithmeticRelation<FF>,
+                                 proof_system::UltraPermutationRelation<FF>,
+                                 proof_system::LookupRelation<FF>,
+                                 proof_system::GenPermSortRelation<FF>,
+                                 proof_system::EllipticRelation<FF>,
+                                 proof_system::AuxiliaryRelation<FF>>;
 
     static constexpr size_t MAX_RELATION_LENGTH = get_max_relation_length<Relations>();
 
@@ -302,8 +304,8 @@ class UltraGrumpkin {
      * @todo TODO(#390): Simplify this by moving MAX_RELATION_LENGTH?
      */
     template <size_t MAX_RELATION_LENGTH>
-    using ExtendedEdges =
-        AllEntities<sumcheck::Univariate<FF, MAX_RELATION_LENGTH>, sumcheck::Univariate<FF, MAX_RELATION_LENGTH>>;
+    using ExtendedEdges = AllEntities<barretenberg::Univariate<FF, MAX_RELATION_LENGTH>,
+                                      barretenberg::Univariate<FF, MAX_RELATION_LENGTH>>;
 
     /**
      * @brief A container for the polynomials evaluations produced during sumcheck, which are purported to be the
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_recursive.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_recursive.hpp
index 1484a5b5fe1..e050d7b6597 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_recursive.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/flavor/ultra_recursive.hpp
@@ -2,14 +2,15 @@
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/commitment_key.hpp"
 #include "barretenberg/honk/pcs/kzg/kzg.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
@@ -61,12 +62,12 @@ class UltraRecursive {
     static constexpr size_t NUM_WITNESS_ENTITIES = 11;
 
     // define the tuple of Relations that comprise the Sumcheck relation
-    using Relations = std::tuple<sumcheck::UltraArithmeticRelation<FF>,
-                                 sumcheck::UltraPermutationRelation<FF>,
-                                 sumcheck::LookupRelation<FF>,
-                                 sumcheck::GenPermSortRelation<FF>,
-                                 sumcheck::EllipticRelation<FF>,
-                                 sumcheck::AuxiliaryRelation<FF>>;
+    using Relations = std::tuple<proof_system::UltraArithmeticRelation<FF>,
+                                 proof_system::UltraPermutationRelation<FF>,
+                                 proof_system::LookupRelation<FF>,
+                                 proof_system::GenPermSortRelation<FF>,
+                                 proof_system::EllipticRelation<FF>,
+                                 proof_system::AuxiliaryRelation<FF>>;
 
     static constexpr size_t MAX_RELATION_LENGTH = get_max_relation_length<Relations>();
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/grand_product_library.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/grand_product_library.hpp
index f8bdbb00584..53405a3aede 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/grand_product_library.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/grand_product_library.hpp
@@ -2,6 +2,7 @@
 #include "barretenberg/honk/sumcheck/sumcheck.hpp"
 #include "barretenberg/plonk/proof_system/proving_key/proving_key.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
+#include "barretenberg/common/constexpr_utils.hpp"
 #include <typeinfo>
 
 namespace proof_system::honk::grand_product_library {
@@ -47,11 +48,11 @@ namespace proof_system::honk::grand_product_library {
 template <typename Flavor, typename GrandProdRelation>
 void compute_grand_product(const size_t circuit_size,
                            auto& full_polynomials,
-                           sumcheck::RelationParameters<typename Flavor::FF>& relation_parameters)
+                           proof_system::RelationParameters<typename Flavor::FF>& relation_parameters)
 {
     using FF = typename Flavor::FF;
     using Polynomial = typename Flavor::Polynomial;
-    using ValueAccumTypes = typename GrandProdRelation::ValueAccumTypes;
+    using ValueAccumulatorsAndViews = typename GrandProdRelation::ValueAccumulatorsAndViews;
 
     // Allocate numerator/denominator polynomials that will serve as scratch space
     // TODO(zac) we can re-use the permutation polynomial as the numerator polynomial. Reduces readability
@@ -71,9 +72,9 @@ void compute_grand_product(const size_t circuit_size,
             for (size_t k = 0; k < Flavor::NUM_ALL_ENTITIES; ++k) {
                 evaluations[k] = full_polynomials[k].size() > i ? full_polynomials[k][i] : 0;
             }
-            numerator[i] = GrandProdRelation::template compute_grand_product_numerator<ValueAccumTypes>(
+            numerator[i] = GrandProdRelation::template compute_grand_product_numerator<ValueAccumulatorsAndViews>(
                 evaluations, relation_parameters, i);
-            denominator[i] = GrandProdRelation::template compute_grand_product_denominator<ValueAccumTypes>(
+            denominator[i] = GrandProdRelation::template compute_grand_product_denominator<ValueAccumulatorsAndViews>(
                 evaluations, relation_parameters, i);
         }
     });
@@ -140,7 +141,7 @@ void compute_grand_product(const size_t circuit_size,
 template <typename Flavor>
 void compute_grand_products(std::shared_ptr<typename Flavor::ProvingKey>& key,
                             typename Flavor::ProverPolynomials& full_polynomials,
-                            sumcheck::RelationParameters<typename Flavor::FF>& relation_parameters)
+                            proof_system::RelationParameters<typename Flavor::FF>& relation_parameters)
 {
     using GrandProductRelations = typename Flavor::GrandProductRelations;
     using FF = typename Flavor::FF;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.cpp
index a4a6b38e1de..1e35a281877 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.cpp
@@ -107,7 +107,7 @@ template <StandardFlavor Flavor> void StandardProver_<Flavor>::execute_grand_pro
 
     auto public_input_delta = compute_public_input_delta<Flavor>(public_inputs, beta, gamma, key->circuit_size);
 
-    relation_parameters = sumcheck::RelationParameters<FF>{
+    relation_parameters = proof_system::RelationParameters<FF>{
         .beta = beta,
         .gamma = gamma,
         .public_input_delta = public_input_delta,
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.hpp
index ac97786e4ff..d871d5c8b6c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover.hpp
@@ -51,7 +51,7 @@ template <StandardFlavor Flavor> class StandardProver_ {
 
     std::vector<FF> public_inputs;
 
-    sumcheck::RelationParameters<FF> relation_parameters;
+    proof_system::RelationParameters<FF> relation_parameters;
 
     std::shared_ptr<ProvingKey> key;
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp
index fd064571cda..af679985ff3 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/prover_library.test.cpp
@@ -1,11 +1,11 @@
 
+#include "prover_library.hpp"
 #include "barretenberg/ecc/curves/bn254/bn254.hpp"
 #include "barretenberg/honk/flavor/standard.hpp"
 #include "barretenberg/honk/flavor/ultra.hpp"
 #include "barretenberg/honk/proof_system/grand_product_library.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "prover.hpp"
-#include "prover_library.hpp"
 
 #include "barretenberg/srs/factories/file_crs_factory.hpp"
 #include <array>
@@ -88,7 +88,7 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         auto beta = FF::random_element();
         auto gamma = FF::random_element();
 
-        sumcheck::RelationParameters<FF> params{
+        proof_system::RelationParameters<FF> params{
             .eta = 0,
             .beta = beta,
             .gamma = gamma,
@@ -125,12 +125,12 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         using LHS =
             typename std::tuple_element<PERMUTATION_RELATION_INDEX, typename Flavor::GrandProductRelations>::type;
         if constexpr (Flavor::NUM_WIRES == 4) {
-            using RHS = typename sumcheck::UltraPermutationRelation<FF>;
+            using RHS = typename proof_system::UltraPermutationRelation<FF>;
             static_assert(std::same_as<LHS, RHS>);
             grand_product_library::compute_grand_product<Flavor, RHS>(
                 proving_key->circuit_size, prover_polynomials, params);
         } else {
-            using RHS = sumcheck::PermutationRelation<FF>;
+            using RHS = proof_system::PermutationRelation<FF>;
             static_assert(std::same_as<LHS, RHS>);
             grand_product_library::compute_grand_product<Flavor, RHS>(
                 proving_key->circuit_size, prover_polynomials, params);
@@ -262,7 +262,7 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         auto gamma = FF::random_element();
         auto eta = FF::random_element();
 
-        sumcheck::RelationParameters<FF> params{
+        proof_system::RelationParameters<FF> params{
             .eta = eta,
             .beta = beta,
             .gamma = gamma,
@@ -298,7 +298,7 @@ template <class FF> class ProverLibraryTests : public testing::Test {
         // Method 1: Compute z_lookup using the prover library method
         constexpr size_t LOOKUP_RELATION_INDEX = 1;
         using LHS = typename std::tuple_element<LOOKUP_RELATION_INDEX, typename Flavor::GrandProductRelations>::type;
-        using RHS = sumcheck::LookupRelation<FF>;
+        using RHS = proof_system::LookupRelation<FF>;
         static_assert(std::same_as<LHS, RHS>);
         grand_product_library::compute_grand_product<Flavor, RHS>(
             proving_key->circuit_size, prover_polynomials, params);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp
index b2f673b7cab..c26dfdbfbc6 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.cpp
@@ -1,24 +1,11 @@
 #include "ultra_prover.hpp"
-#include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/pcs/claim.hpp"
 #include "barretenberg/honk/proof_system/grand_product_library.hpp"
 #include "barretenberg/honk/proof_system/prover_library.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp" // will go away
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
 #include "barretenberg/honk/sumcheck/sumcheck.hpp"
 #include "barretenberg/honk/utils/power_polynomial.hpp"
 #include "barretenberg/polynomials/polynomial.hpp"
 #include "barretenberg/transcript/transcript_wrappers.hpp"
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <memory>
-#include <span>
-#include <string>
-#include <utility>
-#include <vector>
 
 namespace proof_system::honk {
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
index 4c711743921..5f4a5460a3f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_prover.hpp
@@ -5,7 +5,7 @@
 #include "barretenberg/honk/pcs/gemini/gemini.hpp"
 #include "barretenberg/honk/pcs/shplonk/shplonk.hpp"
 #include "barretenberg/honk/proof_system/work_queue.hpp"
-#include "barretenberg/honk/sumcheck/relations/relation_parameters.hpp"
+#include "barretenberg/proof_system/relations/relation_parameters.hpp"
 #include "barretenberg/honk/sumcheck/sumcheck_output.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
 #include "barretenberg/plonk/proof_system/types/proof.hpp"
@@ -47,7 +47,7 @@ template <UltraFlavor Flavor> class UltraProver_ {
     std::vector<FF> public_inputs;
     size_t pub_inputs_offset; // offset of the PI relative to 0th index in the wire polynomials
 
-    sumcheck::RelationParameters<FF> relation_parameters;
+    proof_system::RelationParameters<FF> relation_parameters;
 
     std::shared_ptr<ProvingKey> key;
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp
index 565df400d8f..548c8177a81 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/ultra_verifier.cpp
@@ -44,7 +44,7 @@ template <typename Flavor> bool UltraVerifier_<Flavor>::verify_proof(const plonk
     using VerifierCommitments = typename Flavor::VerifierCommitments;
     using CommitmentLabels = typename Flavor::CommitmentLabels;
 
-    RelationParameters<FF> relation_parameters;
+    proof_system::RelationParameters<FF> relation_parameters;
 
     transcript = VerifierTranscript<FF>{ proof.proof_data };
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp
index 146d73ab686..3a500f68de7 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/proof_system/verifier.cpp
@@ -97,7 +97,7 @@ template <typename Flavor> bool StandardVerifier_<Flavor>::verify_proof(const pl
 
     const FF public_input_delta = compute_public_input_delta<Flavor>(public_inputs, beta, gamma, circuit_size);
 
-    sumcheck::RelationParameters<FF> relation_parameters{
+    proof_system::RelationParameters<FF> relation_parameters{
         .beta = beta,
         .gamma = gamma,
         .public_input_delta = public_input_delta,
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/multivariates.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/partial_evaluation.test.cpp
similarity index 95%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/multivariates.test.cpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/partial_evaluation.test.cpp
index 82c26a54353..b84b30c72e8 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/multivariates.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/partial_evaluation.test.cpp
@@ -1,20 +1,15 @@
-#include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp"
-#include "barretenberg/honk/sumcheck/sumcheck.hpp"
-
 #include "barretenberg/honk/flavor/standard.hpp"
-#include "barretenberg/honk/transcript/transcript.hpp"
-#include "barretenberg/numeric/random/engine.hpp"
+#include "barretenberg/honk/sumcheck/sumcheck.hpp"
 #include <gtest/gtest.h>
 
 using namespace proof_system::honk::sumcheck;
 namespace test_sumcheck_polynomials {
 
-template <typename Flavor> class MultivariatesTests : public testing::Test {};
+template <typename Flavor> class PartialEvaluationTests : public testing::Test {};
 
 using Flavors = testing::Types<honk::flavor::Standard>;
 
-TYPED_TEST_SUITE(MultivariatesTests, Flavors);
+TYPED_TEST_SUITE(PartialEvaluationTests, Flavors);
 
 /*
  * We represent a bivariate f0 as f0(X0, X1). The indexing starts from 0 to match with the round number in sumcheck.
@@ -42,7 +37,7 @@ TYPED_TEST_SUITE(MultivariatesTests, Flavors);
  * f0(u0,u1) = (v00 * (1-u0) + v10 * u0) * (1-u1)
  *           + (v01 * (1-u0) + v11 * u0) *   u1.
  */
-TYPED_TEST(MultivariatesTests, FoldTwoRoundsSpecial)
+TYPED_TEST(PartialEvaluationTests, TwoRoundsSpecial)
 {
     using Flavor = TypeParam;
     using FF = typename Flavor::FF;
@@ -80,7 +75,7 @@ TYPED_TEST(MultivariatesTests, FoldTwoRoundsSpecial)
     EXPECT_EQ(sumcheck.partially_evaluated_polynomials[0][0], expected_val);
 }
 
-TYPED_TEST(MultivariatesTests, FoldTwoRoundsGeneric)
+TYPED_TEST(PartialEvaluationTests, TwoRoundsGeneric)
 {
     using Flavor = TypeParam;
     using FF = typename Flavor::FF;
@@ -137,7 +132,7 @@ TYPED_TEST(MultivariatesTests, FoldTwoRoundsGeneric)
  * f0(u0, u1, u2) = [(v000 * (1-u0) + v100 * u0) * (1-u1) + (v010 * (1-u0) + v110 * u0) * u1] * (1-u2)
  *                + [(v001 * (1-u0) + v101 * u0) * (1-u1) + (v011 * (1-u0) + v111 * u0) * u1] *   u2.
  */
-TYPED_TEST(MultivariatesTests, FoldThreeRoundsSpecial)
+TYPED_TEST(PartialEvaluationTests, ThreeRoundsSpecial)
 {
     using Flavor = TypeParam;
     using FF = typename Flavor::FF;
@@ -188,7 +183,7 @@ TYPED_TEST(MultivariatesTests, FoldThreeRoundsSpecial)
     EXPECT_EQ(sumcheck.partially_evaluated_polynomials[0][0], expected_val);
 }
 
-TYPED_TEST(MultivariatesTests, FoldThreeRoundsGeneric)
+TYPED_TEST(PartialEvaluationTests, ThreeRoundsGeneric)
 {
     using Flavor = TypeParam;
     using FF = typename Flavor::FF;
@@ -239,7 +234,7 @@ TYPED_TEST(MultivariatesTests, FoldThreeRoundsGeneric)
     EXPECT_EQ(sumcheck.partially_evaluated_polynomials[0][0], expected_val);
 }
 
-TYPED_TEST(MultivariatesTests, FoldThreeRoundsGenericMultiplePolys)
+TYPED_TEST(PartialEvaluationTests, ThreeRoundsGenericMultiplePolys)
 {
     using Flavor = TypeParam;
     using FF = typename Flavor::FF;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relation_correctness.test.cpp
similarity index 92%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relation_correctness.test.cpp
index f88bb12de1e..884bc3e31c4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_correctness.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relation_correctness.test.cpp
@@ -1,18 +1,17 @@
-#include <gtest/gtest.h>
-
 #include "barretenberg/honk/composer/standard_composer.hpp"
 #include "barretenberg/honk/composer/ultra_composer.hpp"
 #include "barretenberg/honk/proof_system/grand_product_library.hpp"
 #include "barretenberg/honk/proof_system/prover_library.hpp"
-#include "barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ecc_op_queue_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/relation_parameters.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/ecc_op_queue_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/relation_parameters.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
+#include <gtest/gtest.h>
 
 using namespace proof_system::honk;
 
@@ -239,7 +238,7 @@ TEST_F(RelationCorrectnessTests, StandardRelationCorrectness)
     auto public_input_delta =
         honk::compute_public_input_delta<Flavor>(public_inputs, beta, gamma, prover.key->circuit_size);
 
-    sumcheck::RelationParameters<FF> params{
+    proof_system::RelationParameters<FF> params{
         .beta = beta,
         .gamma = gamma,
         .public_input_delta = public_input_delta,
@@ -272,7 +271,8 @@ TEST_F(RelationCorrectnessTests, StandardRelationCorrectness)
     grand_product_library::compute_grand_products<honk::flavor::Standard>(prover.key, prover_polynomials, params);
 
     // Construct the round for applying sumcheck relations and results for storing computed results
-    auto relations = std::tuple(honk::sumcheck::ArithmeticRelation<FF>(), honk::sumcheck::PermutationRelation<FF>());
+    auto relations =
+        std::tuple(proof_system::ArithmeticRelation<FF>(), proof_system::PermutationRelation<FF>());
 
     // Check that each relation is satisfied across each row of the prover polynomials
     check_relation<Flavor>(std::get<0>(relations), circuit_size, prover_polynomials, params);
@@ -325,7 +325,7 @@ TEST_F(RelationCorrectnessTests, UltraRelationCorrectness)
     auto lookup_grand_product_delta =
         honk::compute_lookup_grand_product_delta<FF>(beta, gamma, prover.key->circuit_size);
 
-    sumcheck::RelationParameters<FF> params{
+    proof_system::RelationParameters<FF> params{
         .eta = eta,
         .beta = beta,
         .gamma = gamma,
@@ -392,12 +392,12 @@ TEST_F(RelationCorrectnessTests, UltraRelationCorrectness)
     ensure_non_zero(prover.key->q_aux);
 
     // Construct the round for applying sumcheck relations and results for storing computed results
-    auto relations = std::tuple(honk::sumcheck::UltraArithmeticRelation<FF>(),
-                                honk::sumcheck::UltraPermutationRelation<FF>(),
-                                honk::sumcheck::LookupRelation<FF>(),
-                                honk::sumcheck::GenPermSortRelation<FF>(),
-                                honk::sumcheck::EllipticRelation<FF>(),
-                                honk::sumcheck::AuxiliaryRelation<FF>());
+    auto relations = std::tuple(proof_system::UltraArithmeticRelation<FF>(),
+                                proof_system::UltraPermutationRelation<FF>(),
+                                proof_system::LookupRelation<FF>(),
+                                proof_system::GenPermSortRelation<FF>(),
+                                proof_system::EllipticRelation<FF>(),
+                                proof_system::AuxiliaryRelation<FF>());
 
     // Check that each relation is satisfied across each row of the prover polynomials
     check_relation<Flavor>(std::get<0>(relations), circuit_size, prover_polynomials, params);
@@ -449,7 +449,7 @@ TEST_F(RelationCorrectnessTests, GoblinUltraRelationCorrectness)
     auto lookup_grand_product_delta =
         honk::compute_lookup_grand_product_delta<FF>(beta, gamma, prover.key->circuit_size);
 
-    sumcheck::RelationParameters<FF> params{
+    proof_system::RelationParameters<FF> params{
         .eta = eta,
         .beta = beta,
         .gamma = gamma,
@@ -522,13 +522,13 @@ TEST_F(RelationCorrectnessTests, GoblinUltraRelationCorrectness)
     ensure_non_zero(prover.key->q_aux);
 
     // Construct the round for applying sumcheck relations and results for storing computed results
-    auto relations = std::tuple(honk::sumcheck::UltraArithmeticRelation<FF>(),
-                                honk::sumcheck::UltraPermutationRelation<FF>(),
-                                honk::sumcheck::LookupRelation<FF>(),
-                                honk::sumcheck::GenPermSortRelation<FF>(),
-                                honk::sumcheck::EllipticRelation<FF>(),
-                                honk::sumcheck::AuxiliaryRelation<FF>(),
-                                honk::sumcheck::EccOpQueueRelation<FF>());
+    auto relations = std::tuple(proof_system::UltraArithmeticRelation<FF>(),
+                                proof_system::UltraPermutationRelation<FF>(),
+                                proof_system::LookupRelation<FF>(),
+                                proof_system::GenPermSortRelation<FF>(),
+                                proof_system::EllipticRelation<FF>(),
+                                proof_system::AuxiliaryRelation<FF>(),
+                                proof_system::EccOpQueueRelation<FF>());
 
     // Check that each relation is satisfied across each row of the prover polynomials
     check_relation<Flavor>(std::get<0>(relations), circuit_size, prover_polynomials, params);
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp
deleted file mode 100644
index e9de26471ca..00000000000
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/arithmetic_relation.hpp
+++ /dev/null
@@ -1,59 +0,0 @@
-#pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
-#include "relation_parameters.hpp"
-#include "relation_types.hpp"
-
-namespace proof_system::honk::sumcheck {
-
-template <typename FF> class ArithmeticRelationBase {
-  public:
-    // 1 + polynomial degree of this relation
-    static constexpr size_t RELATION_LENGTH = 4;
-
-    static constexpr size_t LEN_1 = 4; // arithmetic sub-relation
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1>;
-
-    /**
-     * @brief Expression for the StandardArithmetic gate.
-     * @details The relation is defined as C(extended_edges(X)...) =
-     *    (q_m * w_r * w_l) + (q_l * w_l) + (q_r * w_r) + (q_o * w_o) + q_c
-     *
-     * @param evals transformed to `evals + C(extended_edges(X)...)*scaling_factor`
-     * @param extended_edges an std::array containing the fully extended Univariate edges.
-     * @param parameters contains beta, gamma, and public_input_delta, ....
-     * @param scaling_factor optional term to scale the evaluation before adding to evals.
-     */
-    template <typename AccumulatorTypes>
-    void static add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulator,
-                                           const auto& extended_edges,
-                                           const RelationParameters<FF>&,
-                                           const FF& scaling_factor)
-    {
-        // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
-        //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
-
-        using View = typename std::tuple_element<0, typename AccumulatorTypes::AccumulatorViews>::type;
-        auto w_l = View(extended_edges.w_l);
-        auto w_r = View(extended_edges.w_r);
-        auto w_o = View(extended_edges.w_o);
-        auto q_m = View(extended_edges.q_m);
-        auto q_l = View(extended_edges.q_l);
-        auto q_r = View(extended_edges.q_r);
-        auto q_o = View(extended_edges.q_o);
-        auto q_c = View(extended_edges.q_c);
-
-        auto tmp = w_l * (q_m * w_r + q_l);
-        tmp += q_r * w_r;
-        tmp += q_o * w_o;
-        tmp += q_c;
-        tmp *= scaling_factor;
-        std::get<0>(accumulator) += tmp;
-    };
-};
-
-template <typename FF> using ArithmeticRelation = RelationWrapper<FF, ArithmeticRelationBase>;
-} // namespace proof_system::honk::sumcheck
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
deleted file mode 100644
index 038212c28f5..00000000000
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_consistency.test.cpp
+++ /dev/null
@@ -1,294 +0,0 @@
-#include "../polynomials/barycentric_data.hpp"
-#include "../polynomials/univariate.hpp"
-#include "arithmetic_relation.hpp"
-#include "barretenberg/honk/flavor/standard.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
-#include "permutation_relation.hpp"
-#include "relation_parameters.hpp"
-
-#include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barretenberg/numeric/random/engine.hpp"
-
-#include <cstddef>
-#include <gtest/gtest.h>
-using namespace proof_system::honk::sumcheck;
-/**
- * The purpose of this test suite is to show that the identity arithmetic implemented in the Relations is equivalent to
- * a simpler unoptimized version implemented in the tests themselves. This is useful 1) as documentation since the
- * simple implementations here should make the underlying arithmetic easier to see, and 2) as a check that optimizations
- * introduced into the Relations have not changed the result.
- *
- * For this purpose, we simply feed (the same) random inputs into each of the two implementations and confirm that
- * the outputs match. This does not confirm the correctness of the identity arithmetic (the identities will not be
- * satisfied in general by random inputs) only that the two implementations are equivalent.
- */
-static const size_t INPUT_UNIVARIATE_LENGTH = 2;
-
-namespace proof_system::honk_relation_tests {
-
-class StandardRelationConsistency : public testing::Test {
-  public:
-    using Flavor = honk::flavor::Standard;
-    using FF = typename Flavor::FF;
-    using ClaimedEvaluations = typename Flavor::ClaimedEvaluations;
-    // TODO(#390): Move MAX_RELATION_LENGTH into Flavor and simplify this.
-
-    template <size_t t> using ExtendedEdges = typename Flavor::template ExtendedEdges<t>;
-
-    // TODO(#225)(Adrian): Accept FULL_RELATION_LENGTH as a template parameter for this function only, so that the
-    // test can decide to which degree the polynomials must be extended. Possible accept an existing list of
-    // "edges" and extend them to the degree.
-    template <size_t FULL_RELATION_LENGTH, size_t NUM_POLYNOMIALS>
-    static void compute_mock_extended_edges(
-        ExtendedEdges<FULL_RELATION_LENGTH>& extended_edges,
-        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS>& input_edges)
-    {
-        BarycentricData<FF, INPUT_UNIVARIATE_LENGTH, FULL_RELATION_LENGTH> barycentric_2_to_max =
-            BarycentricData<FF, INPUT_UNIVARIATE_LENGTH, FULL_RELATION_LENGTH>();
-        for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-            extended_edges[i] = barycentric_2_to_max.extend(input_edges[i]);
-        }
-    }
-
-    /**
-     * @brief Returns randomly sampled parameters to feed to the relations.
-     *
-     * @return RelationParameters<FF>
-     */
-    RelationParameters<FF> compute_mock_relation_parameters()
-    {
-        return { .eta = FF::random_element(),
-                 .beta = FF::random_element(),
-                 .gamma = FF::random_element(),
-                 .public_input_delta = FF::random_element(),
-                 .lookup_grand_product_delta = FF::random_element() };
-    }
-
-    /**
-     * @brief Given an array of Univariates, create a new array containing only the i-th evaluations
-     * of all the univariates.
-     *
-     * @note Not really optimized, mainly used for testing that the relations evaluate to the same value when
-     * evaluated as Univariates, Expressions, or index-by-index
-     * @todo(Adrian) Maybe this is more helpful as part of a `check_logic` function.
-     *
-     * @tparam NUM_UNIVARIATES number of univariates in the input array (deduced from `univariates`)
-     * @tparam univariate_length number of evaluations (deduced from `univariates`)
-     * @param univariates array of Univariates
-     * @param i index of the evaluations we want to take from each univariate
-     * @return std::array<FF, NUM_UNIVARIATES> such that result[j] = univariates[j].value_at(i)
-     */
-    template <size_t univariate_length>
-    static ClaimedEvaluations transposed_univariate_array_at(ExtendedEdges<univariate_length> univariates, size_t i)
-    {
-        ASSERT(i < univariate_length);
-        std::array<FF, Flavor::NUM_ALL_ENTITIES> result;
-        size_t result_idx = 0; // TODO(#391) zip
-        for (auto& univariate : univariates) {
-            result[result_idx] = univariate.value_at(i);
-            ++result_idx;
-        }
-        return result;
-    };
-
-    /**
-     * @brief Compute the evaluation of a `relation` in different ways, comparing it to the provided `expected_evals`
-     *
-     * @details Check both `add_full_relation_value_contribution` and `add_edge_contribution` by comparing the result to
-     * the `expected_evals` computed by the caller.
-     * Ensures that the relations compute the same result as the expression given in the tests.
-     *
-     * @param expected_evals Relation evaluation computed by the caller.
-     * @param relation being tested
-     * @param extended_edges
-     * @param relation_parameters
-     */
-    template <size_t FULL_RELATION_LENGTH>
-    static void validate_evaluations(const auto& expected_full_length_univariates, /* array of Univariates*/
-                                     const auto relation,
-                                     const ExtendedEdges<FULL_RELATION_LENGTH>& extended_edges,
-                                     const RelationParameters<FF>& relation_parameters)
-    {
-        // First check that the verifier's computation on individual evaluations is correct.
-        // Note: since add_full_relation_value_contribution computes the identities at a single evaluation of the
-        // multivariates, we need only pass in one evaluation point from the extended edges. Which one we choose is
-        // arbitrary so we choose the 0th.
-
-        // Extract the RelationValues type for the given relation
-        using RelationValues = typename decltype(relation)::RelationValues;
-        RelationValues relation_evals;
-        RelationValues expected_relation_evals;
-
-        ASSERT_EQ(expected_relation_evals.size(), expected_full_length_univariates.size());
-        // Initialize expected_evals to 0th coefficient of expected full length univariates
-        for (size_t idx = 0; idx < relation_evals.size(); ++idx) {
-            relation_evals[idx] = FF(0); // initialize to 0
-            expected_relation_evals[idx] = expected_full_length_univariates[idx].value_at(0);
-        }
-
-        // Extract 0th evaluation from extended edges
-        ClaimedEvaluations edge_evaluations = transposed_univariate_array_at(extended_edges, 0);
-
-        // Evaluate the relation using the verifier functionality
-        relation.add_full_relation_value_contribution(relation_evals, edge_evaluations, relation_parameters);
-
-        EXPECT_EQ(relation_evals, expected_relation_evals);
-
-        // Next, check that the prover's computation on Univariates is correct
-
-        using RelationUnivariates = typename decltype(relation)::RelationUnivariates;
-        RelationUnivariates relation_univariates;
-        zero_univariates<>(relation_univariates);
-
-        constexpr std::size_t num_univariates = std::tuple_size<RelationUnivariates>::value;
-
-        // Compute the relatiion univariates via the sumcheck prover functionality, then extend
-        // them to full length for easy comparison with the expected result.
-        relation.add_edge_contribution(relation_univariates, extended_edges, relation_parameters, 1);
-
-        auto full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, num_univariates>();
-        extend_tuple_of_arrays<FULL_RELATION_LENGTH>(relation_univariates, full_length_univariates);
-
-        EXPECT_EQ(full_length_univariates, expected_full_length_univariates);
-    };
-
-    template <size_t idx = 0, typename... Ts> static void zero_univariates(std::tuple<Ts...>& tuple)
-    {
-        auto& element = std::get<idx>(tuple);
-        std::fill(element.evaluations.begin(), element.evaluations.end(), FF(0));
-
-        if constexpr (idx + 1 < sizeof...(Ts)) {
-            zero_univariates<idx + 1>(tuple);
-        }
-    }
-
-    template <size_t extended_size, size_t idx = 0, typename... Ts>
-    static void extend_tuple_of_arrays(std::tuple<Ts...>& tuple, auto& result_univariates)
-    {
-        auto& element = std::get<idx>(tuple);
-        using Element = std::remove_reference_t<decltype(element)>;
-        BarycentricData<FF, Element::LENGTH, extended_size> barycentric_utils;
-        result_univariates[idx] = barycentric_utils.extend(element);
-
-        if constexpr (idx + 1 < sizeof...(Ts)) {
-            extend_tuple_of_arrays<extended_size, idx + 1>(tuple, result_univariates);
-        }
-    }
-};
-
-TEST_F(StandardRelationConsistency, ArithmeticRelation)
-{
-    using Flavor = honk::flavor::Standard;
-    using FF = typename Flavor::FF;
-    static constexpr size_t FULL_RELATION_LENGTH = 5;
-    using ExtendedEdges = typename Flavor::template ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-
-    const auto relation_parameters = compute_mock_relation_parameters();
-    auto run_test = [&relation_parameters](bool is_random_input) {
-        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-        ExtendedEdges extended_edges;
-        if (!is_random_input) {
-            // evaluation form, i.e. input_univariate(0) = 1, input_univariate(1) = 2,.. The polynomial is x+1.
-            for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ 1, 2 });
-            }
-            compute_mock_extended_edges<FULL_RELATION_LENGTH>(extended_edges, input_polynomials);
-        } else {
-            // input_univariates are random polynomials of degree one
-            for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] =
-                    Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-            }
-            compute_mock_extended_edges<FULL_RELATION_LENGTH>(extended_edges, input_polynomials);
-        };
-        auto relation = ArithmeticRelation<FF>();
-        // Manually compute the expected edge contribution
-        const auto& w_l = extended_edges.w_l;
-        const auto& w_r = extended_edges.w_r;
-        const auto& w_o = extended_edges.w_o;
-        const auto& q_m = extended_edges.q_m;
-        const auto& q_l = extended_edges.q_l;
-        const auto& q_r = extended_edges.q_r;
-        const auto& q_o = extended_edges.q_o;
-        const auto& q_c = extended_edges.q_c;
-
-        // Compute expected full length Univariates using straight forward expressions.
-        // Note: expect { { 5, 22, 57, 116, 205} } for input polynomial {1, 2}
-        constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-        auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-        expected_full_length_univariates[0] = (q_m * w_r * w_l) + (q_r * w_r) + (q_l * w_l) + (q_o * w_o) + (q_c);
-        validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-    };
-    run_test(/* is_random_input=*/true);
-    run_test(/* is_random_input=*/false);
-};
-
-TEST_F(StandardRelationConsistency, PermutationRelation)
-{
-    using Flavor = honk::flavor::Standard;
-    using FF = typename Flavor::FF;
-    static constexpr size_t FULL_RELATION_LENGTH = 5;
-    using ExtendedEdges = typename Flavor::template ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-
-    const auto relation_parameters = compute_mock_relation_parameters();
-    auto run_test = [&relation_parameters](bool is_random_input) {
-        ExtendedEdges extended_edges;
-        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-        if (!is_random_input) {
-            // evaluation form, i.e. input_univariate(0) = 1, input_univariate(1) = 2,.. The polynomial is x+1.
-            for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ 1, 2 });
-            }
-            compute_mock_extended_edges<FULL_RELATION_LENGTH>(extended_edges, input_polynomials);
-        } else {
-            // input_univariates are random polynomials of degree one
-            for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-                input_polynomials[i] =
-                    Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-            }
-            compute_mock_extended_edges<FULL_RELATION_LENGTH>(extended_edges, input_polynomials);
-        };
-        auto relation = PermutationRelation<FF>();
-
-        const auto& beta = relation_parameters.beta;
-        const auto& gamma = relation_parameters.gamma;
-        const auto& public_input_delta = relation_parameters.public_input_delta;
-
-        // Manually compute the expected edge contribution
-        const auto& w_1 = extended_edges.w_l;
-        const auto& w_2 = extended_edges.w_r;
-        const auto& w_3 = extended_edges.w_o;
-        const auto& sigma_1 = extended_edges.sigma_1;
-        const auto& sigma_2 = extended_edges.sigma_2;
-        const auto& sigma_3 = extended_edges.sigma_3;
-        const auto& id_1 = extended_edges.id_1;
-        const auto& id_2 = extended_edges.id_2;
-        const auto& id_3 = extended_edges.id_3;
-        const auto& z_perm = extended_edges.z_perm;
-        const auto& z_perm_shift = extended_edges.z_perm_shift;
-        const auto& lagrange_first = extended_edges.lagrange_first;
-        const auto& lagrange_last = extended_edges.lagrange_last;
-
-        // Compute expected full length Univariates using straight forward expressions
-        constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-        auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-        expected_full_length_univariates[0] = (z_perm + lagrange_first) * (w_1 + id_1 * beta + gamma) *
-                                                  (w_2 + id_2 * beta + gamma) * (w_3 + id_3 * beta + gamma) -
-                                              (z_perm_shift + lagrange_last * public_input_delta) *
-                                                  (w_1 + sigma_1 * beta + gamma) * (w_2 + sigma_2 * beta + gamma) *
-                                                  (w_3 + sigma_3 * beta + gamma);
-
-        expected_full_length_univariates[1] = z_perm_shift * lagrange_last;
-
-        validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-    };
-    run_test(/* is_random_input=*/true);
-    run_test(/* is_random_input=*/false);
-};
-
-} // namespace proof_system::honk_relation_tests
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_relation_consistency.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_relation_consistency.test.cpp
deleted file mode 100644
index ee36a28f0a2..00000000000
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_relation_consistency.test.cpp
+++ /dev/null
@@ -1,681 +0,0 @@
-#include "../polynomials/barycentric_data.hpp"
-#include "../polynomials/univariate.hpp"
-#include "arithmetic_relation.hpp"
-#include "barretenberg/honk/flavor/ultra.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/permutation_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
-#include "permutation_relation.hpp"
-#include "relation_parameters.hpp"
-
-#include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barretenberg/numeric/random/engine.hpp"
-
-#include <cstddef>
-#include <gtest/gtest.h>
-// TODO(luke): This testing infrastructure was duplicated between here and relation_consistency.test.cpp with the
-// orignal Flavor PR. Find a way to recombine these test suites or at least share this functionality.
-using namespace proof_system::honk::sumcheck;
-/**
- * The purpose of this test suite is to show that the identity arithmetic implemented in the Relations is equivalent to
- * a simpler unoptimized version implemented in the tests themselves. This is useful 1) as documentation since the
- * simple implementations here should make the underlying arithmetic easier to see, and 2) as a check that optimizations
- * introduced into the Relations have not changed the result.
- *
- * For this purpose, we simply feed (the same) random inputs into each of the two implementations and confirm that
- * the outputs match. This does not confirm the correctness of the identity arithmetic (the identities will not be
- * satisfied in general by random inputs) only that the two implementations are equivalent.
- */
-static const size_t INPUT_UNIVARIATE_LENGTH = 2;
-
-namespace proof_system::honk_relation_tests {
-
-class UltraRelationConsistency : public testing::Test {
-  public:
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    using ClaimedEvaluations = typename Flavor::ClaimedEvaluations;
-
-    // TODO(#390): Move MAX_RELATION_LENGTH into Flavor and simplify this.
-    template <size_t t> using ExtendedEdges = typename Flavor::template ExtendedEdges<t>;
-
-    // TODO(#225)(Adrian): Accept FULL_RELATION_LENGTH as a template parameter for this function only, so that the test
-    // can decide to which degree the polynomials must be extended. Possible accept an existing list of "edges" and
-    // extend them to the degree.
-    template <size_t FULL_RELATION_LENGTH, size_t NUM_POLYNOMIALS>
-    static void compute_mock_extended_edges(
-        ExtendedEdges<FULL_RELATION_LENGTH>& extended_edges,
-        std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS>& input_edges)
-    {
-        BarycentricData<FF, INPUT_UNIVARIATE_LENGTH, FULL_RELATION_LENGTH> barycentric_2_to_max =
-            BarycentricData<FF, INPUT_UNIVARIATE_LENGTH, FULL_RELATION_LENGTH>();
-        for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-            extended_edges[i] = barycentric_2_to_max.extend(input_edges[i]);
-        }
-    }
-
-    /**
-     * @brief Returns randomly sampled parameters to feed to the relations.
-     *
-     * @return RelationParameters<FF>
-     */
-    RelationParameters<FF> compute_mock_relation_parameters()
-    {
-        return { .eta = FF::random_element(),
-                 .beta = FF::random_element(),
-                 .gamma = FF::random_element(),
-                 .public_input_delta = FF::random_element(),
-                 .lookup_grand_product_delta = FF::random_element() };
-    }
-
-    /**
-     * @brief Given an array of Univariates, create a new array containing only the i-th evaluations
-     * of all the univariates.
-     *
-     * @note Not really optimized, mainly used for testing that the relations evaluate to the same value when
-     * evaluated as Univariates, Expressions, or index-by-index
-     * @todo(Adrian) Maybe this is more helpful as part of a `check_logic` function.
-     *
-     * @tparam NUM_UNIVARIATES number of univariates in the input array (deduced from `univariates`)
-     * @tparam univariate_length number of evaluations (deduced from `univariates`)
-     * @param univariates array of Univariates
-     * @param i index of the evaluations we want to take from each univariate
-     * @return std::array<FF, NUM_UNIVARIATES> such that result[j] = univariates[j].value_at(i)
-     */
-    template <size_t univariate_length>
-    static ClaimedEvaluations transposed_univariate_array_at(ExtendedEdges<univariate_length> univariates, size_t i)
-    {
-        ASSERT(i < univariate_length);
-        std::array<FF, Flavor::NUM_ALL_ENTITIES> result;
-        size_t result_idx = 0; // TODO(#391) zip
-        for (auto& univariate : univariates) {
-            result[result_idx] = univariate.value_at(i);
-            ++result_idx;
-        }
-        return result;
-    };
-
-    /**
-     * @brief Compute the evaluation of a `relation` in different ways, comparing it to the provided `expected_evals`
-     *
-     * @details Check both `add_full_relation_value_contribution` and `add_edge_contribution` by comparing the result to
-     * the `expected_evals` computed by the caller.
-     * Ensures that the relations compute the same result as the expression given in the tests.
-     *
-     * @param expected_evals Relation evaluation computed by the caller.
-     * @param relation being tested
-     * @param extended_edges
-     * @param relation_parameters
-     */
-    template <size_t FULL_RELATION_LENGTH>
-    static void validate_evaluations(const auto& expected_full_length_univariates, /* array of Univariates*/
-                                     const auto relation,
-                                     const ExtendedEdges<FULL_RELATION_LENGTH>& extended_edges,
-                                     const RelationParameters<FF>& relation_parameters)
-    {
-        // First check that the verifier's computation on individual evaluations is correct.
-        // Note: since add_full_relation_value_contribution computes the identities at a single evaluation of the
-        // multivariates, we need only pass in one evaluation point from the extended edges. Which one we choose is
-        // arbitrary so we choose the 0th.
-
-        // Extract the RelationValues type for the given relation
-        using RelationValues = typename decltype(relation)::RelationValues;
-        RelationValues relation_evals;
-        RelationValues expected_relation_evals;
-
-        ASSERT_EQ(expected_relation_evals.size(), expected_full_length_univariates.size());
-        // Initialize expected_evals to 0th coefficient of expected full length univariates
-        for (size_t idx = 0; idx < relation_evals.size(); ++idx) {
-            relation_evals[idx] = FF(0); // initialize to 0
-            expected_relation_evals[idx] = expected_full_length_univariates[idx].value_at(0);
-        }
-
-        // Extract 0th evaluation from extended edges
-        ClaimedEvaluations edge_evaluations = transposed_univariate_array_at(extended_edges, 0);
-
-        // Evaluate the relation using the verifier functionality
-        relation.add_full_relation_value_contribution(relation_evals, edge_evaluations, relation_parameters);
-
-        EXPECT_EQ(relation_evals, expected_relation_evals);
-
-        // Next, check that the prover's computation on Univariates is correct
-
-        using RelationUnivariates = typename decltype(relation)::RelationUnivariates;
-        RelationUnivariates relation_univariates;
-        zero_univariates<>(relation_univariates);
-
-        constexpr std::size_t num_univariates = std::tuple_size<RelationUnivariates>::value;
-
-        // Compute the relatiion univariates via the sumcheck prover functionality, then extend
-        // them to full length for easy comparison with the expected result.
-        relation.add_edge_contribution(relation_univariates, extended_edges, relation_parameters, 1);
-
-        auto full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, num_univariates>();
-        extend_tuple_of_arrays<FULL_RELATION_LENGTH>(relation_univariates, full_length_univariates);
-
-        EXPECT_EQ(full_length_univariates, expected_full_length_univariates);
-    };
-
-    template <size_t idx = 0, typename... Ts> static void zero_univariates(std::tuple<Ts...>& tuple)
-    {
-        auto& element = std::get<idx>(tuple);
-        std::fill(element.evaluations.begin(), element.evaluations.end(), FF(0));
-
-        if constexpr (idx + 1 < sizeof...(Ts)) {
-            zero_univariates<idx + 1>(tuple);
-        }
-    }
-
-    template <size_t extended_size, size_t idx = 0, typename... Ts>
-    static void extend_tuple_of_arrays(std::tuple<Ts...>& tuple, auto& result_univariates)
-    {
-        auto& element = std::get<idx>(tuple);
-        using Element = std::remove_reference_t<decltype(element)>;
-        BarycentricData<FF, Element::LENGTH, extended_size> barycentric_utils;
-        result_univariates[idx] = barycentric_utils.extend(element);
-
-        if constexpr (idx + 1 < sizeof...(Ts)) {
-            extend_tuple_of_arrays<extended_size, idx + 1>(tuple, result_univariates);
-        }
-    }
-};
-
-TEST_F(UltraRelationConsistency, UltraArithmeticRelation)
-{
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    static constexpr size_t FULL_RELATION_LENGTH = 6;
-    using ExtendedEdges = typename Flavor::template ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-
-    const auto relation_parameters = compute_mock_relation_parameters();
-    ExtendedEdges extended_edges;
-    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-
-    // input_univariates are random polynomials of degree one
-    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-    }
-    compute_mock_extended_edges<FULL_RELATION_LENGTH>(extended_edges, input_polynomials);
-
-    auto relation = UltraArithmeticRelation<FF>();
-
-    // Extract the extended edges for manual computation of relation contribution
-    const auto& w_1 = extended_edges.w_l;
-    const auto& w_1_shift = extended_edges.w_l_shift;
-    const auto& w_2 = extended_edges.w_r;
-    const auto& w_3 = extended_edges.w_o;
-    const auto& w_4 = extended_edges.w_4;
-    const auto& w_4_shift = extended_edges.w_4_shift;
-    const auto& q_m = extended_edges.q_m;
-    const auto& q_l = extended_edges.q_l;
-    const auto& q_r = extended_edges.q_r;
-    const auto& q_o = extended_edges.q_o;
-    const auto& q_4 = extended_edges.q_4;
-    const auto& q_c = extended_edges.q_c;
-    const auto& q_arith = extended_edges.q_arith;
-
-    static const FF neg_half = FF(-2).invert();
-
-    constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-    auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-    // Contribution 1
-    auto contribution_1 = (q_arith - 3) * (q_m * w_2 * w_1) * neg_half;
-    contribution_1 += (q_l * w_1) + (q_r * w_2) + (q_o * w_3) + (q_4 * w_4) + q_c;
-    contribution_1 += (q_arith - 1) * w_4_shift;
-    contribution_1 *= q_arith;
-    expected_full_length_univariates[0] = contribution_1;
-
-    // Contribution 2
-    auto contribution_2 = (w_1 + w_4 - w_1_shift + q_m);
-    contribution_2 *= (q_arith - 2) * (q_arith - 1) * q_arith;
-    expected_full_length_univariates[1] = contribution_2;
-
-    validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-};
-
-TEST_F(UltraRelationConsistency, UltraPermutationRelation)
-{
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    using Flavor = honk::flavor::Ultra;
-    static constexpr size_t FULL_RELATION_LENGTH = 6;
-    using ExtendedEdges = typename Flavor::template ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-    auto relation_parameters = compute_mock_relation_parameters();
-    ExtendedEdges extended_edges;
-    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-
-    // input_univariates are random polynomials of degree one
-    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-    }
-    compute_mock_extended_edges(extended_edges, input_polynomials);
-
-    auto relation = UltraPermutationRelation<FF>();
-
-    const auto& beta = relation_parameters.beta;
-    const auto& gamma = relation_parameters.gamma;
-    const auto& public_input_delta = relation_parameters.public_input_delta;
-
-    // Extract the extended edges for manual computation of relation contribution
-    const auto& w_1 = extended_edges.w_l;
-    const auto& w_2 = extended_edges.w_r;
-    const auto& w_3 = extended_edges.w_o;
-    const auto& w_4 = extended_edges.w_4;
-    const auto& sigma_1 = extended_edges.sigma_1;
-    const auto& sigma_2 = extended_edges.sigma_2;
-    const auto& sigma_3 = extended_edges.sigma_3;
-    const auto& sigma_4 = extended_edges.sigma_4;
-    const auto& id_1 = extended_edges.id_1;
-    const auto& id_2 = extended_edges.id_2;
-    const auto& id_3 = extended_edges.id_3;
-    const auto& id_4 = extended_edges.id_4;
-    const auto& z_perm = extended_edges.z_perm;
-    const auto& z_perm_shift = extended_edges.z_perm_shift;
-    const auto& lagrange_first = extended_edges.lagrange_first;
-    const auto& lagrange_last = extended_edges.lagrange_last;
-
-    constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-    auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-    // Compute the expected result using a simple to read version of the relation expression
-
-    // Contribution 1
-    auto contribution_1 = (z_perm + lagrange_first) * (w_1 + id_1 * beta + gamma) * (w_2 + id_2 * beta + gamma) *
-                              (w_3 + id_3 * beta + gamma) * (w_4 + id_4 * beta + gamma) -
-                          (z_perm_shift + lagrange_last * public_input_delta) * (w_1 + sigma_1 * beta + gamma) *
-                              (w_2 + sigma_2 * beta + gamma) * (w_3 + sigma_3 * beta + gamma) *
-                              (w_4 + sigma_4 * beta + gamma);
-    expected_full_length_univariates[0] = contribution_1;
-
-    // Contribution 2
-    auto contribution_2 = z_perm_shift * lagrange_last;
-    expected_full_length_univariates[1] = contribution_2;
-
-    validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-};
-
-TEST_F(UltraRelationConsistency, LookupRelation)
-{
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    using Flavor = honk::flavor::Ultra;
-    static constexpr size_t FULL_RELATION_LENGTH = 6;
-    using ExtendedEdges = typename Flavor::ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-    auto relation_parameters = compute_mock_relation_parameters();
-    ExtendedEdges extended_edges;
-    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-
-    // input_univariates are random polynomials of degree one
-    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-    }
-    compute_mock_extended_edges(extended_edges, input_polynomials);
-
-    auto relation = LookupRelation<FF>();
-
-    const auto eta = relation_parameters.eta;
-    const auto beta = relation_parameters.beta;
-    const auto gamma = relation_parameters.gamma;
-    auto grand_product_delta = relation_parameters.lookup_grand_product_delta;
-
-    // Extract the extended edges for manual computation of relation contribution
-    auto one_plus_beta = FF::one() + beta;
-    auto gamma_by_one_plus_beta = gamma * one_plus_beta;
-    auto eta_sqr = eta * eta;
-    auto eta_cube = eta_sqr * eta;
-
-    const auto& w_1 = extended_edges.w_l;
-    const auto& w_2 = extended_edges.w_r;
-    const auto& w_3 = extended_edges.w_o;
-
-    const auto& w_1_shift = extended_edges.w_l_shift;
-    const auto& w_2_shift = extended_edges.w_r_shift;
-    const auto& w_3_shift = extended_edges.w_o_shift;
-
-    const auto& table_1 = extended_edges.table_1;
-    const auto& table_2 = extended_edges.table_2;
-    const auto& table_3 = extended_edges.table_3;
-    const auto& table_4 = extended_edges.table_4;
-
-    const auto& table_1_shift = extended_edges.table_1_shift;
-    const auto& table_2_shift = extended_edges.table_2_shift;
-    const auto& table_3_shift = extended_edges.table_3_shift;
-    const auto& table_4_shift = extended_edges.table_4_shift;
-
-    const auto& s_accum = extended_edges.sorted_accum;
-    const auto& s_accum_shift = extended_edges.sorted_accum_shift;
-    const auto& z_lookup = extended_edges.z_lookup;
-    const auto& z_lookup_shift = extended_edges.z_lookup_shift;
-
-    const auto& table_index = extended_edges.q_o;
-    const auto& column_1_step_size = extended_edges.q_r;
-    const auto& column_2_step_size = extended_edges.q_m;
-    const auto& column_3_step_size = extended_edges.q_c;
-    const auto& q_lookup = extended_edges.q_lookup;
-
-    const auto& lagrange_first = extended_edges.lagrange_first;
-    const auto& lagrange_last = extended_edges.lagrange_last;
-
-    auto wire_accum = (w_1 + column_1_step_size * w_1_shift) + (w_2 + column_2_step_size * w_2_shift) * eta +
-                      (w_3 + column_3_step_size * w_3_shift) * eta_sqr + table_index * eta_cube;
-
-    auto table_accum = table_1 + table_2 * eta + table_3 * eta_sqr + table_4 * eta_cube;
-    auto table_accum_shift = table_1_shift + table_2_shift * eta + table_3_shift * eta_sqr + table_4_shift * eta_cube;
-
-    constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-    auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-    // Compute the expected result using a simple to read version of the relation expression
-
-    // Contribution 1
-    auto contribution_1 = (z_lookup + lagrange_first) * (q_lookup * wire_accum + gamma) *
-                          (table_accum + table_accum_shift * beta + gamma_by_one_plus_beta) * one_plus_beta;
-    contribution_1 -= (z_lookup_shift + lagrange_last * grand_product_delta) *
-                      (s_accum + s_accum_shift * beta + gamma_by_one_plus_beta);
-    expected_full_length_univariates[0] = contribution_1;
-
-    // Contribution 2
-    auto contribution_2 = z_lookup_shift * lagrange_last;
-    expected_full_length_univariates[1] = contribution_2;
-
-    validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-};
-
-TEST_F(UltraRelationConsistency, GenPermSortRelation)
-{
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    using Flavor = honk::flavor::Ultra;
-    static constexpr size_t FULL_RELATION_LENGTH = 6;
-    using ExtendedEdges = typename Flavor::ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-    auto relation_parameters = compute_mock_relation_parameters();
-    ExtendedEdges extended_edges;
-    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-
-    // input_univariates are random polynomials of degree one
-    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-    }
-    compute_mock_extended_edges(extended_edges, input_polynomials);
-
-    auto relation = GenPermSortRelation<FF>();
-
-    // Extract the extended edges for manual computation of relation contribution
-    const auto& w_1 = extended_edges.w_l;
-    const auto& w_2 = extended_edges.w_r;
-    const auto& w_3 = extended_edges.w_o;
-    const auto& w_4 = extended_edges.w_4;
-    const auto& w_1_shift = extended_edges.w_l_shift;
-    const auto& q_sort = extended_edges.q_sort;
-
-    // Compute wire differences
-    auto delta_1 = w_2 - w_1;
-    auto delta_2 = w_3 - w_2;
-    auto delta_3 = w_4 - w_3;
-    auto delta_4 = w_1_shift - w_4;
-
-    constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-    auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-    // Compute the expected result using a simple to read version of the relation expression
-    auto contribution_1 = delta_1 * (delta_1 - 1) * (delta_1 - 2) * (delta_1 - 3);
-    auto contribution_2 = delta_2 * (delta_2 - 1) * (delta_2 - 2) * (delta_2 - 3);
-    auto contribution_3 = delta_3 * (delta_3 - 1) * (delta_3 - 2) * (delta_3 - 3);
-    auto contribution_4 = delta_4 * (delta_4 - 1) * (delta_4 - 2) * (delta_4 - 3);
-
-    expected_full_length_univariates[0] = contribution_1 * q_sort;
-    expected_full_length_univariates[1] = contribution_2 * q_sort;
-    expected_full_length_univariates[2] = contribution_3 * q_sort;
-    expected_full_length_univariates[3] = contribution_4 * q_sort;
-
-    validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-};
-
-TEST_F(UltraRelationConsistency, EllipticRelation)
-{
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    using Flavor = honk::flavor::Ultra;
-    static constexpr size_t FULL_RELATION_LENGTH = 6;
-    using ExtendedEdges = typename Flavor::ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-    auto relation_parameters = compute_mock_relation_parameters();
-    ExtendedEdges extended_edges;
-    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-
-    // input_univariates are random polynomials of degree one
-    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-    }
-    compute_mock_extended_edges(extended_edges, input_polynomials);
-
-    auto relation = EllipticRelation<FF>();
-
-    // Extract the extended edges for manual computation of relation contribution
-    const auto& x_1 = extended_edges.w_r;
-    const auto& y_1 = extended_edges.w_o;
-
-    const auto& x_2 = extended_edges.w_l_shift;
-    const auto& y_2 = extended_edges.w_4_shift;
-    const auto& x_3 = extended_edges.w_r_shift;
-    const auto& y_3 = extended_edges.w_o_shift;
-
-    const auto& q_sign = extended_edges.q_l;
-    const auto& q_beta = extended_edges.q_o;
-    const auto& q_beta_sqr = extended_edges.q_4;
-    const auto& q_elliptic = extended_edges.q_elliptic;
-
-    constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-    auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-    // Compute x/y coordinate identities
-
-    // Contribution 1
-    auto x_identity = q_sign * (y_1 * y_2 * 2);
-    x_identity += q_beta * (x_1 * x_2 * x_3 * 2 + x_1 * x_1 * x_2) * FF(-1);
-    x_identity += q_beta_sqr * (x_2 * x_2 * x_3 - x_1 * x_2 * x_2);
-    x_identity += (x_1 * x_1 * x_3 - y_2 * y_2 - y_1 * y_1 + x_2 * x_2 * x_2 + x_1 * x_1 * x_1);
-
-    // Contribution 2
-    auto y_identity = q_sign * (y_2 * x_3 - y_2 * x_1);
-    y_identity += q_beta * (x_2 * y_3 + y_1 * x_2);
-    y_identity += (x_1 * y_1 - x_1 * y_3 - y_1 * x_3 - x_1 * y_1);
-
-    expected_full_length_univariates[0] = x_identity * q_elliptic;
-    expected_full_length_univariates[1] = y_identity * q_elliptic;
-
-    validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-};
-
-TEST_F(UltraRelationConsistency, AuxiliaryRelation)
-{
-    using Flavor = honk::flavor::Ultra;
-    using FF = typename Flavor::FF;
-    using Flavor = honk::flavor::Ultra;
-    static constexpr size_t FULL_RELATION_LENGTH = 6;
-    using ExtendedEdges = typename Flavor::ExtendedEdges<FULL_RELATION_LENGTH>;
-    static const size_t NUM_POLYNOMIALS = Flavor::NUM_ALL_ENTITIES;
-    auto relation_parameters = compute_mock_relation_parameters();
-    ExtendedEdges extended_edges;
-    std::array<Univariate<FF, INPUT_UNIVARIATE_LENGTH>, NUM_POLYNOMIALS> input_polynomials;
-
-    // input_univariates are random polynomials of degree one
-    for (size_t i = 0; i < NUM_POLYNOMIALS; ++i) {
-        input_polynomials[i] = Univariate<FF, INPUT_UNIVARIATE_LENGTH>({ FF::random_element(), FF::random_element() });
-    }
-    compute_mock_extended_edges(extended_edges, input_polynomials);
-
-    auto relation = AuxiliaryRelation<FF>();
-
-    const auto& eta = relation_parameters.eta;
-
-    // Extract the extended edges for manual computation of relation contribution
-    const auto& w_1 = extended_edges.w_l;
-    const auto& w_2 = extended_edges.w_r;
-    const auto& w_3 = extended_edges.w_o;
-    const auto& w_4 = extended_edges.w_4;
-    const auto& w_1_shift = extended_edges.w_l_shift;
-    const auto& w_2_shift = extended_edges.w_r_shift;
-    const auto& w_3_shift = extended_edges.w_o_shift;
-    const auto& w_4_shift = extended_edges.w_4_shift;
-
-    const auto& q_1 = extended_edges.q_l;
-    const auto& q_2 = extended_edges.q_r;
-    const auto& q_3 = extended_edges.q_o;
-    const auto& q_4 = extended_edges.q_4;
-    const auto& q_m = extended_edges.q_m;
-    const auto& q_c = extended_edges.q_c;
-    const auto& q_arith = extended_edges.q_arith;
-    const auto& q_aux = extended_edges.q_aux;
-
-    constexpr std::size_t NUM_SUBRELATIONS = std::tuple_size_v<decltype(relation)::RelationUnivariates>;
-    auto expected_full_length_univariates = std::array<Univariate<FF, FULL_RELATION_LENGTH>, NUM_SUBRELATIONS>();
-
-    constexpr FF LIMB_SIZE(uint256_t(1) << 68);
-    constexpr FF SUBLIMB_SHIFT(uint256_t(1) << 14);
-    constexpr FF SUBLIMB_SHIFT_2(SUBLIMB_SHIFT * SUBLIMB_SHIFT);
-    constexpr FF SUBLIMB_SHIFT_3(SUBLIMB_SHIFT_2 * SUBLIMB_SHIFT);
-    constexpr FF SUBLIMB_SHIFT_4(SUBLIMB_SHIFT_3 * SUBLIMB_SHIFT);
-
-    /**
-     * Non native field arithmetic gate 2
-     *
-     *             _                                                                               _
-     *            /   _                   _                               _       14                \
-     * q_2 . q_4 |   (w_1 . w_2) + (w_1 . w_2) + (w_1 . w_4 + w_2 . w_3 - w_3) . 2    - w_3 - w_4   |
-     *            \_                                                                               _/
-     *
-     **/
-    auto limb_subproduct = w_1 * w_2_shift + w_1_shift * w_2;
-    auto non_native_field_gate_2 = (w_1 * w_4 + w_2 * w_3 - w_3_shift);
-    non_native_field_gate_2 *= LIMB_SIZE;
-    non_native_field_gate_2 -= w_4_shift;
-    non_native_field_gate_2 += limb_subproduct;
-
-    limb_subproduct *= LIMB_SIZE;
-    limb_subproduct += (w_1_shift * w_2_shift);
-    auto non_native_field_gate_1 = limb_subproduct;
-    non_native_field_gate_1 -= (w_3 + w_4);
-
-    auto non_native_field_gate_3 = limb_subproduct;
-    non_native_field_gate_3 += w_4;
-    non_native_field_gate_3 -= (w_3_shift + w_4_shift);
-
-    auto non_native_field_identity = q_2 * q_3 * non_native_field_gate_1;
-    non_native_field_identity += q_2 * q_4 * non_native_field_gate_2;
-    non_native_field_identity += q_2 * q_m * non_native_field_gate_3;
-
-    auto limb_accumulator_1 = w_1 + w_2 * SUBLIMB_SHIFT + w_3 * SUBLIMB_SHIFT_2 + w_1_shift * SUBLIMB_SHIFT_3 +
-                              w_2_shift * SUBLIMB_SHIFT_4 - w_4;
-
-    auto limb_accumulator_2 = w_3 + w_4 * SUBLIMB_SHIFT + w_1_shift * SUBLIMB_SHIFT_2 + w_2_shift * SUBLIMB_SHIFT_3 +
-                              w_3_shift * SUBLIMB_SHIFT_4 - w_4_shift;
-
-    auto limb_accumulator_identity = q_3 * q_4 * limb_accumulator_1;
-    limb_accumulator_identity += q_3 * q_m * limb_accumulator_2;
-
-    /**
-     * MEMORY
-     **/
-
-    /**
-     * Memory Record Check
-     */
-    auto memory_record_check = w_3;
-    memory_record_check *= eta;
-    memory_record_check += w_2;
-    memory_record_check *= eta;
-    memory_record_check += w_1;
-    memory_record_check *= eta;
-    memory_record_check += q_c;
-    auto partial_record_check = memory_record_check; // used in RAM consistency check
-    memory_record_check = memory_record_check - w_4;
-
-    /**
-     * ROM Consistency Check
-     */
-    auto index_delta = w_1_shift - w_1;
-    auto record_delta = w_4_shift - w_4;
-
-    auto index_is_monotonically_increasing = index_delta * index_delta - index_delta;
-
-    // auto adjacent_values_match_if_adjacent_indices_match = (FF(1) - index_delta) * record_delta;
-    auto adjacent_values_match_if_adjacent_indices_match = (index_delta * FF(-1) + FF(1)) * record_delta;
-
-    expected_full_length_univariates[1] = adjacent_values_match_if_adjacent_indices_match * (q_1 * q_2);
-    expected_full_length_univariates[2] = index_is_monotonically_increasing * (q_1 * q_2);
-    auto ROM_consistency_check_identity = memory_record_check * (q_1 * q_2);
-
-    /**
-     * RAM Consistency Check
-     */
-    auto access_type = (w_4 - partial_record_check);             // will be 0 or 1 for honest Prover
-    auto access_check = access_type * access_type - access_type; // check value is 0 or 1
-
-    auto next_gate_access_type = w_3_shift;
-    next_gate_access_type *= eta;
-    next_gate_access_type += w_2_shift;
-    next_gate_access_type *= eta;
-    next_gate_access_type += w_1_shift;
-    next_gate_access_type *= eta;
-    next_gate_access_type = w_4_shift - next_gate_access_type;
-
-    auto value_delta = w_3_shift - w_3;
-    auto adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation =
-        (index_delta * FF(-1) + FF(1)) * value_delta * (next_gate_access_type * FF(-1) + FF(1));
-
-    // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the
-    // next gate would make the identity fail).
-    // We need to validate that its 'access type' bool is correct. Can't do
-    // with an arithmetic gate because of the `eta` factors. We need to check that the *next* gate's access type is
-    // correct, to cover this edge case
-    auto next_gate_access_type_is_boolean = next_gate_access_type * next_gate_access_type - next_gate_access_type;
-
-    // Putting it all together...
-    expected_full_length_univariates[3] =
-        adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation * (q_arith);
-    expected_full_length_univariates[4] = index_is_monotonically_increasing * (q_arith);
-    expected_full_length_univariates[5] = next_gate_access_type_is_boolean * (q_arith);
-    auto RAM_consistency_check_identity = access_check * (q_arith);
-
-    /**
-     * RAM/ROM access check gate
-     */
-    memory_record_check *= (q_1 * q_m);
-
-    /**
-     * RAM Timestamp Consistency Check
-     */
-    auto timestamp_delta = w_2_shift - w_2;
-    auto RAM_timestamp_check_identity = (index_delta * FF(-1) + FF(1)) * timestamp_delta - w_3;
-    RAM_timestamp_check_identity *= (q_1 * q_4);
-
-    /**
-     * The complete RAM/ROM memory identity
-     */
-    auto memory_identity = ROM_consistency_check_identity;
-    memory_identity += RAM_timestamp_check_identity;
-    memory_identity += memory_record_check;
-    memory_identity += RAM_consistency_check_identity;
-
-    expected_full_length_univariates[0] = memory_identity + non_native_field_identity + limb_accumulator_identity;
-
-    expected_full_length_univariates[0] *= q_aux;
-    expected_full_length_univariates[1] *= q_aux;
-    expected_full_length_univariates[2] *= q_aux;
-    expected_full_length_univariates[3] *= q_aux;
-    expected_full_length_univariates[4] *= q_aux;
-    expected_full_length_univariates[5] *= q_aux;
-
-    validate_evaluations(expected_full_length_univariates, relation, extended_edges, relation_parameters);
-};
-
-} // namespace proof_system::honk_relation_tests
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp
index eb885cf1603..e3f0ae21409 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.hpp
@@ -2,19 +2,12 @@
 #include "barretenberg/common/serialize.hpp"
 #include "barretenberg/common/throw_or_abort.hpp"
 #include "barretenberg/honk/proof_system/prover.hpp"
-#include "barretenberg/honk/sumcheck/relations/relation_parameters.hpp"
+#include "barretenberg/proof_system/relations/relation_parameters.hpp"
 #include "barretenberg/honk/sumcheck/sumcheck_output.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
 #include "barretenberg/honk/utils/grand_product_delta.hpp"
-#include "polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "sumcheck_round.hpp"
-#include <algorithm>
-#include <array>
-#include <cstddef>
-#include <optional>
-#include <span>
-#include <string>
-#include <vector>
 
 namespace proof_system::honk::sumcheck {
 
@@ -78,11 +71,11 @@ template <typename Flavor> class SumcheckProver {
      * @details
      */
     SumcheckOutput<Flavor> prove(auto full_polynomials,
-                                 const RelationParameters<FF>& relation_parameters) // pass by value, not by reference
+                                 const proof_system::RelationParameters<FF>& relation_parameters) // pass by value, not by reference
     {
         auto [alpha, zeta] = transcript.get_challenges("Sumcheck:alpha", "Sumcheck:zeta");
 
-        PowUnivariate<FF> pow_univariate(zeta);
+        barretenberg::PowUnivariate<FF> pow_univariate(zeta);
 
         std::vector<FF> multivariate_challenge;
         multivariate_challenge.reserve(multivariate_d);
@@ -179,13 +172,13 @@ template <typename Flavor> class SumcheckVerifier {
      * @param relation_parameters
      * @param transcript
      */
-    std::optional<SumcheckOutput<Flavor>> verify(const RelationParameters<FF>& relation_parameters, auto& transcript)
+    std::optional<SumcheckOutput<Flavor>> verify(const proof_system::RelationParameters<FF>& relation_parameters, auto& transcript)
     {
         bool verified(true);
 
         auto [alpha, zeta] = transcript.get_challenges("Sumcheck:alpha", "Sumcheck:zeta");
 
-        PowUnivariate<FF> pow_univariate(zeta);
+        barretenberg::PowUnivariate<FF> pow_univariate(zeta);
         // All but final round.
         // target_total_sum is initialized to zero then mutated in place.
 
@@ -199,8 +192,8 @@ template <typename Flavor> class SumcheckVerifier {
         for (size_t round_idx = 0; round_idx < multivariate_d; round_idx++) {
             // Obtain the round univariate from the transcript
             std::string round_univariate_label = "Sumcheck:univariate_" + std::to_string(round_idx);
-            auto round_univariate = transcript.template receive_from_prover<Univariate<FF, MAX_RANDOM_RELATION_LENGTH>>(
-                round_univariate_label);
+            auto round_univariate = transcript.template receive_from_prover<
+                barretenberg::Univariate<FF, MAX_RANDOM_RELATION_LENGTH>>(round_univariate_label);
 
             bool checked = round.check_sum(round_univariate);
             verified = verified && checked;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp
index 59035ec889d..fba343da147 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck.test.cpp
@@ -1,31 +1,17 @@
+#include "sumcheck.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/honk/composer/standard_composer.hpp"
 #include "barretenberg/honk/composer/ultra_composer.hpp"
-#include "barretenberg/honk/flavor/standard.hpp"
 #include "barretenberg/honk/proof_system/grand_product_library.hpp"
-#include "barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/elliptic_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/lookup_relation.hpp"
-#include "barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
-#include "barretenberg/numeric/random/engine.hpp"
-#include "barretenberg/transcript/manifest.hpp"
-#include "barretenberg/transcript/transcript_wrappers.hpp"
-#include "relations/arithmetic_relation.hpp"
-#include "relations/permutation_relation.hpp"
-#include "sumcheck.hpp"
-#include <array>
-#include <cstddef>
-#include <cstdint>
-#include <gtest/internal/gtest-internal.h>
-
+#include "barretenberg/proof_system/relations/arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
 #include <gtest/gtest.h>
-#include <initializer_list>
-#include <optional>
-#include <string>
-#include <sys/types.h>
-#include <vector>
 
 using namespace proof_system::honk;
 using namespace proof_system::honk::sumcheck;
@@ -315,7 +301,7 @@ TEST_F(SumcheckTests, ProverAndVerifier)
                                                        lagrange_first,
                                                        lagrange_last);
     // Set aribitrary random relation parameters
-    sumcheck::RelationParameters<FF> relation_parameters{
+    proof_system::RelationParameters<FF> relation_parameters{
         .beta = FF::random_element(),
         .gamma = FF::random_element(),
         .public_input_delta = FF::one(),
@@ -389,7 +375,7 @@ TEST_F(SumcheckTests, ProverAndVerifierLonger)
                                                            lagrange_last);
 
         // Set aribitrary random relation parameters
-        sumcheck::RelationParameters<FF> relation_parameters{
+        proof_system::RelationParameters<FF> relation_parameters{
             .beta = FF::random_element(),
             .gamma = FF::random_element(),
             .public_input_delta = FF::one(),
@@ -453,7 +439,7 @@ TEST_F(SumcheckTests, RealCircuitStandard)
     auto public_input_delta =
         honk::compute_public_input_delta<Flavor>(public_inputs, beta, gamma, prover.key->circuit_size);
 
-    sumcheck::RelationParameters<FF> relation_parameters{
+    proof_system::RelationParameters<FF> relation_parameters{
         .beta = beta,
         .gamma = gamma,
         .public_input_delta = public_input_delta,
@@ -635,7 +621,7 @@ TEST_F(SumcheckTests, RealCircuitUltra)
     auto lookup_grand_product_delta =
         honk::compute_lookup_grand_product_delta<FF>(beta, gamma, prover.key->circuit_size);
 
-    sumcheck::RelationParameters<FF> relation_parameters{
+    proof_system::RelationParameters<FF> relation_parameters{
         .eta = eta,
         .beta = beta,
         .gamma = gamma,
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp
index 4dc27e075f8..1b72039573a 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.hpp
@@ -1,15 +1,9 @@
 #pragma once
 #include "barretenberg/common/log.hpp"
 #include "barretenberg/common/thread.hpp"
-#include "barretenberg/honk/flavor/ultra.hpp"
-#include "polynomials/barycentric_data.hpp"
-#include "polynomials/pow.hpp"
-#include "polynomials/univariate.hpp"
-#include "relations/relation_parameters.hpp"
-#include <algorithm>
-#include <array>
-#include <functional>
-#include <tuple>
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/pow.hpp"
+#include "barretenberg/proof_system/relations/relation_parameters.hpp"
 
 namespace proof_system::honk::sumcheck {
 
@@ -75,7 +69,7 @@ template <typename Flavor> class SumcheckProverRound {
     RelationUnivariates univariate_accumulators;
 
     // TODO(#224)(Cody): this should go away
-    BarycentricData<FF, 2, MAX_RELATION_LENGTH> barycentric_2_to_max = BarycentricData<FF, 2, MAX_RELATION_LENGTH>();
+    barretenberg::BarycentricData<FF, 2, MAX_RELATION_LENGTH> barycentric_2_to_max;
 
     // Prover constructor
     SumcheckProverRound(size_t initial_round_size)
@@ -91,13 +85,13 @@ template <typename Flavor> class SumcheckProverRound {
      *
      * @tparam T : In practice, this is a Univariate<FF, MAX_NUM_RELATIONS>.
      */
-    Univariate<FF, MAX_RANDOM_RELATION_LENGTH> batch_over_relations(FF challenge,
-                                                                    const PowUnivariate<FF>& pow_univariate)
+    barretenberg::Univariate<FF, MAX_RANDOM_RELATION_LENGTH> batch_over_relations(
+        FF challenge, const barretenberg::PowUnivariate<FF>& pow_univariate)
     {
         FF running_challenge = 1;
         scale_univariates(univariate_accumulators, challenge, running_challenge);
 
-        auto result = Univariate<FF, MAX_RANDOM_RELATION_LENGTH>(0);
+        auto result = barretenberg::Univariate<FF, MAX_RANDOM_RELATION_LENGTH>(0);
         extend_and_batch_univariates(univariate_accumulators, pow_univariate, result);
 
         // Reset all univariate accumulators to 0 before beginning accumulation in the next round
@@ -116,7 +110,7 @@ template <typename Flavor> class SumcheckProverRound {
     {
         size_t univariate_idx = 0; // TODO(#391) zip
         for (auto& poly : multivariates) {
-            auto edge = Univariate<FF, 2>({ poly[edge_idx], poly[edge_idx + 1] });
+            auto edge = barretenberg::Univariate<FF, 2>({ poly[edge_idx], poly[edge_idx + 1] });
             extended_edges[univariate_idx] = barycentric_2_to_max.extend(edge);
             ++univariate_idx;
         }
@@ -127,9 +121,9 @@ template <typename Flavor> class SumcheckProverRound {
      * values. Most likely this will end up being S_l(0), ... , S_l(t-1) where t is around 12. At the end, reset all
      * univariate accumulators to be zero.
      */
-    Univariate<FF, MAX_RANDOM_RELATION_LENGTH> compute_univariate(auto& polynomials,
-                                                                  const RelationParameters<FF>& relation_parameters,
-                                                                  const PowUnivariate<FF>& pow_univariate,
+    barretenberg::Univariate<FF, MAX_RANDOM_RELATION_LENGTH> compute_univariate(auto& polynomials,
+                                                                  const proof_system::RelationParameters<FF>& relation_parameters,
+                                                                  const barretenberg::PowUnivariate<FF>& pow_univariate,
                                                                   const FF alpha)
     {
         // Precompute the vector of required powers of zeta
@@ -211,7 +205,7 @@ template <typename Flavor> class SumcheckProverRound {
     template <size_t relation_idx = 0>
     void accumulate_relation_univariates(RelationUnivariates& univariate_accumulators,
                                          const auto& extended_edges,
-                                         const RelationParameters<FF>& relation_parameters,
+                                         const proof_system::RelationParameters<FF>& relation_parameters,
                                          const FF& scaling_factor)
     {
         std::get<relation_idx>(relations).add_edge_contribution(
@@ -241,20 +235,21 @@ template <typename Flavor> class SumcheckProverRound {
      */
     template <size_t extended_size>
     static void extend_and_batch_univariates(auto& tuple,
-                                             const PowUnivariate<FF>& pow_univariate,
-                                             Univariate<FF, extended_size>& result)
+                                             const barretenberg::PowUnivariate<FF>& pow_univariate,
+                                             barretenberg::Univariate<FF, extended_size>& result)
     {
         // Random poly R(X) = (1-X) + X.zeta_pow
-        auto random_poly_edge = Univariate<FF, 2>({ 1, pow_univariate.zeta_pow });
-        BarycentricData<FF, 2, extended_size> pow_zeta_univariate_extender = BarycentricData<FF, 2, extended_size>();
-        Univariate<FF, extended_size> extended_random_polynomial_edge =
+        auto random_poly_edge = barretenberg::Univariate<FF, 2>({ 1, pow_univariate.zeta_pow });
+        barretenberg::BarycentricData<FF, 2, extended_size> pow_zeta_univariate_extender =
+            barretenberg::BarycentricData<FF, 2, extended_size>();
+        barretenberg::Univariate<FF, extended_size> extended_random_polynomial_edge =
             pow_zeta_univariate_extender.extend(random_poly_edge);
 
         auto extend_and_sum = [&]<size_t relation_idx, size_t subrelation_idx, typename Element>(Element& element) {
             using Relation = typename std::tuple_element<relation_idx, Relations>::type;
 
             // TODO(#224)(Cody): this barycentric stuff should be more built-in?
-            BarycentricData<FF, Element::LENGTH, extended_size> barycentric_utils;
+            barretenberg::BarycentricData<FF, Element::LENGTH, extended_size> barycentric_utils;
             auto extended = barycentric_utils.extend(element);
 
             const bool is_subrelation_linearly_independent =
@@ -400,8 +395,8 @@ template <typename Flavor> class SumcheckVerifierRound {
      * checked against the final value of the target total sum, defined as sigma_d.
      */
     FF compute_full_honk_relation_purported_value(ClaimedEvaluations purported_evaluations,
-                                                  const RelationParameters<FF>& relation_parameters,
-                                                  const PowUnivariate<FF>& pow_univariate,
+                                                  const proof_system::RelationParameters<FF>& relation_parameters,
+                                                  const barretenberg::PowUnivariate<FF>& pow_univariate,
                                                   const FF alpha)
     {
         accumulate_relation_evaluations<>(
@@ -418,7 +413,7 @@ template <typename Flavor> class SumcheckVerifierRound {
      *
      * @param univariate T^{l}(X), the round univariate that is equal to S^{l}(X)/( (1−X) + X⋅ζ^{ 2^l } )
      */
-    bool check_sum(Univariate<FF, MAX_RANDOM_RELATION_LENGTH>& univariate)
+    bool check_sum(barretenberg::Univariate<FF, MAX_RANDOM_RELATION_LENGTH>& univariate)
     {
         // S^{l}(0) = ( (1−0) + 0⋅ζ^{ 2^l } ) ⋅ T^{l}(0) = T^{l}(0)
         // S^{l}(1) = ( (1−1) + 1⋅ζ^{ 2^l } ) ⋅ T^{l}(1) = ζ^{ 2^l } ⋅ T^{l}(1)
@@ -445,11 +440,12 @@ template <typename Flavor> class SumcheckVerifierRound {
      * @param round_challenge u_l
      * @return FF sigma_{l+1} = S^l(u_l)
      */
-    FF compute_next_target_sum(Univariate<FF, MAX_RANDOM_RELATION_LENGTH>& univariate, FF& round_challenge)
+    FF compute_next_target_sum(barretenberg::Univariate<FF, MAX_RANDOM_RELATION_LENGTH>& univariate, FF& round_challenge)
     {
         // IMPROVEMENT(Cody): Use barycentric static method, maybe implement evaluation as member
         // function on Univariate.
-        auto barycentric = BarycentricData<FF, MAX_RANDOM_RELATION_LENGTH, MAX_RANDOM_RELATION_LENGTH>();
+        auto barycentric =
+            barretenberg::BarycentricData<FF, MAX_RANDOM_RELATION_LENGTH, MAX_RANDOM_RELATION_LENGTH>();
         // Evaluate T^{l}(u_{l})
         target_total_sum = barycentric.evaluate(univariate, round_challenge);
 
@@ -469,7 +465,7 @@ template <typename Flavor> class SumcheckVerifierRound {
     template <size_t relation_idx = 0>
     // TODO(#224)(Cody): Input should be an array?
     void accumulate_relation_evaluations(ClaimedEvaluations purported_evaluations,
-                                         const RelationParameters<FF>& relation_parameters,
+                                         const proof_system::RelationParameters<FF>& relation_parameters,
                                          const FF& partial_evaluation_constant)
     {
         std::get<relation_idx>(relations).add_full_relation_value_contribution(
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.test.cpp
index fa6b176e0be..e6089f875d1 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/sumcheck_round.test.cpp
@@ -1,7 +1,7 @@
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/honk/flavor/standard.hpp"
 #include "barretenberg/numeric/random/engine.hpp"
-#include "polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "sumcheck_round.hpp"
 
 #include <tuple>
@@ -18,6 +18,11 @@
 
 using namespace proof_system::honk;
 using namespace proof_system::honk::sumcheck;
+using namespace proof_system;
+
+using barretenberg::Univariate;
+using barretenberg::PowUnivariate;
+using barretenberg::BarycentricData;
 
 using Flavor = flavor::Standard;
 using FF = typename Flavor::FF;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp
index 3821d5d6505..89b26fa53fd 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/transcript/transcript.test.cpp
@@ -2,14 +2,11 @@
 #include "barretenberg/honk/composer/standard_composer.hpp"
 #include "barretenberg/honk/composer/ultra_composer.hpp"
 #include "barretenberg/honk/flavor/standard.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/numeric/bitop/get_msb.hpp"
 #include "barretenberg/proof_system/flavor/flavor.hpp"
 #include "transcript.hpp"
-#include <cstddef>
-#include <cstdint>
 #include <gtest/gtest.h>
-#include <string>
 
 using namespace proof_system::honk;
 
@@ -188,7 +185,7 @@ TYPED_TEST(TranscriptTests, ProverAndVerifierBasic)
     constexpr size_t LENGTH = 8;
 
     using Fr = barretenberg::fr;
-    using Univariate = proof_system::honk::sumcheck::Univariate<Fr, LENGTH>;
+    using Univariate = barretenberg::Univariate<Fr, LENGTH>;
     using Commitment = barretenberg::g1::affine_element;
 
     std::array<Fr, LENGTH> evaluations;
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/barycentric.hpp
similarity index 82%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/barycentric.hpp
index 319ba0f287a..6146f070ba9 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/barycentric.hpp
@@ -1,7 +1,5 @@
 #pragma once
 #include "univariate.hpp"
-#include <algorithm>
-#include <array>
 
 // TODO(#674): We need the functionality of BarycentricData for both field (native) and field_t (stdlib). The former is
 // is compatible with constexpr operations, and the former is not. The functions for computing the
@@ -17,13 +15,12 @@
 
    3) There should be more thorough testing of this class in isolation.
  */
-namespace proof_system::honk::sumcheck {
+namespace barretenberg {
 
 /**
- * NOTE: We should definitely consider question of optimal choice of domain, but if decide on {0,1,...,t-1} then we can
- * simplify the implementation a bit.
- * NOTE: if we use this approach in the recursive setting, will use Plookup?
+ * @todo: TODO(https://github.com/AztecProtocol/barretenberg/issues/713) Optimize with lookup tables?
  */
+
 template <class Fr, size_t domain_size, size_t num_evals> class BarycentricDataCompileTime {
   public:
     static constexpr size_t big_domain_size = std::max(domain_size, num_evals);
@@ -126,7 +123,7 @@ template <class Fr, size_t domain_size, size_t num_evals> class BarycentricDataC
     static constexpr auto full_numerator_values = construct_full_numerator_values(big_domain);
 
     /**
-     * @brief Given A univariate f represented by {f(0), ..., f(t-1)}, compute {f(t), ..., f(u-1)}
+     * @brief Given a univariate f represented by {f(0), ..., f(t-1)}, compute {f(t), ..., f(u-1)}
      * and return the Univariate represented by {f(0), ..., f(u-1)}.
      *
      * @details Write v_i = f(x_i) on a the domain {x_0, ..., x_{t-1}}. To efficiently compute the needed values of f,
@@ -136,33 +133,37 @@ template <class Fr, size_t domain_size, size_t num_evals> class BarycentricDataC
      *      - B(x) = Π_{i=0}^{t-1} (x-x_i)
      *      - d_i  = Π_{j ∈ {0, ..., t-1}, j≠i} (x_i-x_j) for i ∈ {0, ..., t-1}
      *
-     * NOTE: just taking x_i = i for now and possibly forever. Hence can significantly optimize:
-     *       extending an Edge f = v0(1-X) + v1X to a new value involves just one addition and a subtraction:
-     *       setting Δ  = v1-v0, the values of f(X) are
-     *       f(0)=v0, f(1)= v0 + Δ, v2 = f(1) + Δ, v3 = f(2) + Δ...
+     * When the domain size is two, extending f = v0(1-X) + v1X to a new value involves just one addition and a
+     * subtraction: setting Δ = v1-v0, the values of f(X) are f(0)=v0, f(1)= v0 + Δ, v2 = f(1) + Δ, v3 = f(2) + Δ...
      *
      */
-    Univariate<Fr, num_evals> extend(Univariate<Fr, domain_size> f)
+    Univariate<Fr, num_evals> extend(const Univariate<Fr, domain_size>& f)
     {
-        // ASSERT(u>t);
+        static_assert(num_evals >= domain_size);
         Univariate<Fr, num_evals> result;
 
-        for (size_t k = 0; k != domain_size; ++k) {
-            result.value_at(k) = f.value_at(k);
-        }
+        std::copy(f.evaluations.begin(), f.evaluations.end(), result.evaluations.begin());
 
-        for (size_t k = domain_size; k != num_evals; ++k) {
-            result.value_at(k) = 0;
-            // compute each term v_j / (d_j*(x-x_j)) of the sum
-            for (size_t j = 0; j != domain_size; ++j) {
-                Fr term = f.value_at(j);
-                term *= precomputed_denominator_inverses[domain_size * k + j];
-                result.value_at(k) += term;
+        if constexpr (domain_size == 2) {
+            Fr delta = f.value_at(1) - f.value_at(0);
+            for (size_t idx = 1; idx < num_evals - 1; idx++) {
+                result.value_at(idx + 1) = result.value_at(idx) + delta;
             }
-            // scale the sum by the the value of of B(x)
-            result.value_at(k) *= full_numerator_values[k];
+            return result;
+        } else {
+            for (size_t k = domain_size; k != num_evals; ++k) {
+                result.value_at(k) = 0;
+                // compute each term v_j / (d_j*(x-x_j)) of the sum
+                for (size_t j = 0; j != domain_size; ++j) {
+                    Fr term = f.value_at(j);
+                    term *= precomputed_denominator_inverses[domain_size * k + j];
+                    result.value_at(k) += term;
+                }
+                // scale the sum by the the value of of B(x)
+                result.value_at(k) *= full_numerator_values[k];
+            }
+            return result;
         }
-        return result;
     }
 
     /**
@@ -171,7 +172,7 @@ template <class Fr, size_t domain_size, size_t num_evals> class BarycentricDataC
      * @param f
      * @return Fr
      */
-    Fr evaluate(Univariate<Fr, domain_size>& f, const Fr& u)
+    Fr evaluate(const Univariate<Fr, domain_size>& f, const Fr& u)
     {
 
         Fr full_numerator_value = 1;
@@ -303,7 +304,7 @@ template <class Fr, size_t domain_size, size_t num_evals> class BarycentricDataR
     inline static const auto full_numerator_values = construct_full_numerator_values(big_domain);
 
     /**
-     * @brief Given A univariate f represented by {f(0), ..., f(t-1)}, compute {f(t), ..., f(u-1)}
+     * @brief Given a univariate f represented by {f(0), ..., f(t-1)}, compute {f(t), ..., f(u-1)}
      * and return the Univariate represented by {f(0), ..., f(u-1)}.
      *
      * @details Write v_i = f(x_i) on a the domain {x_0, ..., x_{t-1}}. To efficiently compute the needed values of f,
@@ -313,33 +314,41 @@ template <class Fr, size_t domain_size, size_t num_evals> class BarycentricDataR
      *      - B(x) = Π_{i=0}^{t-1} (x-x_i)
      *      - d_i  = Π_{j ∈ {0, ..., t-1}, j≠i} (x_i-x_j) for i ∈ {0, ..., t-1}
      *
-     * NOTE: just taking x_i = i for now and possibly forever. Hence can significantly optimize:
-     *       extending an Edge f = v0(1-X) + v1X to a new value involves just one addition and a subtraction:
-     *       setting Δ  = v1-v0, the values of f(X) are
-     *       f(0)=v0, f(1)= v0 + Δ, v2 = f(1) + Δ, v3 = f(2) + Δ...
+     * When the domain size is two, extending f = v0(1-X) + v1X to a new value involves just one addition and a
+     * subtraction: setting Δ = v1-v0, the values of f(X) are f(0)=v0, f(1)= v0 + Δ, v2 = f(1) + Δ, v3 = f(2) + Δ...
      *
      */
     Univariate<Fr, num_evals> extend(Univariate<Fr, domain_size> f)
     {
-        // ASSERT(u>t);
+        static_assert(num_evals >= domain_size);
         Univariate<Fr, num_evals> result;
 
-        for (size_t k = 0; k != domain_size; ++k) {
-            result.value_at(k) = f.value_at(k);
-        }
+        std::copy(f.evaluations.begin(), f.evaluations.end(), result.evaluations.begin());
 
-        for (size_t k = domain_size; k != num_evals; ++k) {
-            result.value_at(k) = 0;
-            // compute each term v_j / (d_j*(x-x_j)) of the sum
-            for (size_t j = 0; j != domain_size; ++j) {
-                Fr term = f.value_at(j);
-                term *= precomputed_denominator_inverses[domain_size * k + j];
-                result.value_at(k) += term;
+        if constexpr (domain_size == 2) {
+            Fr delta = f.value_at(1) - f.value_at(0);
+            for (size_t idx = 1; idx < num_evals - 1; idx++) {
+                result.value_at(idx + 1) = result.value_at(idx) + delta;
             }
-            // scale the sum by the the value of of B(x)
-            result.value_at(k) *= full_numerator_values[k];
+            return result;
+        } else {
+            for (size_t k = 0; k != domain_size; ++k) {
+                result.value_at(k) = f.value_at(k);
+            }
+
+            for (size_t k = domain_size; k != num_evals; ++k) {
+                result.value_at(k) = 0;
+                // compute each term v_j / (d_j*(x-x_j)) of the sum
+                for (size_t j = 0; j != domain_size; ++j) {
+                    Fr term = f.value_at(j);
+                    term *= precomputed_denominator_inverses[domain_size * k + j];
+                    result.value_at(k) += term;
+                }
+                // scale the sum by the the value of of B(x)
+                result.value_at(k) *= full_numerator_values[k];
+            }
+            return result;
         }
-        return result;
     }
 
     /**
@@ -406,4 +415,4 @@ using BarycentricData = std::conditional_t<is_field_type_v<Fr>,
                                            BarycentricDataCompileTime<Fr, domain_size, num_evals>,
                                            BarycentricDataRunTime<Fr, domain_size, num_evals>>;
 
-} // namespace proof_system::honk::sumcheck
+} // namespace barretenberg
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/barycentric.test.cpp
similarity index 93%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.test.cpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/barycentric.test.cpp
index df8eb47fdfa..2dcda2c229d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/barycentric_data.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/barycentric.test.cpp
@@ -1,11 +1,8 @@
+#include "barycentric.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barycentric_data.hpp"
-
-#include "barretenberg/numeric/random/engine.hpp"
 #include <gtest/gtest.h>
 
-using namespace proof_system::honk::sumcheck;
-namespace test_sumcheck_polynomials {
+namespace barretenberg::test_barycentric {
 
 template <class FF> class BarycentricDataTests : public testing::Test {};
 
@@ -97,4 +94,4 @@ TYPED_TEST(BarycentricDataTests, BarycentricData5to6)
     EXPECT_EQ(ext1, expected);
 }
 
-} // namespace test_sumcheck_polynomials
+} // namespace barretenberg::test_barycentric
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial.hpp
index aa8aef4d445..e330b94b85d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/polynomial.hpp
@@ -4,10 +4,8 @@
 #include "barretenberg/ecc/curves/grumpkin/grumpkin.hpp"
 #include "evaluation_domain.hpp"
 #include "polynomial_arithmetic.hpp"
-#include <concepts>
-#include <cstddef>
 #include <fstream>
-#include <span>
+
 namespace barretenberg {
 template <typename Fr> class Polynomial {
   public:
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/pow.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/pow.hpp
similarity index 98%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/pow.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/pow.hpp
index dd84d7cebc8..9039266cac0 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/pow.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/pow.hpp
@@ -1,6 +1,6 @@
 #pragma once
 
-namespace proof_system::honk::sumcheck {
+namespace barretenberg {
 
 /**
  * @brief Succinct representation of the `pow` polynomial that can be partially evaluated variable-by-variable.
@@ -128,4 +128,4 @@ template <typename FF> struct PowUnivariate {
         partial_evaluation_constant *= current_univariate_eval;
     }
 };
-} // namespace proof_system::honk::sumcheck
\ No newline at end of file
+} // namespace barretenberg
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/pow.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/pow.test.cpp
similarity index 65%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/pow.test.cpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/pow.test.cpp
index b67816d3632..9c5a725d159 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/pow.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/pow.test.cpp
@@ -1,9 +1,8 @@
-#include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barretenberg/honk/utils/power_polynomial.hpp"
 #include "pow.hpp"
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include <gtest/gtest.h>
 
-namespace proof_system::honk::sumcheck::pow_test {
+namespace barretenberg::test_pow {
 
 using FF = barretenberg::fr;
 
@@ -12,15 +11,21 @@ TEST(SumcheckPow, FullPowConsistency)
     constexpr size_t d = 5;
 
     FF zeta = FF::random_element();
-    PowUnivariate<FF> pow_univariate(zeta);
 
+    PowUnivariate<FF> pow_univariate(zeta);
     std::array<FF, d> variables{};
     for (auto& u_i : variables) {
         u_i = FF::random_element();
         pow_univariate.partially_evaluate(u_i);
     }
-
-    FF expected_eval = proof_system::honk::power_polynomial::evaluate<FF>(zeta, variables);
+    
+    FF zeta_power = zeta;
+    FF expected_eval = 1;
+    for (auto& u_i : variables) {
+        expected_eval *= FF(1) - u_i + u_i * zeta_power;
+        zeta_power *= zeta_power;
+    }
+    
     EXPECT_EQ(pow_univariate.partial_evaluation_constant, expected_eval);
 }
-} // namespace proof_system::honk::sumcheck::pow_test
+} // namespace barretenberg::test_pow
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/univariate.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/univariate.hpp
similarity index 92%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/univariate.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/univariate.hpp
index 948382b8453..b3441db700e 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/univariate.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/univariate.hpp
@@ -2,18 +2,27 @@
 #include "barretenberg/common/assert.hpp"
 #include "barretenberg/common/serialize.hpp"
 #include <array>
-#include <cstdint>
-#include <ostream>
 #include <span>
 
-namespace proof_system::honk::sumcheck {
+namespace barretenberg {
 
+/**
+ * @brief A view of a univariate, also used to truncate univariates.
+ *
+ * @details For optimization purposes, it makes sense to define univariates with large lengths and then reuse only some
+ * of the data in those univariates. We do that by taking a view of those elements and then, as needed, using this to
+ * populate new containers.
+ */
 template <class Fr, size_t view_length> class UnivariateView;
 
+/**
+ * @brief A univariate polynomial represented by its values on {0,1,..., _length-1}
+ */
 template <class Fr, size_t _length> class Univariate {
   public:
     static constexpr size_t LENGTH = _length;
 
+    // TODO(https://github.com/AztecProtocol/barretenberg/issues/714) Try out std::valarray?
     std::array<Fr, _length> evaluations;
 
     Univariate() = default;
@@ -59,6 +68,15 @@ template <class Fr, size_t _length> class Univariate {
         return result;
     }
 
+    static Univariate get_random()
+    {
+        auto output = Univariate<Fr, _length>();
+        for (size_t i = 0; i != _length; ++i) {
+            output.value_at(i) = Fr::random_element();
+        }
+        return output;
+    };
+
     // Operations between Univariate and other Univariate
     bool operator==(const Univariate& other) const = default;
 
@@ -356,4 +374,4 @@ template <typename T, typename U, std::size_t N> std::array<T, N> array_to_array
     return array_to_array_aux<T, U, N>(elements, std::make_index_sequence<N>());
 };
 
-} // namespace proof_system::honk::sumcheck
+} // namespace barretenberg
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/univariate.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/univariate.test.cpp
similarity index 88%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/univariate.test.cpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/univariate.test.cpp
index 91417fec90e..41a35337142 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/polynomials/univariate.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/polynomials/univariate.test.cpp
@@ -1,26 +1,12 @@
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
-#include "barycentric_data.hpp"
-#include "univariate.hpp"
-
-#include "barretenberg/numeric/random/engine.hpp"
+#include "barycentric.hpp"
 #include <gtest/gtest.h>
 
-using namespace proof_system::honk::sumcheck;
-namespace test_univariate {
+namespace barretenberg::test_univariate {
 
 template <typename FF> class UnivariateTest : public testing::Test {
   public:
     template <size_t view_length> using UnivariateView = UnivariateView<FF, view_length>;
-
-    // IMPROVEMENT(Cody) this is not used anywhere? Move to memeber function of U/snivariate?
-    template <size_t length> Univariate<FF, length> random_univariate()
-    {
-        auto output = Univariate<FF, length>();
-        for (size_t i = 0; i != length; ++i) {
-            output.value_at(i) = FF::random_element();
-        }
-        return output;
-    };
 };
 
 using FieldTypes = testing::Types<barretenberg::fr>;
@@ -173,4 +159,4 @@ TYPED_TEST(UnivariateTest, Serialization)
     }
 }
 
-} // namespace test_univariate
+} // namespace barretenberg::test_univariate
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/flavor/flavor.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/flavor/flavor.hpp
index 3065f2eacfc..af934fe7069 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/flavor/flavor.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/flavor/flavor.hpp
@@ -64,10 +64,8 @@
  */
 
 #pragma once
-#include "barretenberg/honk/pcs/commitment_key.hpp"
-#include "barretenberg/honk/pcs/verification_key.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/barycentric_data.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
+#include "barretenberg/polynomials/barycentric.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/polynomials/evaluation_domain.hpp"
 #include "barretenberg/proof_system/types/circuit_type.hpp"
 #include <array>
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/arithmetic_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/arithmetic_relation.hpp
new file mode 100644
index 00000000000..b3bb4e84132
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/arithmetic_relation.hpp
@@ -0,0 +1,57 @@
+#pragma once
+#include "relation_parameters.hpp"
+#include "relation_types.hpp"
+
+namespace proof_system {
+
+template <typename FF_> class ArithmeticRelationImpl {
+  public:
+    using FF = FF_;
+
+    // 1 + polynomial degree of this relation
+    static constexpr size_t RELATION_LENGTH = 4;
+
+    static constexpr size_t LEN_1 = 4; // arithmetic sub-relation
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1>;
+
+    /**
+     * @brief Expression for the StandardArithmetic gate.
+     * @details The relation is defined as
+     *    (q_m * w_r * w_l) + (q_l * w_l) + (q_r * w_r) + (q_o * w_o) + q_c
+     *
+     * @param accumulator the term being calculated by a sequence of calls to this function
+     * @param new_term the term added to the accumulator in this iteration of the function
+     * @param parameters inputs not varying between successive executions of this function
+     * @param scaling_factor scales the new_term before incorporating it into the accumulator
+     */
+    template <typename AccumulatorTypes>
+    void static accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                           const auto& new_term,
+                           [[maybe_unused]] const RelationParameters<FF>& parameters,
+                           const FF& scaling_factor)
+    {
+        // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
+        //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
+
+        using View = typename std::tuple_element<0, typename AccumulatorTypes::AccumulatorViews>::type;
+        auto w_l = View(new_term.w_l);
+        auto w_r = View(new_term.w_r);
+        auto w_o = View(new_term.w_o);
+        auto q_m = View(new_term.q_m);
+        auto q_l = View(new_term.q_l);
+        auto q_r = View(new_term.q_r);
+        auto q_o = View(new_term.q_o);
+        auto q_c = View(new_term.q_c);
+
+        auto tmp = w_l * (q_m * w_r + q_l);
+        tmp += q_r * w_r;
+        tmp += q_o * w_o;
+        tmp += q_c;
+        tmp *= scaling_factor;
+        std::get<0>(accumulators) += tmp;
+    };
+};
+
+template <typename FF> using ArithmeticRelation = Relation<ArithmeticRelationImpl<FF>>;
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/auxiliary_relation.hpp
similarity index 94%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/auxiliary_relation.hpp
index 7d3123592ba..91997903d8c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/auxiliary_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/auxiliary_relation.hpp
@@ -1,16 +1,14 @@
 #pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
 #include "barretenberg/numeric/uint256/uint256.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
-template <typename FF> class AuxiliaryRelationBase {
+template <typename FF_> class AuxiliaryRelationImpl {
   public:
+    using FF = FF_;
+    
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 6;
 
@@ -20,8 +18,8 @@ template <typename FF> class AuxiliaryRelationBase {
     static constexpr size_t LEN_4 = 6; // RAM consistency sub-relation 1
     static constexpr size_t LEN_5 = 6; // RAM consistency sub-relation 2
     static constexpr size_t LEN_6 = 6; // RAM consistency sub-relation 3
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2, LEN_3, LEN_4, LEN_5, LEN_6>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2, LEN_3, LEN_4, LEN_5, LEN_6>;
 
     /**
      * @brief Expression for the generalized permutation sort gate.
@@ -58,10 +56,10 @@ template <typename FF> class AuxiliaryRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    inline static void add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulators,
-                                                  const auto& extended_edges,
-                                                  const RelationParameters<FF>& relation_parameters,
-                                                  const FF& scaling_factor)
+    inline static void accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                                  const auto& extended_edges,
+                                  const RelationParameters<FF>& relation_parameters,
+                                  const FF& scaling_factor)
     {
         // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
         //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
@@ -295,5 +293,5 @@ template <typename FF> class AuxiliaryRelationBase {
     };
 };
 
-template <typename FF> using AuxiliaryRelation = RelationWrapper<FF, AuxiliaryRelationBase>;
-} // namespace proof_system::honk::sumcheck
+template <typename FF> using AuxiliaryRelation = Relation<AuxiliaryRelationImpl<FF>>;
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ecc_op_queue_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ecc_op_queue_relation.hpp
similarity index 84%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ecc_op_queue_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ecc_op_queue_relation.hpp
index 20ce470587f..0dc0fcd3ab6 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ecc_op_queue_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ecc_op_queue_relation.hpp
@@ -1,15 +1,12 @@
 #pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
-template <typename FF> class EccOpQueueRelationBase {
+template <typename FF_> class EccOpQueueRelationImpl {
   public:
+    using FF = FF_;
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 3; // degree(q * (w - w_op_queue)) = 2
 
@@ -21,8 +18,8 @@ template <typename FF> class EccOpQueueRelationBase {
     static constexpr size_t LEN_6 = 3; // op-queue-wire vanishes sub-relation 2
     static constexpr size_t LEN_7 = 3; // op-queue-wire vanishes sub-relation 3
     static constexpr size_t LEN_8 = 3; // op-queue-wire vanishes sub-relation 4
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2, LEN_3, LEN_4, LEN_5, LEN_6, LEN_7, LEN_8>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2, LEN_3, LEN_4, LEN_5, LEN_6, LEN_7, LEN_8>;
 
     /**
      * @brief Expression for the generalized permutation sort gate.
@@ -44,10 +41,10 @@ template <typename FF> class EccOpQueueRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    void static add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulators,
-                                           const auto& extended_edges,
-                                           const RelationParameters<FF>&,
-                                           const FF& scaling_factor)
+    void static accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                           const auto& extended_edges,
+                           const RelationParameters<FF>&,
+                           const FF& scaling_factor)
     {
         // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
         //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
@@ -111,6 +108,6 @@ template <typename FF> class EccOpQueueRelationBase {
     };
 };
 
-template <typename FF> using EccOpQueueRelation = RelationWrapper<FF, EccOpQueueRelationBase>;
+template <typename FF> using EccOpQueueRelation = Relation<EccOpQueueRelationImpl<FF>>;
 
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/elliptic_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/elliptic_relation.hpp
similarity index 86%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/elliptic_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/elliptic_relation.hpp
index d63fd5ac4ff..d0d9910195b 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/elliptic_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/elliptic_relation.hpp
@@ -1,22 +1,20 @@
 #pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
-template <typename FF> class EllipticRelationBase {
+template <typename FF_> class EllipticRelationImpl {
   public:
+    using FF = FF_;
+
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 6; // degree(q_elliptic * q_beta * x^3) = 5
 
     static constexpr size_t LEN_1 = 6; // x-coordinate sub-relation
     static constexpr size_t LEN_2 = 5; // y-coordinate sub-relation
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2>;
 
     /**
      * @brief Expression for the Ultra Arithmetic gate.
@@ -29,10 +27,10 @@ template <typename FF> class EllipticRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    static void add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulators,
-                                           const auto& extended_edges,
-                                           const RelationParameters<FF>&,
-                                           const FF& scaling_factor){
+    static void accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                           const auto& extended_edges,
+                           const RelationParameters<FF>&,
+                           const FF& scaling_factor){
         // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
         //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
         // TODO(luke): Formatter doesnt properly handle explicit scoping below so turning off. Whats up?
@@ -100,6 +98,6 @@ template <typename FF> class EllipticRelationBase {
 };
 
 template <typename FF>
-using EllipticRelation = RelationWrapper<FF, EllipticRelationBase>;
+using EllipticRelation = Relation<EllipticRelationImpl<FF>>;
 // clang-format on
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/gen_perm_sort_relation.hpp
similarity index 80%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/gen_perm_sort_relation.hpp
index 248822e00d9..dd7e4cda102 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/gen_perm_sort_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/gen_perm_sort_relation.hpp
@@ -1,15 +1,13 @@
 #pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
-template <typename FF> class GenPermSortRelationBase {
+template <typename FF_> class GenPermSortRelationImpl {
   public:
+    using FF = FF_;
+
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 6; // degree(q_sort * D(D - 1)(D - 2)(D - 3)) = 5
 
@@ -17,8 +15,8 @@ template <typename FF> class GenPermSortRelationBase {
     static constexpr size_t LEN_2 = 6; // range constrain sub-relation 2
     static constexpr size_t LEN_3 = 6; // range constrain sub-relation 3
     static constexpr size_t LEN_4 = 6; // range constrain sub-relation 4
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2, LEN_3, LEN_4>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2, LEN_3, LEN_4>;
 
     /**
      * @brief Expression for the generalized permutation sort gate.
@@ -36,10 +34,10 @@ template <typename FF> class GenPermSortRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    void static add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulators,
-                                           const auto& extended_edges,
-                                           const RelationParameters<FF>&,
-                                           const FF& scaling_factor)
+    void static accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                           const auto& extended_edges,
+                           const RelationParameters<FF>&,
+                           const FF& scaling_factor)
     {
         // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
         //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
@@ -100,6 +98,6 @@ template <typename FF> class GenPermSortRelationBase {
     };
 };
 
-template <typename FF> using GenPermSortRelation = RelationWrapper<FF, GenPermSortRelationBase>;
+template <typename FF> using GenPermSortRelation = Relation<GenPermSortRelationImpl<FF>>;
 
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/lookup_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/lookup_relation.hpp
similarity index 91%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/lookup_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/lookup_relation.hpp
index 56ff50447fd..336acc0e8cf 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/lookup_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/lookup_relation.hpp
@@ -1,13 +1,11 @@
 #pragma once
-#include "../polynomials/univariate.hpp"
-#include "barretenberg/polynomials/polynomial.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
 /**
- * @brief LookupRelationBase defines the algebra for the lookup polynomial:
+ * @brief LookupRelationImpl defines the algebra for the lookup polynomial:
  *
  *                       ∏ (1 + β) ⋅ (q_lookup*f_k + γ) ⋅ (t_k + βt_{k+1} + γ(1 + β))
  *  Z_lookup(g^j) = --------------------------------------------------------------------------
@@ -21,15 +19,17 @@ namespace proof_system::honk::sumcheck {
  *
  * @tparam FF parametrises the prime field class being used
  */
-template <typename FF> class LookupRelationBase {
+template <typename FF_> class LookupRelationImpl {
   public:
+    using FF = FF_;
+
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 6; // deg(z_lookup * column_selector * wire * q_lookup * table) = 5
 
     static constexpr size_t LEN_1 = 6; // grand product construction sub-relation
     static constexpr size_t LEN_2 = 3; // left-shiftable polynomial sub-relation
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2>;
     template <typename T> using Accumulator = typename std::tuple_element<0, typename T::Accumulators>::type;
 
     /**
@@ -161,10 +161,10 @@ template <typename FF> class LookupRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    inline static void add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulators,
-                                                  const auto& extended_edges,
-                                                  const RelationParameters<FF>& relation_parameters,
-                                                  const FF& scaling_factor)
+    inline static void accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                                  const auto& extended_edges,
+                                  const RelationParameters<FF>& relation_parameters,
+                                  const FF& scaling_factor)
     {
         const auto& grand_product_delta = relation_parameters.lookup_grand_product_delta;
 
@@ -197,6 +197,6 @@ template <typename FF> class LookupRelationBase {
     };
 };
 
-template <typename FF> using LookupRelation = RelationWrapper<FF, LookupRelationBase>;
+template <typename FF> using LookupRelation = Relation<LookupRelationImpl<FF>>;
 
-} // namespace proof_system::honk::sumcheck
\ No newline at end of file
+} // namespace proof_system
\ No newline at end of file
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/permutation_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/permutation_relation.hpp
similarity index 86%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/permutation_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/permutation_relation.hpp
index c3deb11fcf1..972f98e6ed4 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/permutation_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/permutation_relation.hpp
@@ -1,21 +1,22 @@
 #pragma once
-#include "../polynomials/univariate.hpp"
-#include "barretenberg/polynomials/polynomial.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 // TODO(luke): change name of this file to permutation_grand_product_relation(s).hpp and move 'init' relation into it.
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
-template <typename FF> class PermutationRelationBase {
+template <typename FF_> class PermutationRelationImpl {
   public:
+    using FF = FF_;
+
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 5;
 
     static constexpr size_t LEN_1 = 5; // grand product construction sub-relation
     static constexpr size_t LEN_2 = 3; // left-shiftable polynomial sub-relation
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2>;
+    static constexpr std::tuple<size_t, size_t> SUBRELATION_LENGTHS = {LEN_1, LEN_2};
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2>;
     template <typename T> using Accumulator = typename std::tuple_element<0, typename T::Accumulators>::type;
 
     inline static auto& get_grand_product_polynomial(auto& input) { return input.z_perm; }
@@ -74,10 +75,10 @@ template <typename FF> class PermutationRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    inline static void add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulator,
-                                                  const auto& input,
-                                                  const RelationParameters<FF>& relation_parameters,
-                                                  const FF& scaling_factor)
+    inline static void accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                                  const auto& input,
+                                  const RelationParameters<FF>& relation_parameters,
+                                  const FF& scaling_factor)
     {
         const auto& public_input_delta = relation_parameters.public_input_delta;
 
@@ -89,7 +90,7 @@ template <typename FF> class PermutationRelationBase {
             auto lagrange_last = View(input.lagrange_last);
 
             // Contribution (1)
-            std::get<0>(accumulator) +=
+            std::get<0>(accumulators) +=
                 (((z_perm + lagrange_first) *
                   compute_grand_product_numerator<AccumulatorTypes>(input, relation_parameters, 0)) -
                  ((z_perm_shift + lagrange_last * public_input_delta) *
@@ -102,22 +103,24 @@ template <typename FF> class PermutationRelationBase {
             auto lagrange_last = View(input.lagrange_last);
 
             // Contribution (2)
-            std::get<1>(accumulator) += (lagrange_last * z_perm_shift) * scaling_factor;
+            std::get<1>(accumulators) += (lagrange_last * z_perm_shift) * scaling_factor;
         }
     };
 };
 
 // TODO(luke): With Cody's Flavor work it should be easier to create a simple templated relation
 // for handling arbitrary width. For now I'm duplicating the width 3 logic for width 4.
-template <typename FF> class UltraPermutationRelationBase {
+template <typename FF_> class UltraPermutationRelationImpl {
   public:
+    using FF = FF_;
+
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 6;
 
     static constexpr size_t LEN_1 = 6; // grand product construction sub-relation
     static constexpr size_t LEN_2 = 3; // left-shiftable polynomial sub-relation
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2>;
     template <typename T> using Accumulator = typename std::tuple_element<0, typename T::Accumulators>::type;
 
     inline static auto& get_grand_product_polynomial(auto& input) { return input.z_perm; }
@@ -176,10 +179,10 @@ template <typename FF> class UltraPermutationRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    inline static void add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& accumulators,
-                                                  const auto& extended_edges,
-                                                  const RelationParameters<FF>& relation_parameters,
-                                                  const FF& scaling_factor)
+    inline static void accumulate(typename AccumulatorTypes::Accumulators& accumulators,
+                                  const auto& extended_edges,
+                                  const RelationParameters<FF>& relation_parameters,
+                                  const FF& scaling_factor)
     {
         const auto& public_input_delta = relation_parameters.public_input_delta;
 
@@ -210,7 +213,7 @@ template <typename FF> class UltraPermutationRelationBase {
     };
 };
 
-template <typename FF> using PermutationRelation = RelationWrapper<FF, PermutationRelationBase>;
+template <typename FF> using PermutationRelation = Relation<PermutationRelationImpl<FF>>;
+template <typename FF> using UltraPermutationRelation = Relation<UltraPermutationRelationImpl<FF>>;
 
-template <typename FF> using UltraPermutationRelation = RelationWrapper<FF, UltraPermutationRelationBase>;
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_parameters.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/relation_parameters.hpp
similarity index 53%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_parameters.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/relation_parameters.hpp
index a575a999a76..529d2cbb005 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_parameters.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/relation_parameters.hpp
@@ -1,7 +1,6 @@
 #pragma once
 
-#include <cstddef>
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
 /**
  * @brief Container for parameters used by the grand product (permutation, lookup) Honk relations
@@ -14,5 +13,16 @@ template <typename FF> struct RelationParameters {
     FF gamma = FF(0);                      // Permutation + Lookup
     FF public_input_delta = FF(0);         // Permutation
     FF lookup_grand_product_delta = FF(0); // Lookup
+
+    static RelationParameters get_random()
+    {
+        RelationParameters result;
+        result.eta = FF::random_element();
+        result.beta = FF::random_element();
+        result.gamma = FF::random_element();
+        result.public_input_delta = FF::random_element();
+        result.lookup_grand_product_delta = FF::random_element();
+        return result;
+    }
 };
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/relation_types.hpp
similarity index 58%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/relation_types.hpp
index e66cc8f9800..041ebbc0a95 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/relation_types.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/relation_types.hpp
@@ -1,11 +1,8 @@
 #pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "relation_parameters.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 template <typename T> concept HasSubrelationLinearlyIndependentMember = requires(T)
 {
     T::Relation::SUBRELATION_LINEARLY_INDEPENDENT;
@@ -23,16 +20,14 @@ template <typename T> concept HasSubrelationLinearlyIndependentMember = requires
  * std::tuple<UnivariateView>. For the verifier, who accumulates FFs, both types are simply aliases for std::array<FF>
  * (since no "view" type is necessary). The containers std::tuple and std::array are needed to accommodate multiple
  * sub-relations within each relation, where, for efficiency, each sub-relation has its own specified degree.
+ *
+ * @todo TODO(https://github.com/AztecProtocol/barretenberg/issues/720)
+ *
  */
 
 /**
  * @brief Getter method that will return `input[index]` iff `input` is a std::span container
  *
- * @tparam FF
- * @tparam TypeMuncher
- * @tparam T
- * @param input
- * @param index
  * @return requires
  */
 template <typename FF, typename AccumulatorTypes, typename T>
@@ -46,11 +41,6 @@ requires std::is_same<std::span<FF>, T>::value inline
 /**
  * @brief Getter method that will return `input[index]` iff `input` is not a std::span container
  *
- * @tparam FF
- * @tparam TypeMuncher
- * @tparam T
- * @param input
- * @param index
  * @return requires
  */
 template <typename FF, typename AccumulatorTypes, typename T>
@@ -65,43 +55,48 @@ inline typename std::tuple_element<0, typename AccumulatorTypes::AccumulatorView
  * a given relation to the corresponding accumulator.
  *
  * @tparam FF
- * @tparam RelationBase Base class that implements the arithmetic for a given relation (or set of sub-relations)
+ * @tparam RelationImpl Base class that implements the arithmetic for a given relation (or set of sub-relations)
  */
-template <typename FF, template <typename> typename RelationBase> class RelationWrapper : public RelationBase<FF> {
+template <typename RelationImpl> class Relation : public RelationImpl {
   private:
-    template <size_t... Values> struct UnivariateAccumulatorTypes {
-        using Accumulators = std::tuple<Univariate<FF, Values>...>;
-        using AccumulatorViews = std::tuple<UnivariateView<FF, Values>...>;
+    using FF = typename RelationImpl::FF;
+    template <size_t... subrelation_lengths> struct UnivariateAccumulatorsAndViewsTemplate {
+        using Accumulators = std::tuple<barretenberg::Univariate<FF, subrelation_lengths>...>;
+        using AccumulatorViews = std::tuple<barretenberg::UnivariateView<FF, subrelation_lengths>...>;
     };
-    template <size_t... Values> struct ValueAccumulatorTypes {
-        using Accumulators = std::array<FF, sizeof...(Values)>;
-        using AccumulatorViews = std::array<FF, sizeof...(Values)>; // there is no "view" type here
+    template <size_t... subrelation_lengths> struct ValueAccumulatorsAndViewsTemplate {
+        using Accumulators = std::array<FF, sizeof...(subrelation_lengths)>;
+        using AccumulatorViews = std::array<FF, sizeof...(subrelation_lengths)>; // there is no "view" type here
     };
 
   public:
-    using Relation = RelationBase<FF>;
-    using UnivariateAccumTypes = typename Relation::template AccumulatorTypesBase<UnivariateAccumulatorTypes>;
-    using ValueAccumTypes = typename Relation::template AccumulatorTypesBase<ValueAccumulatorTypes>;
+    // Each `RelationImpl` defines a template `GetAccumulatorTypes` that supplies the `subrelation_lengths` parameters
+    // of the different `AccumulatorsAndViewsTemplate`s.
+    using UnivariateAccumulatorsAndViews =
+        typename RelationImpl::template GetAccumulatorTypes<UnivariateAccumulatorsAndViewsTemplate>;
+    // In the case of the value accumulator types, only the number of subrelations (not their lengths) has an effect.
+    using ValueAccumulatorsAndViews =
+        typename RelationImpl::template GetAccumulatorTypes<ValueAccumulatorsAndViewsTemplate>;
 
-    using RelationUnivariates = typename UnivariateAccumTypes::Accumulators;
-    using RelationValues = typename ValueAccumTypes::Accumulators;
-    static constexpr size_t RELATION_LENGTH = Relation::RELATION_LENGTH;
+    using RelationUnivariates = typename UnivariateAccumulatorsAndViews::Accumulators;
+    using RelationValues = typename ValueAccumulatorsAndViews::Accumulators;
+    static constexpr size_t RELATION_LENGTH = RelationImpl::RELATION_LENGTH;
 
-    inline void add_edge_contribution(auto& accumulator,
-                                      const auto& input,
-                                      const RelationParameters<FF>& relation_parameters,
-                                      const FF& scaling_factor) const
+    static inline void add_edge_contribution(RelationUnivariates& accumulator,
+                                             const auto& input,
+                                             const RelationParameters<FF>& relation_parameters,
+                                             const FF& scaling_factor)
     {
-        Relation::template add_edge_contribution_impl<UnivariateAccumTypes>(
+        Relation::template accumulate<UnivariateAccumulatorsAndViews>(
             accumulator, input, relation_parameters, scaling_factor);
     }
 
-    void add_full_relation_value_contribution(RelationValues& accumulator,
-                                              auto& input,
-                                              const RelationParameters<FF>& relation_parameters,
-                                              const FF& scaling_factor = 1) const
+    static void add_full_relation_value_contribution(RelationValues& accumulator,
+                                                     auto& input,
+                                                     const RelationParameters<FF>& relation_parameters,
+                                                     const FF& scaling_factor = 1)
     {
-        Relation::template add_edge_contribution_impl<ValueAccumTypes>(
+        Relation::template accumulate<ValueAccumulatorsAndViews>(
             accumulator, input, relation_parameters, scaling_factor);
     }
 
@@ -131,4 +126,4 @@ template <typename FF, template <typename> typename RelationBase> class Relation
     }
 };
 
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/standard_relation_consistency.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/standard_relation_consistency.test.cpp
new file mode 100644
index 00000000000..a8528822b0b
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/standard_relation_consistency.test.cpp
@@ -0,0 +1,147 @@
+/**
+ * @file standard_relation_consistency.test.cpp
+ * @brief Show that relation arithmetic has a simple form.
+ * @details The purpose of this test suite is to show that the identity arithmetic implemented in the Relations is
+ * equivalent to a simpler unoptimized version implemented in the tests themselves. This is useful 1) as documentation
+ * since the simple implementations here should make the underlying arithmetic easier to see, and 2) as a check that
+ * optimizations introduced into the Relations have not changed the result.
+ *
+ * For this purpose, we simply feed (the same) random inputs into each of the two implementations and confirm that
+ * the outputs match. This does not confirm the correctness of the identity arithmetic (the identities will not be
+ * satisfied in general by random inputs) only that the two implementations are equivalent.
+ *
+ */
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/proof_system/relations/arithmetic_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include <gtest/gtest.h>
+
+using namespace proof_system;
+
+namespace proof_system::standard_relation_consistency_tests {
+
+using FF = barretenberg::fr;
+struct InputElements {
+    static constexpr size_t NUM_ELEMENTS = 18;
+    std::array<FF, NUM_ELEMENTS> _data;
+
+    static InputElements get_random()
+    {
+        InputElements result;
+        std::generate(result._data.begin(), result._data.end(), [] { return FF::random_element(); });
+        return result;
+    }
+
+    static InputElements get_special() // Use non-random values
+    {
+        InputElements result;
+        FF idx = 0;
+        std::generate(result._data.begin(), result._data.end(), [&] {
+            idx += FF(1);
+            return idx;
+        });
+        return result;
+    }
+
+    FF& q_c = std::get<0>(_data);
+    FF& q_l = std::get<1>(_data);
+    FF& q_r = std::get<2>(_data);
+    FF& q_o = std::get<3>(_data);
+    FF& q_m = std::get<4>(_data);
+    FF& sigma_1 = std::get<5>(_data);
+    FF& sigma_2 = std::get<6>(_data);
+    FF& sigma_3 = std::get<7>(_data);
+    FF& id_1 = std::get<8>(_data);
+    FF& id_2 = std::get<9>(_data);
+    FF& id_3 = std::get<10>(_data);
+    FF& lagrange_first = std::get<11>(_data);
+    FF& lagrange_last = std::get<12>(_data);
+    FF& w_l = std::get<13>(_data);
+    FF& w_r = std::get<14>(_data);
+    FF& w_o = std::get<15>(_data);
+    FF& z_perm = std::get<16>(_data);
+    FF& z_perm_shift = std::get<17>(_data);
+};
+
+class StandardRelationConsistency : public testing::Test {
+  public:
+    template <typename Relation>
+    static void validate_relation_execution(const auto& expected_values,
+                                            const InputElements& input_elements,
+                                            const auto& parameters)
+    {
+        typename Relation::RelationValues accumulator;
+        std::fill(accumulator.begin(), accumulator.end(), FF(0));
+        Relation::add_full_relation_value_contribution(accumulator, input_elements, parameters);
+        EXPECT_EQ(accumulator, expected_values);
+    };
+};
+
+TEST_F(StandardRelationConsistency, ArithmeticRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = ArithmeticRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_l = input_elements.w_l;
+        const auto& w_r = input_elements.w_r;
+        const auto& w_o = input_elements.w_o;
+        const auto& q_m = input_elements.q_m;
+        const auto& q_l = input_elements.q_l;
+        const auto& q_r = input_elements.q_r;
+        const auto& q_o = input_elements.q_o;
+        const auto& q_c = input_elements.q_c;
+
+        RelationValues expected_values;
+        expected_values[0] = (q_m * w_r * w_l) + (q_r * w_r) + (q_l * w_l) + (q_o * w_o) + (q_c);
+
+        const auto parameters = RelationParameters<FF>::get_random();
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+TEST_F(StandardRelationConsistency, PermutationRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = PermutationRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_1 = input_elements.w_l;
+        const auto& w_2 = input_elements.w_r;
+        const auto& w_3 = input_elements.w_o;
+        const auto& sigma_1 = input_elements.sigma_1;
+        const auto& sigma_2 = input_elements.sigma_2;
+        const auto& sigma_3 = input_elements.sigma_3;
+        const auto& id_1 = input_elements.id_1;
+        const auto& id_2 = input_elements.id_2;
+        const auto& id_3 = input_elements.id_3;
+        const auto& z_perm = input_elements.z_perm;
+        const auto& z_perm_shift = input_elements.z_perm_shift;
+        const auto& lagrange_first = input_elements.lagrange_first;
+        const auto& lagrange_last = input_elements.lagrange_last;
+
+        RelationValues expected_values;
+        const auto parameters = RelationParameters<FF>::get_random();
+        const auto& beta = parameters.beta;
+        const auto& gamma = parameters.gamma;
+        const auto& public_input_delta = parameters.public_input_delta;
+
+        expected_values[0] = (z_perm + lagrange_first) * (w_1 + id_1 * beta + gamma) * (w_2 + id_2 * beta + gamma) *
+                                 (w_3 + id_3 * beta + gamma) -
+                             (z_perm_shift + lagrange_last * public_input_delta) * (w_1 + sigma_1 * beta + gamma) *
+                                 (w_2 + sigma_2 * beta + gamma) * (w_3 + sigma_3 * beta + gamma);
+
+        expected_values[1] = z_perm_shift * lagrange_last;
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+} // namespace proof_system::standard_relation_consistency_tests
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp
similarity index 87%
rename from circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp
rename to circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp
index 6127a39e19c..e751dfad64f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/honk/sumcheck/relations/ultra_arithmetic_relation.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp
@@ -1,22 +1,20 @@
 #pragma once
-#include <array>
-#include <tuple>
-
-#include "../polynomials/univariate.hpp"
 #include "relation_parameters.hpp"
 #include "relation_types.hpp"
 
-namespace proof_system::honk::sumcheck {
+namespace proof_system {
 
-template <typename FF> class UltraArithmeticRelationBase {
+template <typename FF_> class UltraArithmeticRelationImpl {
   public:
+    using FF = FF_;
+
     // 1 + polynomial degree of this relation
     static constexpr size_t RELATION_LENGTH = 6; // degree(q_arith^2 * q_m * w_r * w_l) = 5
 
     static constexpr size_t LEN_1 = 6; // primary arithmetic sub-relation
     static constexpr size_t LEN_2 = 5; // secondary arithmetic sub-relation
-    template <template <size_t...> typename AccumulatorTypesContainer>
-    using AccumulatorTypesBase = AccumulatorTypesContainer<LEN_1, LEN_2>;
+    template <template <size_t...> typename SubrelationAccumulatorsTemplate>
+    using GetAccumulatorTypes = SubrelationAccumulatorsTemplate<LEN_1, LEN_2>;
 
     /**
      * @brief Expression for the Ultra Arithmetic gate.
@@ -70,10 +68,10 @@ template <typename FF> class UltraArithmeticRelationBase {
      * @param scaling_factor optional term to scale the evaluation before adding to evals.
      */
     template <typename AccumulatorTypes>
-    void static add_edge_contribution_impl(typename AccumulatorTypes::Accumulators& evals,
-                                           const auto& extended_edges,
-                                           const RelationParameters<FF>&,
-                                           const FF& scaling_factor){
+    void static accumulate(typename AccumulatorTypes::Accumulators& evals,
+                           const auto& extended_edges,
+                           const RelationParameters<FF>&,
+                           const FF& scaling_factor){
         // OPTIMIZATION?: Karatsuba in general, at least for some degrees?
         //       See https://hackmd.io/xGLuj6biSsCjzQnYN-pEiA?both
         // clang-format off
@@ -122,7 +120,7 @@ template <typename FF> class UltraArithmeticRelationBase {
 };
 
 template <typename FF>
-using UltraArithmeticRelation = RelationWrapper<FF, UltraArithmeticRelationBase>;
+using UltraArithmeticRelation = Relation<UltraArithmeticRelationImpl<FF>>;
 
 // clang-format on
-} // namespace proof_system::honk::sumcheck
+} // namespace proof_system
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_relation_consistency.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_relation_consistency.test.cpp
new file mode 100644
index 00000000000..a5d6ad5fc32
--- /dev/null
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/proof_system/relations/ultra_relation_consistency.test.cpp
@@ -0,0 +1,533 @@
+/**
+ * @file ultra_relation_consistency.test.cpp
+ * @brief Show that relation arithmetic has a simple form.
+ * @details The purpose of this test suite is to show that the identity arithmetic implemented in the Relations is
+ * equivalent to a simpler unoptimized version implemented in the tests themselves. This is useful 1) as documentation
+ * since the simple implementations here should make the underlying arithmetic easier to see, and 2) as a check that
+ * optimizations introduced into the Relations have not changed the result.
+ *
+ * For this purpose, we simply feed (the same) random inputs into each of the two implementations and confirm that
+ * the outputs match. This does not confirm the correctness of the identity arithmetic (the identities will not be
+ * satisfied in general by random inputs) only that the two implementations are equivalent.
+ *
+ */
+#include "barretenberg/ecc/curves/bn254/fr.hpp"
+#include "barretenberg/proof_system/relations/auxiliary_relation.hpp"
+#include "barretenberg/proof_system/relations/elliptic_relation.hpp"
+#include "barretenberg/proof_system/relations/gen_perm_sort_relation.hpp"
+#include "barretenberg/proof_system/relations/lookup_relation.hpp"
+#include "barretenberg/proof_system/relations/permutation_relation.hpp"
+#include "barretenberg/proof_system/relations/ultra_arithmetic_relation.hpp"
+#include <gtest/gtest.h>
+
+using namespace proof_system;
+
+namespace proof_system::ultra_relation_consistency_tests {
+
+using FF = barretenberg::fr;
+struct InputElements {
+    static constexpr size_t NUM_ELEMENTS = 43;
+    std::array<FF, NUM_ELEMENTS> _data;
+
+    static InputElements get_random()
+    {
+        InputElements result;
+        std::generate(result._data.begin(), result._data.end(), [] { return FF::random_element(); });
+        return result;
+    }
+
+    static InputElements get_special() // use non-random values
+    {
+        InputElements result;
+        FF idx = 0;
+        std::generate(result._data.begin(), result._data.end(), [&] {
+            idx += FF(1);
+            return idx;
+        });
+        return result;
+    }
+
+    FF& q_c = std::get<0>(_data);
+    FF& q_l = std::get<1>(_data);
+    FF& q_r = std::get<2>(_data);
+    FF& q_o = std::get<3>(_data);
+    FF& q_4 = std::get<4>(_data);
+    FF& q_m = std::get<5>(_data);
+    FF& q_arith = std::get<6>(_data);
+    FF& q_sort = std::get<7>(_data);
+    FF& q_elliptic = std::get<8>(_data);
+    FF& q_aux = std::get<9>(_data);
+    FF& q_lookup = std::get<10>(_data);
+    FF& sigma_1 = std::get<11>(_data);
+    FF& sigma_2 = std::get<12>(_data);
+    FF& sigma_3 = std::get<13>(_data);
+    FF& sigma_4 = std::get<14>(_data);
+    FF& id_1 = std::get<15>(_data);
+    FF& id_2 = std::get<16>(_data);
+    FF& id_3 = std::get<17>(_data);
+    FF& id_4 = std::get<18>(_data);
+    FF& table_1 = std::get<19>(_data);
+    FF& table_2 = std::get<20>(_data);
+    FF& table_3 = std::get<21>(_data);
+    FF& table_4 = std::get<22>(_data);
+    FF& lagrange_first = std::get<23>(_data);
+    FF& lagrange_last = std::get<24>(_data);
+    FF& w_l = std::get<25>(_data);
+    FF& w_r = std::get<26>(_data);
+    FF& w_o = std::get<27>(_data);
+    FF& w_4 = std::get<28>(_data);
+    FF& sorted_accum = std::get<29>(_data);
+    FF& z_perm = std::get<30>(_data);
+    FF& z_lookup = std::get<31>(_data);
+    FF& table_1_shift = std::get<32>(_data);
+    FF& table_2_shift = std::get<33>(_data);
+    FF& table_3_shift = std::get<34>(_data);
+    FF& table_4_shift = std::get<35>(_data);
+    FF& w_l_shift = std::get<36>(_data);
+    FF& w_r_shift = std::get<37>(_data);
+    FF& w_o_shift = std::get<38>(_data);
+    FF& w_4_shift = std::get<39>(_data);
+    FF& sorted_accum_shift = std::get<40>(_data);
+    FF& z_perm_shift = std::get<41>(_data);
+    FF& z_lookup_shift = std::get<42>(_data);
+};
+
+class UltraRelationConsistency : public testing::Test {
+  public:
+    template <typename Relation>
+    static void validate_relation_execution(const auto& expected_values,
+                                            const InputElements& input_elements,
+                                            const auto& parameters)
+    {
+        typename Relation::RelationValues accumulator;
+        std::fill(accumulator.begin(), accumulator.end(), FF(0));
+        Relation::add_full_relation_value_contribution(accumulator, input_elements, parameters);
+        EXPECT_EQ(accumulator, expected_values);
+    };
+};
+
+TEST_F(UltraRelationConsistency, UltraArithmeticRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = UltraArithmeticRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_1 = input_elements.w_l;
+        const auto& w_1_shift = input_elements.w_l_shift;
+        const auto& w_2 = input_elements.w_r;
+        const auto& w_3 = input_elements.w_o;
+        const auto& w_4 = input_elements.w_4;
+        const auto& w_4_shift = input_elements.w_4_shift;
+        const auto& q_m = input_elements.q_m;
+        const auto& q_l = input_elements.q_l;
+        const auto& q_r = input_elements.q_r;
+        const auto& q_o = input_elements.q_o;
+        const auto& q_4 = input_elements.q_4;
+        const auto& q_c = input_elements.q_c;
+        const auto& q_arith = input_elements.q_arith;
+
+        RelationValues expected_values;
+        static const FF neg_half = FF(-2).invert();
+
+        // Contribution 1
+        auto contribution_1 = (q_arith - 3) * (q_m * w_2 * w_1) * neg_half;
+        contribution_1 += (q_l * w_1) + (q_r * w_2) + (q_o * w_3) + (q_4 * w_4) + q_c;
+        contribution_1 += (q_arith - 1) * w_4_shift;
+        contribution_1 *= q_arith;
+        expected_values[0] = contribution_1;
+
+        // Contribution 2
+        auto contribution_2 = (w_1 + w_4 - w_1_shift + q_m);
+        contribution_2 *= (q_arith - 2) * (q_arith - 1) * q_arith;
+        expected_values[1] = contribution_2;
+
+        const auto parameters = RelationParameters<FF>::get_random();
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+TEST_F(UltraRelationConsistency, UltraPermutationRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = UltraPermutationRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_1 = input_elements.w_l;
+        const auto& w_2 = input_elements.w_r;
+        const auto& w_3 = input_elements.w_o;
+        const auto& w_4 = input_elements.w_4;
+        const auto& sigma_1 = input_elements.sigma_1;
+        const auto& sigma_2 = input_elements.sigma_2;
+        const auto& sigma_3 = input_elements.sigma_3;
+        const auto& sigma_4 = input_elements.sigma_4;
+        const auto& id_1 = input_elements.id_1;
+        const auto& id_2 = input_elements.id_2;
+        const auto& id_3 = input_elements.id_3;
+        const auto& id_4 = input_elements.id_4;
+        const auto& z_perm = input_elements.z_perm;
+        const auto& z_perm_shift = input_elements.z_perm_shift;
+        const auto& lagrange_first = input_elements.lagrange_first;
+        const auto& lagrange_last = input_elements.lagrange_last;
+
+        RelationValues expected_values;
+
+        const auto parameters = RelationParameters<FF>::get_random();
+        const auto& beta = parameters.beta;
+        const auto& gamma = parameters.gamma;
+        const auto& public_input_delta = parameters.public_input_delta;
+
+        // Contribution 1
+        auto contribution_1 = (z_perm + lagrange_first) * (w_1 + id_1 * beta + gamma) * (w_2 + id_2 * beta + gamma) *
+                                  (w_3 + id_3 * beta + gamma) * (w_4 + id_4 * beta + gamma) -
+                              (z_perm_shift + lagrange_last * public_input_delta) * (w_1 + sigma_1 * beta + gamma) *
+                                  (w_2 + sigma_2 * beta + gamma) * (w_3 + sigma_3 * beta + gamma) *
+                                  (w_4 + sigma_4 * beta + gamma);
+        expected_values[0] = contribution_1;
+
+        // Contribution 2
+        auto contribution_2 = z_perm_shift * lagrange_last;
+        expected_values[1] = contribution_2;
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+TEST_F(UltraRelationConsistency, LookupRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = LookupRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_1 = input_elements.w_l;
+        const auto& w_2 = input_elements.w_r;
+        const auto& w_3 = input_elements.w_o;
+
+        const auto& w_1_shift = input_elements.w_l_shift;
+        const auto& w_2_shift = input_elements.w_r_shift;
+        const auto& w_3_shift = input_elements.w_o_shift;
+
+        const auto& table_1 = input_elements.table_1;
+        const auto& table_2 = input_elements.table_2;
+        const auto& table_3 = input_elements.table_3;
+        const auto& table_4 = input_elements.table_4;
+
+        const auto& table_1_shift = input_elements.table_1_shift;
+        const auto& table_2_shift = input_elements.table_2_shift;
+        const auto& table_3_shift = input_elements.table_3_shift;
+        const auto& table_4_shift = input_elements.table_4_shift;
+
+        const auto& s_accum = input_elements.sorted_accum;
+        const auto& s_accum_shift = input_elements.sorted_accum_shift;
+        const auto& z_lookup = input_elements.z_lookup;
+        const auto& z_lookup_shift = input_elements.z_lookup_shift;
+
+        const auto& table_index = input_elements.q_o;
+        const auto& column_1_step_size = input_elements.q_r;
+        const auto& column_2_step_size = input_elements.q_m;
+        const auto& column_3_step_size = input_elements.q_c;
+        const auto& q_lookup = input_elements.q_lookup;
+
+        const auto& lagrange_first = input_elements.lagrange_first;
+        const auto& lagrange_last = input_elements.lagrange_last;
+
+        RelationValues expected_values;
+
+        const auto parameters = RelationParameters<FF>::get_random();
+
+        const auto eta = parameters.eta;
+        const auto beta = parameters.beta;
+        const auto gamma = parameters.gamma;
+        auto grand_product_delta = parameters.lookup_grand_product_delta;
+
+        // Extract the extended edges for manual computation of relation contribution
+        auto one_plus_beta = FF::one() + beta;
+        auto gamma_by_one_plus_beta = gamma * one_plus_beta;
+        auto eta_sqr = eta * eta;
+        auto eta_cube = eta_sqr * eta;
+
+        auto wire_accum = (w_1 + column_1_step_size * w_1_shift) + (w_2 + column_2_step_size * w_2_shift) * eta +
+                          (w_3 + column_3_step_size * w_3_shift) * eta_sqr + table_index * eta_cube;
+
+        auto table_accum = table_1 + table_2 * eta + table_3 * eta_sqr + table_4 * eta_cube;
+        auto table_accum_shift =
+            table_1_shift + table_2_shift * eta + table_3_shift * eta_sqr + table_4_shift * eta_cube;
+
+        // Contribution 1
+        auto contribution_1 = (z_lookup + lagrange_first) * (q_lookup * wire_accum + gamma) *
+                              (table_accum + table_accum_shift * beta + gamma_by_one_plus_beta) * one_plus_beta;
+        contribution_1 -= (z_lookup_shift + lagrange_last * grand_product_delta) *
+                          (s_accum + s_accum_shift * beta + gamma_by_one_plus_beta);
+        expected_values[0] = contribution_1;
+
+        // Contribution 2
+        auto contribution_2 = z_lookup_shift * lagrange_last;
+        expected_values[1] = contribution_2;
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+TEST_F(UltraRelationConsistency, GenPermSortRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = GenPermSortRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_1 = input_elements.w_l;
+        const auto& w_2 = input_elements.w_r;
+        const auto& w_3 = input_elements.w_o;
+        const auto& w_4 = input_elements.w_4;
+        const auto& w_1_shift = input_elements.w_l_shift;
+        const auto& q_sort = input_elements.q_sort;
+
+        auto delta_1 = w_2 - w_1;
+        auto delta_2 = w_3 - w_2;
+        auto delta_3 = w_4 - w_3;
+        auto delta_4 = w_1_shift - w_4;
+
+        auto contribution_1 = delta_1 * (delta_1 - 1) * (delta_1 - 2) * (delta_1 - 3);
+        auto contribution_2 = delta_2 * (delta_2 - 1) * (delta_2 - 2) * (delta_2 - 3);
+        auto contribution_3 = delta_3 * (delta_3 - 1) * (delta_3 - 2) * (delta_3 - 3);
+        auto contribution_4 = delta_4 * (delta_4 - 1) * (delta_4 - 2) * (delta_4 - 3);
+
+        RelationValues expected_values;
+
+        expected_values[0] = contribution_1 * q_sort;
+        expected_values[1] = contribution_2 * q_sort;
+        expected_values[2] = contribution_3 * q_sort;
+        expected_values[3] = contribution_4 * q_sort;
+
+        const auto parameters = RelationParameters<FF>::get_random();
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+TEST_F(UltraRelationConsistency, EllipticRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = EllipticRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& x_1 = input_elements.w_r;
+        const auto& y_1 = input_elements.w_o;
+
+        const auto& x_2 = input_elements.w_l_shift;
+        const auto& y_2 = input_elements.w_4_shift;
+        const auto& x_3 = input_elements.w_r_shift;
+        const auto& y_3 = input_elements.w_o_shift;
+
+        const auto& q_sign = input_elements.q_l;
+        const auto& q_beta = input_elements.q_o;
+        const auto& q_beta_sqr = input_elements.q_4;
+        const auto& q_elliptic = input_elements.q_elliptic;
+
+        RelationValues expected_values;
+        // Compute x/y coordinate identities
+
+        // Contribution 1
+        auto x_identity = q_sign * (y_1 * y_2 * 2);
+        x_identity += q_beta * (x_1 * x_2 * x_3 * 2 + x_1 * x_1 * x_2) * FF(-1);
+        x_identity += q_beta_sqr * (x_2 * x_2 * x_3 - x_1 * x_2 * x_2);
+        x_identity += (x_1 * x_1 * x_3 - y_2 * y_2 - y_1 * y_1 + x_2 * x_2 * x_2 + x_1 * x_1 * x_1);
+
+        // Contribution 2
+        auto y_identity = q_sign * (y_2 * x_3 - y_2 * x_1);
+        y_identity += q_beta * (x_2 * y_3 + y_1 * x_2);
+        y_identity += (x_1 * y_1 - x_1 * y_3 - y_1 * x_3 - x_1 * y_1);
+
+        expected_values[0] = x_identity * q_elliptic;
+        expected_values[1] = y_identity * q_elliptic;
+
+        const auto parameters = RelationParameters<FF>::get_random();
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+TEST_F(UltraRelationConsistency, AuxiliaryRelation)
+{
+    const auto run_test = [](bool random_inputs) {
+        using Relation = AuxiliaryRelation<FF>;
+        using RelationValues = typename Relation::RelationValues;
+
+        const InputElements input_elements = random_inputs ? InputElements::get_random() : InputElements::get_special();
+        const auto& w_1 = input_elements.w_l;
+        const auto& w_2 = input_elements.w_r;
+        const auto& w_3 = input_elements.w_o;
+        const auto& w_4 = input_elements.w_4;
+        const auto& w_1_shift = input_elements.w_l_shift;
+        const auto& w_2_shift = input_elements.w_r_shift;
+        const auto& w_3_shift = input_elements.w_o_shift;
+        const auto& w_4_shift = input_elements.w_4_shift;
+
+        const auto& q_1 = input_elements.q_l;
+        const auto& q_2 = input_elements.q_r;
+        const auto& q_3 = input_elements.q_o;
+        const auto& q_4 = input_elements.q_4;
+        const auto& q_m = input_elements.q_m;
+        const auto& q_c = input_elements.q_c;
+        const auto& q_arith = input_elements.q_arith;
+        const auto& q_aux = input_elements.q_aux;
+
+        constexpr FF LIMB_SIZE(uint256_t(1) << 68);
+        constexpr FF SUBLIMB_SHIFT(uint256_t(1) << 14);
+        constexpr FF SUBLIMB_SHIFT_2(SUBLIMB_SHIFT * SUBLIMB_SHIFT);
+        constexpr FF SUBLIMB_SHIFT_3(SUBLIMB_SHIFT_2 * SUBLIMB_SHIFT);
+        constexpr FF SUBLIMB_SHIFT_4(SUBLIMB_SHIFT_3 * SUBLIMB_SHIFT);
+
+        const auto parameters = RelationParameters<FF>::get_random();
+        const auto& eta = parameters.eta;
+
+        RelationValues expected_values;
+        /**
+         * Non native field arithmetic gate 2
+         *
+         *             _                                                                               _
+         *            /   _                   _                               _       14                \
+         * q_2 . q_4 |   (w_1 . w_2) + (w_1 . w_2) + (w_1 . w_4 + w_2 . w_3 - w_3) . 2    - w_3 - w_4   |
+         *            \_                                                                               _/
+         *
+         **/
+        auto limb_subproduct = w_1 * w_2_shift + w_1_shift * w_2;
+        auto non_native_field_gate_2 = (w_1 * w_4 + w_2 * w_3 - w_3_shift);
+        non_native_field_gate_2 *= LIMB_SIZE;
+        non_native_field_gate_2 -= w_4_shift;
+        non_native_field_gate_2 += limb_subproduct;
+
+        limb_subproduct *= LIMB_SIZE;
+        limb_subproduct += (w_1_shift * w_2_shift);
+        auto non_native_field_gate_1 = limb_subproduct;
+        non_native_field_gate_1 -= (w_3 + w_4);
+
+        auto non_native_field_gate_3 = limb_subproduct;
+        non_native_field_gate_3 += w_4;
+        non_native_field_gate_3 -= (w_3_shift + w_4_shift);
+
+        auto non_native_field_identity = q_2 * q_3 * non_native_field_gate_1;
+        non_native_field_identity += q_2 * q_4 * non_native_field_gate_2;
+        non_native_field_identity += q_2 * q_m * non_native_field_gate_3;
+
+        auto limb_accumulator_1 = w_1 + w_2 * SUBLIMB_SHIFT + w_3 * SUBLIMB_SHIFT_2 + w_1_shift * SUBLIMB_SHIFT_3 +
+                                  w_2_shift * SUBLIMB_SHIFT_4 - w_4;
+
+        auto limb_accumulator_2 = w_3 + w_4 * SUBLIMB_SHIFT + w_1_shift * SUBLIMB_SHIFT_2 +
+                                  w_2_shift * SUBLIMB_SHIFT_3 + w_3_shift * SUBLIMB_SHIFT_4 - w_4_shift;
+
+        auto limb_accumulator_identity = q_3 * q_4 * limb_accumulator_1;
+        limb_accumulator_identity += q_3 * q_m * limb_accumulator_2;
+
+        /**
+         * MEMORY
+         **/
+
+        /**
+         * Memory Record Check
+         */
+        auto memory_record_check = w_3;
+        memory_record_check *= eta;
+        memory_record_check += w_2;
+        memory_record_check *= eta;
+        memory_record_check += w_1;
+        memory_record_check *= eta;
+        memory_record_check += q_c;
+        auto partial_record_check = memory_record_check; // used in RAM consistency check
+        memory_record_check = memory_record_check - w_4;
+
+        /**
+         * ROM Consistency Check
+         */
+        auto index_delta = w_1_shift - w_1;
+        auto record_delta = w_4_shift - w_4;
+
+        auto index_is_monotonically_increasing = index_delta * index_delta - index_delta;
+
+        // auto adjacent_values_match_if_adjacent_indices_match = (FF(1) - index_delta) * record_delta;
+        auto adjacent_values_match_if_adjacent_indices_match = (index_delta * FF(-1) + FF(1)) * record_delta;
+
+        expected_values[1] = adjacent_values_match_if_adjacent_indices_match * (q_1 * q_2);
+        expected_values[2] = index_is_monotonically_increasing * (q_1 * q_2);
+        auto ROM_consistency_check_identity = memory_record_check * (q_1 * q_2);
+
+        /**
+         * RAM Consistency Check
+         */
+        auto access_type = (w_4 - partial_record_check);             // will be 0 or 1 for honest Prover
+        auto access_check = access_type * access_type - access_type; // check value is 0 or 1
+
+        auto next_gate_access_type = w_3_shift;
+        next_gate_access_type *= eta;
+        next_gate_access_type += w_2_shift;
+        next_gate_access_type *= eta;
+        next_gate_access_type += w_1_shift;
+        next_gate_access_type *= eta;
+        next_gate_access_type = w_4_shift - next_gate_access_type;
+
+        auto value_delta = w_3_shift - w_3;
+        auto adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation =
+            (index_delta * FF(-1) + FF(1)) * value_delta * (next_gate_access_type * FF(-1) + FF(1));
+
+        // We can't apply the RAM consistency check identity on the final entry in the sorted list (the wires in the
+        // next gate would make the identity fail). We need to validate that its 'access type' bool is correct. Can't do
+        // with an arithmetic gate because of the `eta` factors. We need to check that the *next* gate's access type is
+        // correct, to cover this edge case
+        auto next_gate_access_type_is_boolean = next_gate_access_type * next_gate_access_type - next_gate_access_type;
+
+        // Putting it all together...
+        expected_values[3] =
+            adjacent_values_match_if_adjacent_indices_match_and_next_access_is_a_read_operation * (q_arith);
+        expected_values[4] = index_is_monotonically_increasing * (q_arith);
+        expected_values[5] = next_gate_access_type_is_boolean * (q_arith);
+        auto RAM_consistency_check_identity = access_check * (q_arith);
+
+        /**
+         * RAM/ROM access check gate
+         */
+        memory_record_check *= (q_1 * q_m);
+
+        /**
+         * RAM Timestamp Consistency Check
+         */
+        auto timestamp_delta = w_2_shift - w_2;
+        auto RAM_timestamp_check_identity = (index_delta * FF(-1) + FF(1)) * timestamp_delta - w_3;
+        RAM_timestamp_check_identity *= (q_1 * q_4);
+
+        /**
+         * The complete RAM/ROM memory identity
+         */
+        auto memory_identity = ROM_consistency_check_identity;
+        memory_identity += RAM_timestamp_check_identity;
+        memory_identity += memory_record_check;
+        memory_identity += RAM_consistency_check_identity;
+
+        expected_values[0] = memory_identity + non_native_field_identity + limb_accumulator_identity;
+        expected_values[0] *= q_aux;
+        expected_values[1] *= q_aux;
+        expected_values[2] *= q_aux;
+        expected_values[3] *= q_aux;
+        expected_values[4] *= q_aux;
+        expected_values[5] *= q_aux;
+
+        validate_relation_execution<Relation>(expected_values, input_elements, parameters);
+    };
+    run_test(/*random_inputs=*/false);
+    run_test(/*random_inputs=*/true);
+};
+
+} // namespace proof_system::ultra_relation_consistency_tests
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.hpp
index 697aa34ea19..4adb5c0fceb 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.hpp
@@ -3,7 +3,8 @@
 #include "barretenberg/ecc/curves/bn254/fq.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
 #include "barretenberg/honk/transcript/transcript.hpp"
 
 #include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.test.cpp
index f32032e499b..9611368117c 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/transcript/transcript.test.cpp
@@ -4,8 +4,8 @@
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
 #include "barretenberg/honk/flavor/ultra.hpp"
 #include "barretenberg/honk/flavor/ultra_recursive.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
 #include "barretenberg/honk/transcript/transcript.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "barretenberg/stdlib/recursion/honk/transcript/transcript.hpp"
 
 namespace proof_system::plonk::stdlib::recursion::honk {
@@ -27,7 +27,7 @@ template <class Flavor, size_t LENGTH> auto generate_mock_proof_data(auto prover
 {
     using FF = typename Flavor::FF;
     using Commitment = typename Flavor::Commitment;
-    using Univariate = typename proof_system::honk::sumcheck::Univariate<FF, LENGTH>;
+    using Univariate = typename barretenberg::Univariate<FF, LENGTH>;
 
     // Create some mock data to be added to the transcript in several mock rounds
     uint32_t data = 25;
@@ -69,7 +69,7 @@ template <class Flavor, size_t LENGTH> void perform_mock_verifier_transcript_ope
 {
     using FF = typename Flavor::FF;
     using Commitment = typename Flavor::Commitment;
-    using Univariate = typename proof_system::honk::sumcheck::Univariate<FF, LENGTH>;
+    using Univariate = typename barretenberg::Univariate<FF, LENGTH>;
 
     // round 0
     transcript.template receive_from_prover<uint32_t>("data");
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.cpp
index bac2b058946..323b4a2800f 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/recursion/honk/verifier/ultra_recursive_verifier.cpp
@@ -30,7 +30,7 @@ std::array<typename Flavor::GroupElement, 2> UltraRecursiveVerifier_<Flavor, gob
     using KZG = ::proof_system::honk::pcs::kzg::KZG<Curve, goblin_flag>; // note: This can only be KZG
     using VerifierCommitments = typename Flavor::VerifierCommitments;
     using CommitmentLabels = typename Flavor::CommitmentLabels;
-    using RelationParams = ::proof_system::honk::sumcheck::RelationParameters<FF>;
+    using RelationParams = ::proof_system::RelationParameters<FF>;
 
     RelationParams relation_parameters;
 
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/utility/utility.hpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/utility/utility.hpp
index 0031ef3231a..e17926fa47d 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/utility/utility.hpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/stdlib/utility/utility.hpp
@@ -3,7 +3,8 @@
 #include "barretenberg/ecc/curves/bn254/fq.hpp"
 #include "barretenberg/ecc/curves/bn254/fr.hpp"
 #include "barretenberg/ecc/curves/bn254/g1.hpp"
-#include "barretenberg/honk/sumcheck/polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
+
 #include "barretenberg/honk/transcript/transcript.hpp"
 
 #include "barretenberg/stdlib/primitives/bigfield/bigfield.hpp"
@@ -28,8 +29,8 @@ template <typename Builder> class StdlibTypesUtility {
     using element_ct = element<Builder, fq_ct, field_ct, barretenberg::g1>;
     using FF = barretenberg::fr;
     using Commitment = barretenberg::g1::affine_element;
-    template <size_t LENGTH> using Univariate = proof_system::honk::sumcheck::Univariate<FF, LENGTH>;
-    template <size_t LENGTH> using Univariate_ct = proof_system::honk::sumcheck::Univariate<field_ct, LENGTH>;
+    template <size_t LENGTH> using Univariate = barretenberg::Univariate<FF, LENGTH>;
+    template <size_t LENGTH> using Univariate_ct = barretenberg::Univariate<field_ct, LENGTH>;
 
   public:
     /**
diff --git a/circuits/cpp/barretenberg/cpp/src/barretenberg/transcript/transcript.test.cpp b/circuits/cpp/barretenberg/cpp/src/barretenberg/transcript/transcript.test.cpp
index 0603a7e2207..6489f90d014 100644
--- a/circuits/cpp/barretenberg/cpp/src/barretenberg/transcript/transcript.test.cpp
+++ b/circuits/cpp/barretenberg/cpp/src/barretenberg/transcript/transcript.test.cpp
@@ -1,4 +1,4 @@
-#include "../honk/sumcheck/polynomials/univariate.hpp"
+#include "barretenberg/polynomials/univariate.hpp"
 #include "transcript_wrappers.hpp"
 #include <cstddef>
 #include <cstdint>
@@ -136,7 +136,7 @@ TEST(transcript, univariate_serialization)
     constexpr size_t LENGTH = 8;
 
     using Fr = barretenberg::fr;
-    using Univariate = proof_system::honk::sumcheck::Univariate<Fr, LENGTH>;
+    using Univariate = barretenberg::Univariate<Fr, LENGTH>;
     using Transcript = transcript::StandardTranscript;
 
     std::vector<uint8_t> g1_vector(64);