diff --git a/tachyon/crypto/commitments/fri/two_adic_fri.h b/tachyon/crypto/commitments/fri/two_adic_fri.h
index 83c462a09..0bfbd6ab6 100644
--- a/tachyon/crypto/commitments/fri/two_adic_fri.h
+++ b/tachyon/crypto/commitments/fri/two_adic_fri.h
@@ -336,14 +336,15 @@ class TwoAdicFRI {
     for (size_t round = 0; round < num_rounds; ++round) {
       absl::Span<const Eigen::Map<const math::RowMajorMatrix<F>>> matrices =
           matrices_by_round[round];
-      const OpeningPointsForRound& points = points_by_round[round];
+      const OpeningPointsForRound& points_vec_for_round =
+          points_by_round[round];
       for (size_t i = 0; i < matrices.size(); ++i) {
         const Eigen::Map<const math::RowMajorMatrix<F>>& matrix = matrices[i];
-        const std::vector<ExtF>& point_list = points[i];
+        const std::vector<ExtF>& points_for_mat = points_vec_for_round[i];
         uint32_t log_num_rows =
             base::bits::CheckedLog2(static_cast<uint32_t>(matrix.rows()));
         max_log_num_rows = std::max(max_log_num_rows, log_num_rows);
-        for (const ExtF& point : point_list) {
+        for (const ExtF& point : points_for_mat) {
           const auto [it, inserted] =
               max_log_num_rows_for_point.try_emplace(point, log_num_rows);
           if (!inserted) {
diff --git a/tachyon/math/polynomials/univariate/radix2_evaluation_domain.h b/tachyon/math/polynomials/univariate/radix2_evaluation_domain.h
index 85856c9b5..aafcf3ec4 100644
--- a/tachyon/math/polynomials/univariate/radix2_evaluation_domain.h
+++ b/tachyon/math/polynomials/univariate/radix2_evaluation_domain.h
@@ -113,7 +113,7 @@ class Radix2EvaluationDomain
 
     // For the second half, we flip the DIT, working in bit-reversed order.
     ReverseMatrixIndexBits(mat);
-    RunParallelRowChunksReversed(mat, cache_->rev_roots_vec,
+    RunParallelRowChunksReversed(mat, cache_->bitrev_roots_vec,
                                  cache_->packed_roots_vec[1]);
     ReverseMatrixIndexBits(mat);
   }
@@ -145,7 +145,7 @@ class Radix2EvaluationDomain
 
     // For the second half, we flip the DIT, working in bit-reversed order.
     ReverseMatrixIndexBits(mat);
-    RunParallelRowChunksReversed(mat, cache_->rev_inv_roots_vec,
+    RunParallelRowChunksReversed(mat, cache_->bitrev_inv_roots_vec,
                                  cache_->packed_inv_roots_vec[1]);
     // We skip the final bit-reversal, since the next FFT expects bit-reversed
     // input.
@@ -189,7 +189,7 @@ class Radix2EvaluationDomain
 
     // For the second half, we flip the DIT, working in bit-reversed order.
     ReverseMatrixIndexBits(out);
-    domain->RunParallelRowChunksReversed(out, domain->cache_->rev_roots_vec,
+    domain->RunParallelRowChunksReversed(out, domain->cache_->bitrev_roots_vec,
                                          domain->cache_->packed_roots_vec[1]);
     if (reverse_at_last) {
       ReverseMatrixIndexBits(out);
diff --git a/tachyon/math/polynomials/univariate/radix2_twiddle_cache.h b/tachyon/math/polynomials/univariate/radix2_twiddle_cache.h
index 2dbf6bc3e..4a219b6b1 100644
--- a/tachyon/math/polynomials/univariate/radix2_twiddle_cache.h
+++ b/tachyon/math/polynomials/univariate/radix2_twiddle_cache.h
@@ -27,8 +27,8 @@ class Radix2TwiddleCache {
 
   struct Item {
     // For small prime fields
-    std::vector<F> rev_roots_vec;
-    std::vector<F> rev_inv_roots_vec;
+    std::vector<F> bitrev_roots_vec;
+    std::vector<F> bitrev_inv_roots_vec;
     std::vector<std::vector<PackedPrimeField>> packed_roots_vec;
     std::vector<std::vector<PackedPrimeField>> packed_inv_roots_vec;
     // For all finite fields
@@ -80,16 +80,16 @@ class Radix2TwiddleCache {
         packed_inv_roots_vec[0].resize(vec_largest_size);
         packed_roots_vec[1].resize(vec_largest_size);
         packed_inv_roots_vec[1].resize(vec_largest_size);
-        rev_roots_vec = SwapBitRevElements(largest);
-        rev_inv_roots_vec = SwapBitRevElements(largest_inv);
+        bitrev_roots_vec = SwapBitRevElements(largest);
+        bitrev_inv_roots_vec = SwapBitRevElements(largest_inv);
         OMP_PARALLEL_FOR(size_t i = 0; i < vec_largest_size; ++i) {
           packed_roots_vec[0][i] = PackedPrimeField::Broadcast(largest[i]);
           packed_inv_roots_vec[0][i] =
               PackedPrimeField::Broadcast(largest_inv[i]);
           packed_roots_vec[1][i] =
-              PackedPrimeField::Broadcast(rev_roots_vec[i]);
+              PackedPrimeField::Broadcast(bitrev_roots_vec[i]);
           packed_inv_roots_vec[1][i] =
-              PackedPrimeField::Broadcast(rev_inv_roots_vec[i]);
+              PackedPrimeField::Broadcast(bitrev_inv_roots_vec[i]);
         }
       }