Skip to main content

jf_plonk/circuit/plonk_verifier/
mod.rs

1// Copyright (c) 2022 Espresso Systems (espressosys.com)
2// This file is part of the Jellyfish library.
3
4// You should have received a copy of the MIT License
5// along with the Jellyfish library. If not, see <https://mit-license.org/>.
6
7//! Circuits for Plonk verifiers.
8use crate::proof_system::{structs::VerifyingKey, verifier::Verifier};
9use ark_ec::{
10    pairing::Pairing,
11    short_weierstrass::{Affine, SWCurveConfig as SWParam},
12    twisted_edwards::TECurveConfig as TEParam,
13};
14use ark_ff::{BigInteger, PrimeField};
15use ark_std::{format, string::ToString, vec, vec::Vec};
16use jf_relation::{
17    gadgets::{
18        ecc::{MultiScalarMultiplicationCircuit, PointVariable, SWToTEConParam, TEPoint},
19        ultraplonk::mod_arith::{FpElem, FpElemVar},
20    },
21    Circuit, CircuitError,
22    CircuitError::ParameterError,
23    PlonkCircuit, Variable,
24};
25use jf_rescue::RescueParameter;
26
27mod gadgets;
28mod poly;
29mod structs;
30
31use gadgets::*;
32pub use structs::*;
33
34#[derive(Debug, Clone, Eq, PartialEq)]
35/// Represent variable of a Plonk verifying key.
36pub struct VerifyingKeyVar<E: Pairing> {
37    /// The variables for the permutation polynomial commitments.
38    pub(crate) sigma_comms: Vec<PointVariable>,
39    /// The variables for the selector polynomial commitments.
40    pub(crate) selector_comms: Vec<PointVariable>,
41    /// A flag indicating whether the key is a merged key.
42    is_merged: bool,
43
44    /// The size of the evaluation domain. Should be a power of two.
45    domain_size: usize,
46
47    /// The number of public inputs.
48    num_inputs: usize,
49
50    /// The constants K0, ..., K_num_wire_types that ensure wire subsets are
51    /// disjoint.
52    k: Vec<E::ScalarField>,
53}
54
55impl<E: Pairing> VerifyingKeyVar<E> {
56    /// Create a variable for a Plonk verifying key.
57    pub fn new<F, P>(
58        circuit: &mut PlonkCircuit<F>,
59        verify_key: &VerifyingKey<E>,
60    ) -> Result<Self, CircuitError>
61    where
62        E: Pairing<BaseField = F, G1Affine = Affine<P>>,
63        F: PrimeField + SWToTEConParam,
64        P: SWParam<BaseField = F>,
65    {
66        let sigma_comms = verify_key
67            .sigma_comms
68            .iter()
69            .map(|comm| circuit.create_point_variable(TEPoint::from(comm.0)))
70            .collect::<Result<Vec<_>, CircuitError>>()?;
71        let selector_comms = verify_key
72            .selector_comms
73            .iter()
74            .map(|comm| circuit.create_point_variable(TEPoint::from(comm.0)))
75            .collect::<Result<Vec<_>, CircuitError>>()?;
76        Ok(Self {
77            sigma_comms,
78            selector_comms,
79            is_merged: verify_key.is_merged,
80            domain_size: verify_key.domain_size,
81            num_inputs: verify_key.num_inputs,
82            k: verify_key.k.clone(),
83        })
84    }
85
86    /// Convert to a list of variables.
87    pub fn to_vec(&self) -> Vec<Variable> {
88        let mut res = vec![];
89        for sigma_comm in self.sigma_comms.iter() {
90            res.push(sigma_comm.get_x());
91            res.push(sigma_comm.get_y());
92        }
93        for selector_comm in self.selector_comms.iter() {
94            res.push(selector_comm.get_x());
95            res.push(selector_comm.get_y());
96        }
97        res
98    }
99
100    /// Merge with another Plonk verifying key variable.
101    pub(crate) fn merge<F, P>(
102        &self,
103        circuit: &mut PlonkCircuit<F>,
104        other: &Self,
105    ) -> Result<Self, CircuitError>
106    where
107        F: PrimeField,
108        P: TEParam<BaseField = F>,
109    {
110        if self.is_merged || other.is_merged {
111            return Err(ParameterError(
112                "cannot merge a merged key again".to_string(),
113            ));
114        }
115        if self.domain_size != other.domain_size {
116            return Err(ParameterError(
117                "cannot merge a verifying key with different domain size".to_string(),
118            ));
119        }
120        if self.num_inputs != other.num_inputs {
121            return Err(ParameterError(
122                "cannot merge a verifying key with different public input length".to_string(),
123            ));
124        }
125        let sigma_comms = self
126            .sigma_comms
127            .iter()
128            .zip(other.sigma_comms.iter())
129            .map(|(com1, com2)| circuit.ecc_add::<P>(com1, com2))
130            .collect::<Result<Vec<_>, CircuitError>>()?;
131        let selector_comms = self
132            .selector_comms
133            .iter()
134            .zip(other.selector_comms.iter())
135            .map(|(com1, com2)| circuit.ecc_add::<P>(com1, com2))
136            .collect::<Result<Vec<_>, CircuitError>>()?;
137        Ok(Self {
138            sigma_comms,
139            selector_comms,
140            is_merged: true,
141            domain_size: self.domain_size,
142            num_inputs: self.num_inputs + other.num_inputs,
143            k: self.k.clone(),
144        })
145    }
146
147    /// Circuit for partially verifying a batched proof without performing the
148    /// pairing. Return the variables for the two group elements used in the
149    /// final pairing.
150    /// The public inputs are already in the form of FpElemVars.
151    pub fn partial_verify_circuit<F, P>(
152        circuit: &mut PlonkCircuit<F>,
153        beta_g: &TEPoint<F>,
154        generator_g: &TEPoint<F>,
155        merged_vks: &[Self],
156        shared_public_input_vars: &[FpElemVar<F>],
157        batch_proof: &BatchProofVar<F>,
158        blinding_factor: Variable,
159    ) -> Result<(PointVariable, PointVariable), CircuitError>
160    where
161        E: Pairing<BaseField = F, G1Affine = Affine<P>>,
162        F: RescueParameter + SWToTEConParam,
163        P: SWParam<BaseField = F> + TEParam,
164    {
165        if merged_vks.is_empty() {
166            return Err(ParameterError("empty merged verification keys".to_string()));
167        }
168        if merged_vks.len() != batch_proof.len() {
169            return Err(ParameterError(format!(
170                "the number of verification keys {} is different from the number of instances {}.",
171                merged_vks.len(),
172                batch_proof.len()
173            )));
174        }
175
176        let domain_size = merged_vks[0].domain_size;
177        for (i, vk) in merged_vks.iter().skip(1).enumerate() {
178            if vk.domain_size != domain_size {
179                return Err(ParameterError(format!(
180                    "the {}-th verification key's domain size {} is different from {}.",
181                    i, vk.domain_size, domain_size
182                )));
183            }
184        }
185
186        let range_bit_len = circuit.range_bit_len()?;
187        let m2 = (<E::ScalarField as PrimeField>::MODULUS_BIT_SIZE as usize + 1) >> 1;
188        // m should be a multiple of `range_bit_len`
189        let m = (m2 - 1) / range_bit_len * range_bit_len + range_bit_len;
190
191        // constants
192        let two_power_m = Some(E::BaseField::from(2u8).pow([m as u64]));
193
194        let fr_modulus_bits = <E::ScalarField as PrimeField>::MODULUS.to_bytes_le();
195        let modulus_in_f = F::from_le_bytes_mod_order(&fr_modulus_bits);
196        let modulus_fp_elem = FpElem::new(&modulus_in_f, m, two_power_m)?;
197
198        let non_native_field_info = NonNativeFieldInfo::<F> {
199            m,
200            two_power_m,
201            modulus_in_f,
202            modulus_fp_elem,
203        };
204
205        let verifier = Verifier::<E>::new(domain_size)?;
206        let domain = verifier.domain;
207
208        // we need to copy the public input once after merging the circuit
209        let shared_public_input_vars =
210            [shared_public_input_vars, shared_public_input_vars].concat();
211        let public_inputs = vec![&shared_public_input_vars[..]; merged_vks.len()];
212        let merged_vks_ref: Vec<&VerifyingKeyVar<E>> = merged_vks.iter().collect();
213
214        // generate the PCS info
215        let pcs_info_var = prepare_pcs_info_var(
216            circuit,
217            &merged_vks_ref,
218            &public_inputs,
219            batch_proof,
220            &None,
221            domain,
222            non_native_field_info,
223        )?;
224
225        // inner1
226        //  = [open_proof]
227        //  + u * [shifted_open_proof]
228        //  + blinding_factor * [1]1
229        let generator_g_var = circuit.create_constant_point_variable(*generator_g)?;
230        let bases = [
231            pcs_info_var.opening_proof,
232            pcs_info_var.shifted_opening_proof,
233            generator_g_var,
234        ];
235        let u_var = pcs_info_var.u.convert_to_var(circuit)?;
236        let scalars = [circuit.one(), u_var, blinding_factor];
237
238        let inner1 = MultiScalarMultiplicationCircuit::<_, P>::msm(circuit, &bases, &scalars)?;
239
240        // inner2
241        //  = eval_point * [open_proof]
242        //  + next_eval_point * u * [shifted_open_proof]
243        //  + [aggregated_comm]
244        //  - aggregated_eval * [1]1
245        //  + blinding_factor * [beta]1
246        let mut scalars_and_bases = pcs_info_var.comm_scalars_and_bases;
247        scalars_and_bases.scalars.push(pcs_info_var.eval_point);
248        scalars_and_bases.bases.push(pcs_info_var.opening_proof);
249
250        let tmp = circuit.mod_mul(
251            &pcs_info_var.next_eval_point,
252            &pcs_info_var.u,
253            &modulus_fp_elem,
254        )?;
255        scalars_and_bases.scalars.push(tmp);
256        scalars_and_bases
257            .bases
258            .push(pcs_info_var.shifted_opening_proof);
259
260        let generator_g_inv_var = circuit.create_constant_point_variable(generator_g.inverse())?;
261        scalars_and_bases.scalars.push(pcs_info_var.eval);
262        scalars_and_bases.bases.push(generator_g_inv_var);
263
264        let mut scalars = scalars_and_bases
265            .scalars
266            .iter()
267            .map(|x| x.convert_to_var(circuit))
268            .collect::<Result<Vec<_>, _>>()?;
269        scalars.push(blinding_factor);
270
271        let mut bases = scalars_and_bases.bases;
272        let beta_g = circuit.create_constant_point_variable(*beta_g)?;
273        bases.push(beta_g);
274        let inner2 = MultiScalarMultiplicationCircuit::<_, P>::msm(circuit, &bases, &scalars)?;
275
276        Ok((inner1, inner2))
277    }
278}
279
280/// Plonk Circuit that support batch verification
281pub trait BatchableCircuit<F> {
282    /// Aggregate verification keys
283    fn aggregate_verify_keys<E, P>(
284        &mut self,
285        vk_type_a_vars: &[VerifyingKeyVar<E>],
286        vk_type_b_vars: &[VerifyingKeyVar<E>],
287    ) -> Result<Vec<VerifyingKeyVar<E>>, CircuitError>
288    where
289        E: Pairing,
290        P: TEParam<BaseField = F>;
291}
292
293/// Instances batching scheme related gates
294impl<F> BatchableCircuit<F> for PlonkCircuit<F>
295where
296    F: PrimeField,
297{
298    fn aggregate_verify_keys<E, P>(
299        &mut self,
300        vk_type_a_vars: &[VerifyingKeyVar<E>],
301        vk_type_b_vars: &[VerifyingKeyVar<E>],
302    ) -> Result<Vec<VerifyingKeyVar<E>>, CircuitError>
303    where
304        E: Pairing,
305        P: TEParam<BaseField = F>,
306    {
307        if vk_type_a_vars.len() != vk_type_b_vars.len() {
308            return Err(ParameterError(format!(
309                "the number of type A verification key variables {} is different from the number of type B verification key variables {}.",
310                vk_type_a_vars.len(),
311                vk_type_b_vars.len())
312            ));
313        }
314        vk_type_a_vars
315            .iter()
316            .zip(vk_type_b_vars.iter())
317            .map(|(vk_b, vk_d)| vk_b.merge::<F, P>(self, vk_d))
318            .collect::<Result<Vec<_>, CircuitError>>()
319    }
320}
321
322#[cfg(test)]
323mod test {
324    use super::*;
325    use crate::{
326        proof_system::{
327            batch_arg::{new_mergeable_circuit_for_test, BatchArgument},
328            structs::BatchProof,
329            PlonkKzgSnark, UniversalSNARK,
330        },
331        transcript::{PlonkTranscript, RescueTranscript},
332    };
333    use ark_bls12_377::{g1::Config as Param377, Bls12_377, Fq as Fq377, Fr as Fr377};
334    use ark_ec::{short_weierstrass::SWCurveConfig, twisted_edwards::TECurveConfig, CurveGroup};
335    use ark_std::{vec, UniformRand};
336    use jf_relation::{
337        gadgets::test_utils::test_variable_independence_for_circuit, MergeableCircuitType,
338    };
339    use jf_utils::{field_switching, test_rng};
340    use rstest::rstest;
341
342    const RANGE_BIT_LEN_FOR_TEST: usize = 16;
343
344    #[test]
345    fn test_aggregate_vks() -> Result<(), CircuitError> {
346        test_aggregate_vks_helper::<Bls12_377, Fq377, _, Param377>()
347    }
348
349    fn test_aggregate_vks_helper<E, F, P, Q>() -> Result<(), CircuitError>
350    where
351        E: Pairing<BaseField = F, G1Affine = Affine<P>>,
352        F: PrimeField + RescueParameter + SWToTEConParam,
353        P: SWParam<BaseField = F>,
354        Q: TEParam<BaseField = F>,
355    {
356        // Simulate universal setup
357        let rng = &mut test_rng();
358        let n = 32;
359        let max_degree = n + 2;
360        let srs = PlonkKzgSnark::<E>::universal_setup_for_testing(max_degree, rng)?;
361
362        // Setup instances and create verifying keys
363        let mut vks_type_a = vec![];
364        let mut vks_type_b = vec![];
365        let shared_public_input = E::ScalarField::rand(rng);
366        for i in 0..5 {
367            let circuit = new_mergeable_circuit_for_test::<E>(
368                shared_public_input,
369                i,
370                MergeableCircuitType::TypeA,
371            )?;
372            let instance =
373                BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeA)?;
374            vks_type_a.push(instance.verify_key_ref().clone());
375
376            let circuit = new_mergeable_circuit_for_test::<E>(
377                shared_public_input,
378                i,
379                MergeableCircuitType::TypeB,
380            )?;
381            let instance =
382                BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeB)?;
383            vks_type_b.push(instance.verify_key_ref().clone());
384        }
385        // Compute merged verifying keys
386        let vks_type_a_ref: Vec<&VerifyingKey<E>> = vks_type_a.iter().collect();
387        let vks_type_b_ref: Vec<&VerifyingKey<E>> = vks_type_b.iter().collect();
388        let merged_vks = BatchArgument::aggregate_verify_keys(&vks_type_a_ref, &vks_type_b_ref)?;
389
390        // Check circuits
391        let mut circuit: PlonkCircuit<F> = PlonkCircuit::new_ultra_plonk(RANGE_BIT_LEN_FOR_TEST);
392        let vk_type_a_vars = vks_type_a
393            .iter()
394            .map(|vk| VerifyingKeyVar::new(&mut circuit, vk))
395            .collect::<Result<Vec<_>, CircuitError>>()?;
396        for (vk_var, vk) in vk_type_a_vars.iter().zip(vks_type_a.iter()) {
397            check_vk_equality(&circuit, vk_var, vk);
398        }
399
400        let vk_type_b_vars = vks_type_b
401            .iter()
402            .map(|vk| VerifyingKeyVar::new(&mut circuit, vk))
403            .collect::<Result<Vec<_>, CircuitError>>()?;
404        for (vk_var, vk) in vk_type_b_vars.iter().zip(vks_type_b.iter()) {
405            check_vk_equality(&circuit, vk_var, vk);
406        }
407
408        let merged_vk_vars =
409            circuit.aggregate_verify_keys::<E, Q>(&vk_type_a_vars, &vk_type_b_vars)?;
410        for (vk_var, vk) in merged_vk_vars.iter().zip(merged_vks.iter()) {
411            check_vk_equality(&circuit, vk_var, vk);
412        }
413
414        assert!(circuit.check_circuit_satisfiability(&[]).is_ok());
415
416        // Error paths
417        // wrong witness
418        let tmp = circuit.witness(merged_vk_vars[0].sigma_comms[0].get_x())?;
419        *circuit.witness_mut(merged_vk_vars[0].sigma_comms[0].get_x()) = F::from(0u8);
420        assert!(circuit.check_circuit_satisfiability(&[]).is_err());
421        *circuit.witness_mut(merged_vk_vars[0].sigma_comms[0].get_x()) = tmp;
422
423        // inconsistent length between `vk_type_a_vars` and `vk_type_b_vars`
424        assert!(circuit
425            .aggregate_verify_keys::<E, Q>(&vk_type_a_vars[1..], &vk_type_b_vars)
426            .is_err());
427
428        // merged keys can't be merged again.
429        let mut bad_vk_vars = vk_type_a_vars.clone();
430        bad_vk_vars[0].is_merged = true;
431        assert!(circuit
432            .aggregate_verify_keys::<E, Q>(&bad_vk_vars, &vk_type_b_vars)
433            .is_err());
434
435        Ok(())
436    }
437
438    fn check_vk_equality<E, F, P>(
439        circuit: &PlonkCircuit<F>,
440        vk_var: &VerifyingKeyVar<E>,
441        vk: &VerifyingKey<E>,
442    ) where
443        E: Pairing<BaseField = F, G1Affine = Affine<P>>,
444        F: PrimeField + SWToTEConParam,
445        P: SWParam<BaseField = F>,
446    {
447        for (comm_var, comm) in vk_var.sigma_comms.iter().zip(vk.sigma_comms.iter()) {
448            let expected_comm = TEPoint::from(comm.0);
449            assert_eq!(circuit.point_witness(comm_var).unwrap(), expected_comm);
450        }
451        for (comm_var, comm) in vk_var.selector_comms.iter().zip(vk.selector_comms.iter()) {
452            let expected_comm = TEPoint::from(comm.0);
453            assert_eq!(circuit.point_witness(comm_var).unwrap(), expected_comm);
454        }
455        assert_eq!(vk_var.is_merged, vk.is_merged);
456    }
457
458    #[rstest]
459    fn test_partial_verification_circuit(
460        #[values(8, 9, 10, 11)] log_circuit_size: usize,
461    ) -> Result<(), CircuitError> {
462        let rng = &mut test_rng();
463
464        // =======================================
465        // setup
466        // =======================================
467
468        // 1. Simulate universal setup
469        let n = 1 << log_circuit_size;
470        let max_degree = n + 2;
471        let srs = PlonkKzgSnark::<Bls12_377>::universal_setup_for_testing(max_degree, rng)?;
472
473        // 2. Setup instances
474        let shared_public_input = Fr377::rand(rng);
475        let mut instances_type_a = vec![];
476        let mut instances_type_b = vec![];
477        for i in 32..50 {
478            let circuit = new_mergeable_circuit_for_test::<Bls12_377>(
479                shared_public_input,
480                i,
481                MergeableCircuitType::TypeA,
482            )?;
483            let instance =
484                BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeA)?;
485            instances_type_a.push(instance);
486
487            let circuit = new_mergeable_circuit_for_test::<Bls12_377>(
488                shared_public_input,
489                i,
490                MergeableCircuitType::TypeB,
491            )?;
492            let instance =
493                BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeB)?;
494            instances_type_b.push(instance);
495        }
496        // 3. Batch Proving
497        let batch_proof = BatchArgument::batch_prove::<_, RescueTranscript<Fq377>>(
498            rng,
499            &instances_type_a,
500            &instances_type_b,
501        )?;
502
503        // 4. Aggregate verification keys
504        let vks_type_a: Vec<&VerifyingKey<Bls12_377>> = instances_type_a
505            .iter()
506            .map(|pred| pred.verify_key_ref())
507            .collect();
508        let vks_type_b: Vec<&VerifyingKey<Bls12_377>> = instances_type_b
509            .iter()
510            .map(|pred| pred.verify_key_ref())
511            .collect();
512        let merged_vks = BatchArgument::aggregate_verify_keys(&vks_type_a, &vks_type_b)?;
513        // error path: inconsistent length between vks_type_a and vks_type_b
514        assert!(BatchArgument::aggregate_verify_keys(&vks_type_a[1..], &vks_type_b).is_err());
515
516        // 5. Verification
517        let open_key_ref = &vks_type_a[0].open_key;
518        let beta_g_ref = &srs.powers_of_g[1];
519        let blinding_factor = Fr377::rand(rng);
520        let (inner1, inner2) = BatchArgument::partial_verify::<RescueTranscript<Fq377>>(
521            beta_g_ref,
522            &open_key_ref.g,
523            &merged_vks,
524            &[shared_public_input],
525            &batch_proof,
526            blinding_factor,
527        )?;
528        assert!(BatchArgument::decide(open_key_ref, inner1, inner2)?);
529
530        {
531            // =======================================
532            // good path
533            // =======================================
534            let public_inputs = [[field_switching(&shared_public_input)].as_ref()].concat();
535
536            let (mut circuit, partial_verify_points) = build_circuit::<Bls12_377, Fq377, Param377>(
537                &shared_public_input,
538                &merged_vks,
539                &batch_proof,
540                beta_g_ref,
541                &open_key_ref.g,
542                &blinding_factor,
543            )?;
544
545            assert!(
546                circuit.check_circuit_satisfiability(&public_inputs).is_ok(),
547                "{:?}",
548                circuit.check_circuit_satisfiability(&public_inputs)
549            );
550            assert_eq!(
551                circuit.point_witness(&partial_verify_points.0)?,
552                TEPoint::<Fq377>::from(inner1.into_affine())
553            );
554            assert_eq!(
555                circuit.point_witness(&partial_verify_points.1)?,
556                TEPoint::<Fq377>::from(inner2.into_affine())
557            );
558
559            // ark_std::println!("#variables: {}", circuit.num_vars());
560            // ark_std::println!("#constraints: {}\n", circuit.num_gates());
561
562            // =======================================
563            // bad path: wrong pub inputs
564            // =======================================
565            // instance inputs = partial verify inputs != satisfiability inputs
566            let wrong_public_inputs = [[Fq377::rand(rng)].as_ref()].concat();
567            assert!(circuit
568                .check_circuit_satisfiability(&wrong_public_inputs)
569                .is_err(),);
570
571            // =======================================
572            // bad path: wrong number of pub inputs
573            // =======================================
574            let wrong_public_inputs =
575                [[field_switching(&shared_public_input); 3].as_ref()].concat();
576            assert!(circuit
577                .check_circuit_satisfiability(&wrong_public_inputs)
578                .is_err(),);
579
580            // =======================================
581            // bad path: wrong witness
582            // =======================================
583            *circuit.witness_mut(10) = Fq377::from(0u32);
584            assert!(circuit
585                .check_circuit_satisfiability(&public_inputs)
586                .is_err());
587        }
588        // ==============================================
589        // more bad path: wrong inputs length
590        // ==============================================
591        {
592            // wrong vks length (less by 1)
593            // should not be able to generate circuit
594            let mut wrong_merge_vks = merged_vks.clone();
595            let tmp = wrong_merge_vks.pop().unwrap();
596            assert!(build_circuit::<Bls12_377, Fq377, Param377>(
597                &shared_public_input,
598                &wrong_merge_vks,
599                &batch_proof,
600                beta_g_ref,
601                &open_key_ref.g,
602                &blinding_factor,
603            )
604            .is_err());
605
606            // wrong vks length (more by 1)
607            // should not be able to generate circuit
608            let mut wrong_merge_vks = merged_vks.clone();
609            wrong_merge_vks.push(tmp);
610            assert!(build_circuit::<Bls12_377, Fq377, Param377>(
611                &shared_public_input,
612                &wrong_merge_vks,
613                &batch_proof,
614                beta_g_ref,
615                &open_key_ref.g,
616                &blinding_factor,
617            )
618            .is_err());
619        }
620
621        // ==============================================
622        // more bad path: wrong inputs to the function
623        // ==============================================
624        {
625            // wrong shared input, the circuit is not satisfied
626            // instance inputs = satisfiability inputs != partial verify inputs
627            let public_inputs = [[field_switching(&shared_public_input)].as_ref()].concat();
628            let wrong_shared_public_input = Fr377::rand(rng);
629            let (circuit, partial_verify_points) = build_circuit::<Bls12_377, Fq377, Param377>(
630                &wrong_shared_public_input,
631                &merged_vks,
632                &batch_proof,
633                beta_g_ref,
634                &open_key_ref.g,
635                &blinding_factor,
636            )?;
637
638            assert!(
639                circuit
640                    .check_circuit_satisfiability(&public_inputs)
641                    .is_err(),
642                "{:?}",
643                circuit.check_circuit_satisfiability(public_inputs.as_ref())
644            );
645            assert_ne!(
646                circuit.point_witness(&partial_verify_points.0)?,
647                TEPoint::<Fq377>::from(inner1.into_affine())
648            );
649            assert_ne!(
650                circuit.point_witness(&partial_verify_points.1)?,
651                TEPoint::<Fq377>::from(inner2.into_affine())
652            );
653
654            // wrong shared input and circuit input
655            // instance inputs != partial verify inputs = satisfiability inputs
656            // the circuit is satisfied because partial verify inputs =
657            // satisfiability inputs both output must be different so it will
658            // not verify original instance
659            let wrong_public_inputs =
660                [[field_switching(&wrong_shared_public_input)].as_ref()].concat();
661            assert!(
662                circuit
663                    .check_circuit_satisfiability(&wrong_public_inputs)
664                    .is_ok(),
665                "{:?}",
666                circuit.check_circuit_satisfiability(wrong_public_inputs.as_ref())
667            );
668            assert_ne!(
669                circuit.point_witness(&partial_verify_points.0)?,
670                TEPoint::<Fq377>::from(inner1.into_affine())
671            );
672            assert_ne!(
673                circuit.point_witness(&partial_verify_points.1)?,
674                TEPoint::<Fq377>::from(inner2.into_affine())
675            );
676        }
677
678        Ok(())
679    }
680
681    fn build_circuit<E, F, P>(
682        shared_public_input: &E::ScalarField,
683        merged_vks: &[VerifyingKey<E>],
684        batch_proof: &BatchProof<E>,
685        beta_g_ref: &Affine<P>,
686        generator_g: &Affine<P>,
687        blinding_factor: &E::ScalarField,
688    ) -> Result<(PlonkCircuit<F>, (PointVariable, PointVariable)), CircuitError>
689    where
690        E: Pairing<BaseField = F, G1Affine = Affine<P>>,
691        F: RescueParameter + SWToTEConParam,
692        P: SWCurveConfig<BaseField = F> + TECurveConfig,
693    {
694        let mut circuit = PlonkCircuit::<E::BaseField>::new_ultra_plonk(RANGE_BIT_LEN_FOR_TEST);
695
696        // constants
697        let m = 128;
698        let two_power_m = Some(E::BaseField::from(2u8).pow([m as u64]));
699
700        // public inputs
701        let shared_public_input_var =
702            circuit.create_public_variable(field_switching(shared_public_input))?;
703        let shared_public_input_fp_elem_var =
704            FpElemVar::new_unchecked(&mut circuit, shared_public_input_var, m, two_power_m)?;
705
706        // vk
707        let vk_vars = merged_vks
708            .iter()
709            .map(|x| VerifyingKeyVar::new(&mut circuit, x))
710            .collect::<Result<Vec<_>, _>>()?;
711
712        // proof
713        let batch_proof_vars = (*batch_proof).create_variables(&mut circuit, m, two_power_m)?;
714
715        let beta_g: TEPoint<F> = (*beta_g_ref).into();
716        let generator_g = &(*generator_g).into();
717        let blinding_factor_var = circuit.create_variable(field_switching(blinding_factor))?;
718
719        let partial_verify_points = VerifyingKeyVar::partial_verify_circuit(
720            &mut circuit,
721            &beta_g,
722            generator_g,
723            &vk_vars,
724            &[shared_public_input_fp_elem_var],
725            &batch_proof_vars,
726            blinding_factor_var,
727        )?;
728
729        Ok((circuit, partial_verify_points))
730    }
731
732    #[test]
733    fn test_variable_independence_for_partial_verification_circuit() -> Result<(), CircuitError> {
734        test_variable_independence_for_partial_verification_circuit_helper::<
735            Bls12_377,
736            _,
737            _,
738            RescueTranscript<_>,
739        >()
740    }
741
742    fn test_variable_independence_for_partial_verification_circuit_helper<E, F, P, T>(
743    ) -> Result<(), CircuitError>
744    where
745        E: Pairing<BaseField = F, G1Affine = Affine<P>>,
746        F: RescueParameter + SWToTEConParam,
747        P: SWCurveConfig<BaseField = F> + TECurveConfig,
748        T: PlonkTranscript<F>,
749    {
750        let rng = &mut test_rng();
751        let i = 8;
752        let mut circuits = vec![];
753
754        // 1. Simulate universal setup
755        let n = 1 << i;
756        let max_degree = n + 2;
757        let srs = PlonkKzgSnark::<E>::universal_setup_for_testing(max_degree, rng)?;
758
759        for _ in 0..2 {
760            // =======================================
761            // set up
762            // =======================================
763
764            // 2. Setup instances
765            let shared_public_input = E::ScalarField::rand(rng);
766            let mut instances_type_a = vec![];
767            let mut instances_type_b = vec![];
768
769            let circuit = new_mergeable_circuit_for_test::<E>(
770                shared_public_input,
771                i,
772                MergeableCircuitType::TypeA,
773            )?;
774            let instance =
775                BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeA)?;
776            instances_type_a.push(instance);
777
778            let circuit = new_mergeable_circuit_for_test::<E>(
779                shared_public_input,
780                i,
781                MergeableCircuitType::TypeB,
782            )?;
783            let instance =
784                BatchArgument::setup_instance(&srs, circuit, MergeableCircuitType::TypeB)?;
785            instances_type_b.push(instance);
786
787            // 3. Batch Proving
788            let batch_proof =
789                BatchArgument::batch_prove::<_, T>(rng, &instances_type_a, &instances_type_b)?;
790
791            // 4. Aggregate verification keys
792            let vks_type_a: Vec<&VerifyingKey<E>> = instances_type_a
793                .iter()
794                .map(|pred| pred.verify_key_ref())
795                .collect();
796            let vks_type_b: Vec<&VerifyingKey<E>> = instances_type_b
797                .iter()
798                .map(|pred| pred.verify_key_ref())
799                .collect();
800            let merged_vks = BatchArgument::aggregate_verify_keys(&vks_type_a, &vks_type_b)?;
801
802            // 5. Build circuit
803            let open_key_ref = &vks_type_a[0].open_key;
804            let beta_g_ref = &srs.powers_of_g[1];
805            let blinding_factor = E::ScalarField::rand(rng);
806
807            let (mut circuit, _partial_verify_points) = build_circuit::<E, F, P>(
808                &shared_public_input,
809                &merged_vks,
810                &batch_proof,
811                beta_g_ref,
812                &open_key_ref.g,
813                &blinding_factor,
814            )?;
815
816            circuit.finalize_for_arithmetization()?;
817            circuits.push(circuit);
818        }
819
820        test_variable_independence_for_circuit(circuits[0].clone(), circuits[1].clone())?;
821
822        Ok(())
823    }
824}