Target version of proof structs

src/polynomial/commitment.rs

@@ -10,7 +10,7 @@ use crate::merkle_tree::MerkleTree;
 use crate::plonk_challenger::Challenger;
 use crate::plonk_common::reduce_with_powers;
 use crate::polynomial::polynomial::PolynomialCoeffs;
-use crate::proof::{FriProof, Hash, OpeningSet};
+use crate::proof::{FriProof, FriProofTarget, Hash, OpeningSet};
 use crate::timed;
 use crate::util::{log2_strict, reverse_index_bits_in_place, transpose};
 
@@ -272,6 +272,10 @@ impl<F: Field + Extendable<D>, const D: usize> OpeningProof<F, D> {
     }
 }
 
+pub struct OpeningProofTarget<const D: usize> {
+    fri_proof: FriProofTarget<D>,
+}
+
 #[cfg(test)]
 mod tests {
     use anyhow::Result;

src/proof.rs

@@ -1,8 +1,10 @@
+use crate::field::extension_field::target::ExtensionTarget;
 use crate::field::extension_field::Extendable;
 use crate::field::field::Field;
 use crate::fri::FriConfig;
+use crate::gadgets::polynomial::PolynomialCoeffsExtTarget;
 use crate::merkle_proofs::{MerkleProof, MerkleProofTarget};
-use crate::polynomial::commitment::{ListPolynomialCommitment, OpeningProof};
+use crate::polynomial::commitment::{ListPolynomialCommitment, OpeningProof, OpeningProofTarget};
 use crate::polynomial::polynomial::PolynomialCoeffs;
 use crate::target::Target;
 use std::convert::TryInto;
@@ -63,39 +65,33 @@ pub struct Proof<F: Field + Extendable<D>, const D: usize> {
     pub plonk_zs_root: Hash<F>,
     /// Merkle root of LDEs of the quotient polynomial components.
     pub quotient_polys_root: Hash<F>,
-
     /// Purported values of each polynomial at the challenge point.
     pub openings: OpeningSet<F, D>,
-
     /// A FRI argument for each FRI query.
     pub opening_proof: OpeningProof<F, D>,
 }
 
-pub struct ProofTarget {
-    /// Merkle root of LDEs of wire values.
+pub struct ProofTarget<const D: usize> {
     pub wires_root: HashTarget,
-    /// Merkle root of LDEs of Z, in the context of Plonk's permutation argument.
     pub plonk_zs_root: HashTarget,
-    /// Merkle root of LDEs of the quotient polynomial components.
     pub quotient_polys_root: HashTarget,
-
-    /// Purported values of each polynomial at each challenge point.
-    pub openings: Vec<OpeningSetTarget>,
-
-    /// A FRI argument for each FRI query.
-    pub fri_proofs: Vec<FriProofTarget>,
+    pub openings: Vec<OpeningSetTarget<D>>,
+    pub opening_proof: Vec<OpeningProofTarget<D>>,
 }
 
 /// Evaluations and Merkle proof produced by the prover in a FRI query step.
-// TODO: Implement FriQueryStepTarget
 pub struct FriQueryStep<F: Field + Extendable<D>, const D: usize> {
     pub evals: Vec<F::Extension>,
     pub merkle_proof: MerkleProof<F>,
 }
 
+pub struct FriQueryStepTarget<const D: usize> {
+    pub evals: Vec<ExtensionTarget<D>>,
+    pub merkle_proof: MerkleProofTarget,
+}
+
 /// Evaluations and Merkle proofs of the original set of polynomials,
 /// before they are combined into a composition polynomial.
-// TODO: Implement FriInitialTreeProofTarget
 pub struct FriInitialTreeProof<F: Field> {
     pub evals_proofs: Vec<(Vec<F>, MerkleProof<F>)>,
 }
@@ -107,13 +103,21 @@ impl<F: Field> FriInitialTreeProof<F> {
     }
 }
 
+pub struct FriInitialTreeProofTarget {
+    pub evals_proofs: Vec<(Vec<Target>, MerkleProofTarget)>,
+}
+
 /// Proof for a FRI query round.
-// TODO: Implement FriQueryRoundTarget
 pub struct FriQueryRound<F: Field + Extendable<D>, const D: usize> {
     pub initial_trees_proof: FriInitialTreeProof<F>,
     pub steps: Vec<FriQueryStep<F, D>>,
 }
 
+pub struct FriQueryRoundTarget<const D: usize> {
+    pub initial_trees_proof: FriInitialTreeProofTarget,
+    pub steps: Vec<FriQueryStepTarget<D>>,
+}
+
 pub struct FriProof<F: Field + Extendable<D>, const D: usize> {
     /// A Merkle root for each reduced polynomial in the commit phase.
     pub commit_phase_merkle_roots: Vec<Hash<F>>,
@@ -125,16 +129,11 @@ pub struct FriProof<F: Field + Extendable<D>, const D: usize> {
     pub pow_witness: F,
 }
 
-/// Represents a single FRI query, i.e. a path through the reduction tree.
-pub struct FriProofTarget {
-    /// A Merkle root for each reduced polynomial in the commit phase.
+pub struct FriProofTarget<const D: usize> {
     pub commit_phase_merkle_roots: Vec<HashTarget>,
-    /// Merkle proofs for the original purported codewords, i.e. the subject of the LDT.
-    pub initial_merkle_proofs: Vec<MerkleProofTarget>,
-    /// Merkle proofs for the reduced polynomials that were sent in the commit phase.
-    pub intermediate_merkle_proofs: Vec<MerkleProofTarget>,
-    /// The final polynomial in coefficient form.
-    pub final_poly: Vec<Target>,
+    pub query_round_proofs: Vec<FriQueryRoundTarget<D>>,
+    pub final_poly: PolynomialCoeffsExtTarget<D>,
+    pub pow_witness: Target,
 }
 
 /// The purported values of each polynomial at a single point.
@@ -175,10 +174,10 @@ impl<F: Field + Extendable<D>, const D: usize> OpeningSet<F, D> {
 }
 
 /// The purported values of each polynomial at a single point.
-pub struct OpeningSetTarget {
-    pub constants: Vec<Target>,
-    pub plonk_sigmas: Vec<Target>,
-    pub wires: Vec<Target>,
-    pub plonk_zs: Vec<Target>,
-    pub quotient_polys: Vec<Target>,
+pub struct OpeningSetTarget<const D: usize> {
+    pub constants: Vec<ExtensionTarget<D>>,
+    pub plonk_sigmas: Vec<ExtensionTarget<D>>,
+    pub wires: Vec<ExtensionTarget<D>>,
+    pub plonk_zs: Vec<ExtensionTarget<D>>,
+    pub quotient_polys: Vec<ExtensionTarget<D>>,
 }

src/recursive_verifier.rs

@@ -13,7 +13,7 @@ pub fn add_recursive_verifier<F: Extendable<D>, const D: usize>(
     inner_config: CircuitConfig,
     inner_circuit: VerifierCircuitTarget,
     inner_gates: Vec<GateRef<F, D>>,
-    inner_proof: ProofTarget,
+    inner_proof: ProofTarget<D>,
 ) {
     assert!(builder.config.num_wires >= MIN_WIRES);
     assert!(builder.config.num_wires >= MIN_ROUTED_WIRES);