a16z
diff --git a/‎examples/merkle-tree/src/main.rs‎
Lines changed: 2 additions & 1 deletion b/‎examples/merkle-tree/src/main.rs‎
Lines changed: 2 additions & 1 deletion
diff --git a/‎examples/recursion/src/main.rs‎
Lines changed: 2 additions & 0 deletions b/‎examples/recursion/src/main.rs‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎jolt-core/benches/commit.rs‎
Lines changed: 4 additions & 4 deletions b/‎jolt-core/benches/commit.rs‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎jolt-core/benches/e2e_profiling.rs‎
Lines changed: 6 additions & 4 deletions b/‎jolt-core/benches/e2e_profiling.rs‎
Lines changed: 6 additions & 4 deletions
diff --git a/‎jolt-core/src/guest/prover.rs‎
Lines changed: 6 additions & 3 deletions b/‎jolt-core/src/guest/prover.rs‎
Lines changed: 6 additions & 3 deletions
diff --git a/‎jolt-core/src/guest/verifier.rs‎
Lines changed: 3 additions & 1 deletion b/‎jolt-core/src/guest/verifier.rs‎
Lines changed: 3 additions & 1 deletion
diff --git a/‎jolt-core/src/poly/commitment/dory/commitment_scheme.rs‎
Lines changed: 5 additions & 0 deletions b/‎jolt-core/src/poly/commitment/dory/commitment_scheme.rs‎
Lines changed: 5 additions & 0 deletions
diff --git a/‎jolt-core/src/poly/commitment/dory/dory_globals.rs‎
Lines changed: 50 additions & 23 deletions b/‎jolt-core/src/poly/commitment/dory/dory_globals.rs‎
Lines changed: 50 additions & 23 deletions
diff --git a/‎jolt-core/src/poly/commitment/dory/tests.rs‎
Lines changed: 6 additions & 5 deletions b/‎jolt-core/src/poly/commitment/dory/tests.rs‎
Lines changed: 6 additions & 5 deletions
diff --git a/‎jolt-core/src/poly/eq_poly.rs‎
Lines changed: 22 additions & 0 deletions b/‎jolt-core/src/poly/eq_poly.rs‎
Lines changed: 22 additions & 0 deletions
@@ -20,7 +20,7 @@ pub fn main() {
     let leaf3 = [7u8; 32];
     let leaf4 = [8u8; 32];
 
-    let (trusted_advice_commitment, _hint) = guest::commit_trusted_advice_merkle_tree(
+    let (trusted_advice_commitment, trusted_advice_hint) = guest::commit_trusted_advice_merkle_tree(
         TrustedAdvice::new(leaf2),
         TrustedAdvice::new(leaf3),
         &prover_preprocessing,
@@ -36,6 +36,7 @@ pub fn main() {
         TrustedAdvice::new(leaf3),
         UntrustedAdvice::new(leaf4),
         trusted_advice_commitment,
+        trusted_advice_hint,
     );
     info!("Prover runtime: {} s", now.elapsed().as_secs_f64());
 
 
@@ -338,6 +338,7 @@ fn collect_guest_proofs(guest: GuestProgram, target_dir: &str, use_embed: bool)
             &[],
             &[],
             None,
+            None,
             &mut output_bytes,
             &guest_prover_preprocessing,
         );
@@ -511,6 +512,7 @@ fn run_recursion_proof(
                 &[],
                 &[],
                 None,
+                None,
                 &mut output_bytes,
                 &recursion_prover_preprocessing,
             );
 
@@ -1,6 +1,6 @@
 use criterion::Criterion;
 use jolt_core::poly::commitment::commitment_scheme::CommitmentScheme;
-use jolt_core::poly::commitment::dory::{DoryCommitmentScheme, DoryGlobals};
+use jolt_core::poly::commitment::dory::{DoryCommitmentScheme, DoryContext, DoryGlobals};
 use jolt_core::poly::multilinear_polynomial::MultilinearPolynomial;
 use jolt_core::utils::math::Math;
 use rand::Rng;
@@ -9,7 +9,7 @@ use rand_core::{RngCore, SeedableRng};
 // use rayon::prelude::*;
 
 fn benchmark_dory_dense(c: &mut Criterion, name: &str, k: usize, t: usize) {
-    let globals = DoryGlobals::initialize(k, t);
+    let globals = DoryGlobals::initialize_context(k, t, DoryContext::Main);
     let setup = <DoryCommitmentScheme as CommitmentScheme>::setup_prover(k.log_2() + t.log_2());
     let mut rng = ChaCha20Rng::seed_from_u64(111111u64);
 
@@ -26,7 +26,7 @@ fn benchmark_dory_dense(c: &mut Criterion, name: &str, k: usize, t: usize) {
 }
 
 fn benchmark_dory_one_hot_batch(c: &mut Criterion, name: &str, k: usize, t: usize) {
-    let globals = DoryGlobals::initialize(k, t);
+    let globals = DoryGlobals::initialize_context(k, t, DoryContext::Main);
     let setup = <DoryCommitmentScheme as CommitmentScheme>::setup_prover(k.log_2() + t.log_2());
     let mut rng = ChaCha20Rng::seed_from_u64(111111u64);
 
@@ -52,7 +52,7 @@ fn benchmark_dory_one_hot_batch(c: &mut Criterion, name: &str, k: usize, t: usiz
 }
 
 fn benchmark_dory_mixed_batch(c: &mut Criterion, name: &str, k: usize, t: usize) {
-    let globals = DoryGlobals::initialize(k, t);
+    let globals = DoryGlobals::initialize_context(k, t, DoryContext::Main);
     let setup = <DoryCommitmentScheme as CommitmentScheme>::setup_prover(k.log_2() + t.log_2());
     let mut rng = ChaCha20Rng::seed_from_u64(111111u64);
 
 
@@ -211,9 +211,9 @@ fn prove_example(
             bytecode,
             program_io.memory_layout.clone(),
             init_memory_state,
+            padded_trace_len,
         );
-        let preprocessing =
-            JoltProverPreprocessing::new(shared_preprocessing.clone(), padded_trace_len);
+        let preprocessing = JoltProverPreprocessing::new(shared_preprocessing.clone());
 
         let elf_contents_opt = program.get_elf_contents();
         let elf_contents = elf_contents_opt.as_deref().expect("elf contents is None");
@@ -224,6 +224,7 @@ fn prove_example(
             &[],
             &[],
             None,
+            None,
         );
         let program_io = prover.program_io.clone();
         let (jolt_proof, _) = prover.prove();
@@ -266,9 +267,9 @@ fn prove_example_with_trace(
         bytecode.clone(),
         program_io.memory_layout.clone(),
         init_memory_state,
+        trace.len().next_power_of_two(),
     );
-    let preprocessing =
-        JoltProverPreprocessing::new(shared_preprocessing, trace.len().next_power_of_two());
+    let preprocessing = JoltProverPreprocessing::new(shared_preprocessing);
 
     let elf_contents_opt = program.get_elf_contents();
     let elf_contents = elf_contents_opt.as_deref().expect("elf contents is None");
@@ -281,6 +282,7 @@ fn prove_example_with_trace(
         &[],
         &[],
         None,
+        None,
     );
     let now = Instant::now();
     let (jolt_proof, _) = prover.prove();
 
@@ -23,18 +23,20 @@ pub fn preprocess(
     let mut memory_config = guest.memory_config;
     memory_config.program_size = Some(program_size);
     let memory_layout = MemoryLayout::new(&memory_config);
-    let shared_preprocessing = JoltSharedPreprocessing::new(bytecode, memory_layout, memory_init);
-    JoltProverPreprocessing::new(shared_preprocessing, max_trace_length)
+    let shared_preprocessing =
+        JoltSharedPreprocessing::new(bytecode, memory_layout, memory_init, max_trace_length);
+    JoltProverPreprocessing::new(shared_preprocessing)
 }
 
-#[allow(clippy::type_complexity)]
+#[allow(clippy::type_complexity, clippy::too_many_arguments)]
 #[cfg(feature = "prover")]
 pub fn prove<F: JoltField, PCS: StreamingCommitmentScheme<Field = F>, FS: Transcript>(
     guest: &Program,
     inputs_bytes: &[u8],
     untrusted_advice_bytes: &[u8],
     trusted_advice_bytes: &[u8],
     trusted_advice_commitment: Option<<PCS as CommitmentScheme>::Commitment>,
+    trusted_advice_hint: Option<<PCS as CommitmentScheme>::OpeningProofHint>,
     output_bytes: &mut [u8],
     preprocessing: &JoltProverPreprocessing<F, PCS>,
 ) -> (
@@ -51,6 +53,7 @@ pub fn prove<F: JoltField, PCS: StreamingCommitmentScheme<Field = F>, FS: Transc
         untrusted_advice_bytes,
         trusted_advice_bytes,
         trusted_advice_commitment,
+        trusted_advice_hint,
     );
     let io_device = prover.program_io.clone();
     let (proof, debug_info) = prover.prove();
 
@@ -15,14 +15,16 @@ use common::jolt_device::MemoryLayout;
 
 pub fn preprocess(
     guest: &Program,
+    max_trace_length: usize,
     verifier_setup: <DoryCommitmentScheme as CommitmentScheme>::VerifierSetup,
 ) -> JoltVerifierPreprocessing<ark_bn254::Fr, DoryCommitmentScheme> {
     let (bytecode, memory_init, program_size) = guest.decode();
 
     let mut memory_config = guest.memory_config;
     memory_config.program_size = Some(program_size);
     let memory_layout = MemoryLayout::new(&memory_config);
-    let shared = JoltSharedPreprocessing::new(bytecode, memory_layout, memory_init);
+    let shared =
+        JoltSharedPreprocessing::new(bytecode, memory_layout, memory_init, max_trace_length);
     JoltVerifierPreprocessing::new(shared, verifier_setup)
 }
 
 
@@ -48,6 +48,11 @@ impl CommitmentScheme for DoryCommitmentScheme {
         let mut rng = ChaCha20Rng::from_seed(seed);
         let setup = ArkworksProverSetup::new_from_urs(&mut rng, max_num_vars);
 
+        // The prepared-point cache in dory-pcs is global and can only be initialized once.
+        // In unit tests, multiple setups with different sizes are created, so initializing the
+        // cache with a small setup can break later tests that need more generators.
+        // We therefore disable cache initialization in `cfg(test)` builds.
+        #[cfg(not(test))]
         DoryGlobals::init_prepared_cache(&setup.g1_vec, &setup.g2_vec);
 
         setup
 
@@ -58,6 +58,45 @@ impl Drop for DoryContextGuard {
 pub struct DoryGlobals;
 
 impl DoryGlobals {
+    /// Split `total_vars` into a *balanced* pair `(sigma, nu)` where:
+    /// - **sigma** is the number of **column** variables
+    /// - **nu** is the number of **row** variables
+    ///
+    /// Dory matrices are conceptually shaped as `2^nu` rows × `2^sigma` columns (row-major).
+    /// We use the balanced policy `sigma = ceil(total_vars / 2)` and `nu = total_vars - sigma`.
+    #[inline]
+    pub fn balanced_sigma_nu(total_vars: usize) -> (usize, usize) {
+        let sigma = total_vars.div_ceil(2);
+        let nu = total_vars - sigma;
+        (sigma, nu)
+    }
+
+    /// Convenience helper for the main Dory matrix where `total_vars = log_k_chunk + log_t`.
+    #[inline]
+    pub fn main_sigma_nu(log_k_chunk: usize, log_t: usize) -> (usize, usize) {
+        Self::balanced_sigma_nu(log_k_chunk + log_t)
+    }
+
+    /// Computes balanced `(sigma, nu)` dimensions directly from a max advice byte budget.
+    ///
+    /// - `max_advice_size_bytes` is interpreted as bytes of 64-bit words.
+    /// - Rounds word count up to the next power of two (minimum 1) and computes log2 as `advice_vars`.
+    /// - Returns `(sigma, nu)` where `sigma = ⌈advice_vars/2⌉` and `nu = advice_vars - sigma`.
+    #[inline]
+    pub fn advice_sigma_nu_from_max_bytes(max_advice_size_bytes: usize) -> (usize, usize) {
+        let words = max_advice_size_bytes / 8;
+        let len = words.next_power_of_two().max(1);
+        let advice_vars = len.log_2();
+        Self::balanced_sigma_nu(advice_vars)
+    }
+
+    /// How many row variables of the *cycle* segment exist in the unified point:
+    /// `row_cycle_len = max(0, log_t - sigma_main)`.
+    #[inline]
+    pub fn cycle_row_len(log_t: usize, sigma_main: usize) -> usize {
+        log_t.saturating_sub(sigma_main)
+    }
+
     /// Get the current Dory context
     pub fn current_context() -> DoryContext {
         CURRENT_CONTEXT.load(Ordering::SeqCst).into()
@@ -182,46 +221,34 @@ impl DoryGlobals {
             (side, side)
         } else {
             // Odd total vars: almost square (columns = 2*rows)
-            let sigma = total_vars.div_ceil(2);
-            let nu = total_vars - sigma;
+            let (sigma, nu) = Self::balanced_sigma_nu(total_vars);
             (1 << sigma, 1 << nu)
         };
 
         (num_columns, num_rows, T)
     }
 
-    /// Initialize the globals for the main Dory matrix
+    /// Initialize the globals for a specific Dory context
     ///
     /// # Arguments
     /// * `K` - Maximum address space size (K in OneHot polynomials)
     /// * `T` - Maximum trace length (cycle count)
+    /// * `context` - The Dory context to initialize (Main, TrustedAdvice, or UntrustedAdvice)
     ///
     /// The matrix dimensions are calculated to minimize padding:
     /// - If log2(K*T) is even: creates a square matrix
     /// - If log2(K*T) is odd: creates an almost-square matrix (columns = 2*rows)
-    pub fn initialize(K: usize, T: usize) -> Option<()> {
+    pub fn initialize_context(K: usize, T: usize, context: DoryContext) -> Option<()> {
         let (num_columns, num_rows, t) = Self::calculate_dimensions(K, T);
-        Self::set_num_columns_for_context(num_columns, DoryContext::Main);
-        Self::set_T_for_context(t, DoryContext::Main);
-        Self::set_max_num_rows_for_context(num_rows, DoryContext::Main);
-        Some(())
-    }
+        Self::set_num_columns_for_context(num_columns, context);
+        Self::set_T_for_context(t, context);
+        Self::set_max_num_rows_for_context(num_rows, context);
 
-    /// Initialize the globals for trusted advice commitments
-    pub fn initialize_trusted_advice(K: usize, T: usize) -> Option<()> {
-        let (num_columns, num_rows, t) = Self::calculate_dimensions(K, T);
-        Self::set_num_columns_for_context(num_columns, DoryContext::TrustedAdvice);
-        Self::set_T_for_context(t, DoryContext::TrustedAdvice);
-        Self::set_max_num_rows_for_context(num_rows, DoryContext::TrustedAdvice);
-        Some(())
-    }
+        // For Main context, ensure subsequent uses of `get_*` read from it by default
+        if context == DoryContext::Main {
+            CURRENT_CONTEXT.store(DoryContext::Main as u8, Ordering::SeqCst);
+        }
 
-    /// Initialize the globals for untrusted advice commitments
-    pub fn initialize_untrusted_advice(K: usize, T: usize) -> Option<()> {
-        let (num_columns, num_rows, t) = Self::calculate_dimensions(K, T);
-        Self::set_num_columns_for_context(num_columns, DoryContext::UntrustedAdvice);
-        Self::set_T_for_context(t, DoryContext::UntrustedAdvice);
-        Self::set_max_num_rows_for_context(num_rows, DoryContext::UntrustedAdvice);
         Some(())
     }
 
 
@@ -4,6 +4,7 @@ mod tests {
     use super::super::*;
     use crate::field::JoltField;
     use crate::poly::commitment::commitment_scheme::CommitmentScheme;
+    use crate::poly::commitment::dory::DoryContext;
     use crate::poly::dense_mlpoly::DensePolynomial;
     use crate::poly::multilinear_polynomial::{MultilinearPolynomial, PolynomialEvaluation};
     use crate::transcripts::{Blake2bTranscript, Transcript};
@@ -64,7 +65,7 @@ mod tests {
 
         let num_coeffs = 1 << num_vars;
         // Dense polynomial: K = 1, T = num_coeffs
-        let _guard = DoryGlobals::initialize(1, num_coeffs);
+        let _guard = DoryGlobals::initialize_context(1, num_coeffs, DoryContext::Main);
 
         let prover_setup = DoryCommitmentScheme::setup_prover(num_vars);
         let verifier_setup = DoryCommitmentScheme::setup_verifier(&prover_setup);
@@ -241,7 +242,7 @@ mod tests {
         let num_coeffs = 1 << num_vars;
 
         // Dense polynomial: K = 1, T = num_coeffs
-        let _guard = DoryGlobals::initialize(1, num_coeffs);
+        let _guard = DoryGlobals::initialize_context(1, num_coeffs, DoryContext::Main);
 
         let mut rng = thread_rng();
         let coeffs: Vec<Fr> = (0..num_coeffs).map(|_| Fr::rand(&mut rng)).collect();
@@ -385,7 +386,7 @@ mod tests {
         let K = 8;
         let T = 8;
 
-        let _guard = DoryGlobals::initialize(K, T);
+        let _guard = DoryGlobals::initialize_context(K, T, DoryContext::Main);
 
         let mut rng = thread_rng();
         let nonzero_indices: Vec<Option<u8>> = (0..T)
@@ -450,7 +451,7 @@ mod tests {
         let num_coeffs = 1 << num_vars;
         let num_polys = 5;
 
-        let _guard = DoryGlobals::initialize(1, num_coeffs);
+        let _guard = DoryGlobals::initialize_context(1, num_coeffs, DoryContext::Main);
 
         let mut rng = thread_rng();
 
@@ -534,7 +535,7 @@ mod tests {
         let num_coeffs = 1 << num_vars;
         let num_polys = 5;
 
-        let _guard = DoryGlobals::initialize(1, num_coeffs);
+        let _guard = DoryGlobals::initialize_context(1, num_coeffs, DoryContext::Main);
 
         let mut rng = thread_rng();
 
 
@@ -55,6 +55,28 @@ impl<F: JoltField> EqPolynomial<F> {
         }
     }
 
+    /// Computes the zero selector: `eq(r, [0, 0, ...]) = ∏ᵢ (1 - rᵢ)`.
+    ///
+    /// This is equivalent to `mle(r, &vec![F::zero(); r.len()])` but more efficient
+    /// as it avoids allocating the zeros vector. Commonly used for Lagrange factors
+    /// when computing embeddings (e.g., advice polynomial embeddings in Dory batch openings).
+    ///
+    /// # Mathematical Interpretation
+    /// - `eq(r, 0) = ∏ᵢ (1 - rᵢ)` selects the "all-zeros" vertex of the boolean hypercube
+    /// - Returns 1 when all `rᵢ = 0`, and decays multiplicatively as more bits become non-zero
+    ///
+    /// # Arguments
+    /// - `r`: Point at which to evaluate
+    ///
+    /// # Returns
+    /// The product `∏ᵢ (1 - rᵢ)` over all elements in `r`
+    pub fn zero_selector<C>(r: &[C]) -> F
+    where
+        C: Copy + Send + Sync + Into<F>,
+    {
+        r.par_iter().map(|r_i| F::one() - (*r_i).into()).product()
+    }
+
     #[tracing::instrument(skip_all, name = "EqPolynomial::evals")]
     /// Computes the table of evaluations: `{ eq(r, x) : x ∈ {0, 1}^n }`.
     ///