Feat/batched fri per epoch

crypto/stark/src/fri/mod.rs

@@ -1,6 +1,8 @@
+pub mod batched;
 pub mod fri_commitment;
 pub mod fri_decommit;
 pub(crate) mod fri_functions;
+pub mod mmcs;
 
 use crypto::fiat_shamir::is_transcript::IsStarkTranscript;
 use math::field::element::FieldElement;

crypto/stark/src/proof/stark.rs

@@ -5,7 +5,8 @@ use math::field::{
 };
 
 use crate::{
-    config::Commitment, fri::fri_decommit::FriDecommitment, lookup::BusPublicInputs, table::Table,
+    config::Commitment, fri::fri_decommit::FriDecommitment, fri::mmcs::MixedOpening,
+    lookup::BusPublicInputs, table::Table,
 };
 
 #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
@@ -83,3 +84,66 @@ pub struct StarkProof<F: IsSubFieldOf<E>, E: IsField, PI> {
 pub struct MultiProof<F: IsSubFieldOf<E>, E: IsField, PI> {
     pub proofs: Vec<StarkProof<F, E, PI>>,
 }
+
+/// Opening of all tables at ONE FRI query index, read from the per-phase
+/// mixed-height MMCS trees. `main`, `aux` and `composition` each carry ONE
+/// shared authentication path covering every table's row-pair at the query —
+/// the unified-shard opening-path win (N×Q auth paths collapse to ~Q per phase).
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(bound = "")]
+pub struct BatchedQueryOpening<F: IsSubFieldOf<E>, E: IsField> {
+    pub main: MixedOpening<F>,
+    pub aux: Option<MixedOpening<E>>,
+    pub composition: MixedOpening<E>,
+    /// Per preprocessed table (in preprocessed-table order): the precomputed
+    /// columns opened against that table's hardcoded precomputed tree — those
+    /// columns are NOT part of the shared main MMCS.
+    pub precomputed: Vec<PolynomialOpenings<F>>,
+}
+
+/// Per-table data carried by a [`BatchedMultiProof`] (canonical epoch order).
+/// The three commitment roots and the OOD point `z` are SHARED across the epoch
+/// (roots live on `BatchedMultiProof`; `z` is re-derived by the verifier), so
+/// only genuinely per-table values live here.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+#[serde(bound = "PI: serde::Serialize + serde::de::DeserializeOwned")]
+pub struct BatchedTableData<E: IsField, PI> {
+    pub trace_length: usize,
+    /// tⱼ(z gᵏ)
+    pub trace_ood_evaluations: Table<E>,
+    /// Hᵢ(z^N)
+    pub composition_poly_parts_ood_evaluation: Vec<FieldElement<E>>,
+    /// Hardcoded precomputed-columns commitment (preprocessed tables); the
+    /// verifier checks it against the AIR's known value.
+    pub precomputed_root: Option<Commitment>,
+    pub bus_public_inputs: Option<BusPublicInputs<E>>,
+    pub public_inputs: PI,
+}
+
+/// A batched STARK proof for an epoch of tables sharing ONE linear transcript,
+/// ONE OOD point `z`, and ONE FRI over the height-combined DEEP codewords
+/// (unified-shard / Plonky3-style). Produced by `Prover::multi_prove_batched`
+/// and verified by `Verifier::batched_multi_verify`. Eventually replaces
+/// [`MultiProof`].
+#[derive(Debug, serde::Serialize, serde::Deserialize)]
+#[serde(bound = "PI: serde::Serialize + serde::de::DeserializeOwned")]
+pub struct BatchedMultiProof<F: IsSubFieldOf<E>, E: IsField, PI> {
+    /// Shared mixed-height MMCS root over all tables' main-split matrices.
+    pub main_root: Commitment,
+    /// Shared mixed-height MMCS root over all aux-carrying tables' matrices.
+    pub aux_root: Option<Commitment>,
+    /// Shared mixed-height MMCS root over all tables' composition matrices.
+    pub composition_root: Commitment,
+    /// Merkle roots of the batched-FRI fold layers.
+    pub fri_layers_merkle_roots: Vec<Commitment>,
+    /// Final FRI folding value.
+    pub fri_last_value: FieldElement<E>,
+    /// Per-query openings of the FRI fold layers (shared across tables).
+    pub query_list: Vec<FriDecommitment<E>>,
+    /// Proof-of-work grinding nonce.
+    pub nonce: Option<u64>,
+    /// Per-query openings of the three shared trees (+ per-table precomputed).
+    pub deep_poly_openings: Vec<BatchedQueryOpening<F, E>>,
+    /// Per-table data in canonical epoch order.
+    pub per_table: Vec<BatchedTableData<E, PI>>,
+}