multi-stark to batch-stark

Author: sai-deng

recursion/src/generation.rs

@@ -3,12 +3,12 @@ use alloc::vec::Vec;
 
 use itertools::zip_eq;
 use p3_air::Air;
+use p3_batch_stark::BatchProof;
+use p3_batch_stark::config::{observe_base_as_ext, observe_instance_binding};
 use p3_challenger::{CanObserve, CanSample, CanSampleBits, FieldChallenger, GrindingChallenger};
 use p3_commit::{BatchOpening, Mmcs, Pcs, PolynomialSpace};
 use p3_field::{BasedVectorSpace, Field, PrimeCharacteristicRing, PrimeField, TwoAdicField};
 use p3_fri::{FriProof, TwoAdicFriPcs};
-use p3_batch_stark::BatchProof;
-use p3_batch_stark::config::{observe_base_as_ext, observe_instance_binding};
 use p3_uni_stark::{
     Domain, Proof, StarkGenericConfig, SymbolicAirBuilder, Val, VerifierConstraintFolder,
     get_log_quotient_degree,
@@ -187,7 +187,7 @@ where
     Ok(challenges)
 }
 
-/// Generates the challenges used in the verification of a multi-STARK proof.
+/// Generates the challenges used in the verification of a batch-STARK proof.
 pub fn generate_batch_challenges<SC: StarkGenericConfig, A>(
     airs: &[A],
     config: &SC,
@@ -199,10 +199,10 @@ where
     A: Air<SymbolicAirBuilder<Val<SC>>> + for<'a> Air<VerifierConstraintFolder<'a, SC>>,
     SC::Pcs: PcsGeneration<SC, <SC::Pcs as Pcs<SC::Challenge, SC::Challenger>>::Proof>,
 {
-    debug_assert_eq!(config.is_zk(), 0, "batch/multi recursion assumes non-ZK");
+    debug_assert_eq!(config.is_zk(), 0, "batch recursion assumes non-ZK");
     if SC::Pcs::ZK {
         return Err(GenerationError::InvalidProofShape(
-            "multi-STARK challenge generation does not support ZK mode",
+            "batch-STARK challenge generation does not support ZK mode",
         ));
     }
 

recursion/src/public_inputs.rs

@@ -3,10 +3,10 @@
 
 use alloc::vec::Vec;
 
+use p3_batch_stark::BatchProof;
 use p3_circuit::CircuitBuilder;
 use p3_commit::Pcs;
 use p3_field::{BasedVectorSpace, Field, PrimeField64};
-use p3_batch_stark::BatchProof;
 use p3_uni_stark::{Proof, StarkGenericConfig, Val};
 
 use crate::ProofTargets;

recursion/src/verifier/batch_stark.rs

@@ -3,12 +3,12 @@ use alloc::vec::Vec;
 use alloc::{format, vec};
 use core::marker::PhantomData;
 
+use p3_batch_stark::BatchProof;
 use p3_circuit::CircuitBuilder;
 use p3_circuit::op::{NonPrimitiveOpConfig, NonPrimitiveOpType};
 use p3_circuit::utils::ColumnsTargets;
 use p3_commit::{Pcs, PolynomialSpace};
 use p3_field::{BasedVectorSpace, Field, PrimeCharacteristicRing};
-use p3_batch_stark::BatchProof;
 use p3_uni_stark::{OpenedValues, StarkGenericConfig};
 use p3_util::zip_eq::zip_eq;
 
@@ -31,7 +31,7 @@ type PcsVerifierParams<SC, InputProof, OpeningProof, Comm> =
         >>::Domain,
     >>::VerifierParams;
 
-/// Opened values for a single STARK instance within the multi-proof.
+/// Opened values for a single STARK instance within the batch-proof.
 #[derive(Clone)]
 pub struct InstanceOpenedValuesTargets<SC: StarkGenericConfig> {
     pub trace_local: Vec<Target>,
@@ -40,7 +40,7 @@ pub struct InstanceOpenedValuesTargets<SC: StarkGenericConfig> {
     _phantom: PhantomData<SC>,
 }
 
-/// Recursive targets for a multi-STARK proof.
+/// Recursive targets for a batch-STARK proof.
 ///
 /// The `flattened` field stores the aggregated commitments, opened values, and opening proof in the
 /// same layout expected by single-instance PCS logic. The `instances` field retains per-instance
@@ -159,7 +159,7 @@ impl<
     }
 }
 
-/// Verify a multi-STARK proof inside a recursive circuit.
+/// Verify a batch-STARK proof inside a recursive circuit.
 pub fn verify_batch_circuit<
     A,
     SC: StarkGenericConfig,
@@ -191,16 +191,16 @@ where
     SC::Challenge: PrimeCharacteristicRing,
     <<SC as StarkGenericConfig>::Pcs as Pcs<SC::Challenge, SC::Challenger>>::Domain: Clone,
 {
-    debug_assert_eq!(config.is_zk(), 0, "batch/multi recursion assumes non-ZK");
+    debug_assert_eq!(config.is_zk(), 0, "batch recursion assumes non-ZK");
     if airs.is_empty() {
         return Err(VerificationError::InvalidProofShape(
-            "multi-STARK verification requires at least one instance".to_string(),
+            "batch-STARK verification requires at least one instance".to_string(),
         ));
     }
 
     if SC::Pcs::ZK {
         return Err(VerificationError::InvalidProofShape(
-            "ZK mode is not supported for multi-STARK recursion".to_string(),
+            "ZK mode is not supported for batch-STARK recursion".to_string(),
         ));
     }
 
@@ -231,7 +231,7 @@ where
 
     if commitments_targets.random_commit.is_some() {
         return Err(VerificationError::InvalidProofShape(
-            "Multi-STARK verifier does not support random commitments".to_string(),
+            "Batch-STARK verifier does not support random commitments".to_string(),
         ));
     }
 
@@ -277,7 +277,7 @@ where
         quotient_degrees.push(quotient_degree);
     }
 
-    // Challenger initialisation mirrors the native multi-STARK verifier transcript.
+    // Challenger initialisation mirrors the native batch-STARK verifier transcript.
     let mut challenger = CircuitChallenger::<RATE>::new();
     let inst_count_target = circuit.alloc_const(
         SC::Challenge::from_usize(n_instances),

recursion/tests/fibonacci_batch_stark_prover.rs

@@ -1,4 +1,5 @@
 use p3_baby_bear::{BabyBear, Poseidon2BabyBear};
+use p3_batch_stark::{StarkInstance, prove_batch, verify_batch};
 use p3_challenger::DuplexChallenger;
 use p3_circuit::CircuitBuilder;
 use p3_circuit::test_utils::{FibonacciAir, generate_trace_rows};
@@ -8,7 +9,6 @@ use p3_field::extension::BinomialExtensionField;
 use p3_field::{Field, PrimeCharacteristicRing};
 use p3_fri::{TwoAdicFriPcs, create_test_fri_params};
 use p3_merkle_tree::MerkleTreeMmcs;
-use p3_batch_stark::{StarkInstance, prove_batch, verify_batch};
 use p3_recursion::pcs::fri::{
     FriProofTargets, FriVerifierParams, HashTargets, InputProofTargets, RecExtensionValMmcs,
     RecValMmcs, Witness,