snark_verifier/pcs/ipa/
decider.rs

1use crate::{pcs::ipa::IpaSuccinctVerifyingKey, util::arithmetic::CurveAffine};
2
3/// Inner product argument deciding key.
4#[derive(Clone, Debug)]
5pub struct IpaDecidingKey<C: CurveAffine> {
6    svk: IpaSuccinctVerifyingKey<C>,
7    /// Committing key.
8    g: Vec<C>,
9}
10
11impl<C: CurveAffine> IpaDecidingKey<C> {
12    /// Initialize an [`IpaDecidingKey`].
13    pub fn new(svk: IpaSuccinctVerifyingKey<C>, g: Vec<C>) -> Self {
14        Self { svk, g }
15    }
16}
17
18impl<C: CurveAffine> AsRef<IpaSuccinctVerifyingKey<C>> for IpaDecidingKey<C> {
19    fn as_ref(&self) -> &IpaSuccinctVerifyingKey<C> {
20        &self.svk
21    }
22}
23
24mod native {
25    use crate::{
26        loader::native::NativeLoader,
27        pcs::{
28            ipa::{h_coeffs, IpaAccumulator, IpaAs, IpaDecidingKey},
29            AccumulationDecider,
30        },
31        util::{
32            arithmetic::{Curve, CurveAffine, Field},
33            msm::multi_scalar_multiplication,
34            Itertools,
35        },
36        Error,
37    };
38    use std::fmt::Debug;
39
40    impl<C, MOS> AccumulationDecider<C, NativeLoader> for IpaAs<C, MOS>
41    where
42        C: CurveAffine,
43        MOS: Clone + Debug,
44    {
45        type DecidingKey = IpaDecidingKey<C>;
46
47        fn decide(
48            dk: &Self::DecidingKey,
49            IpaAccumulator { u, xi }: IpaAccumulator<C, NativeLoader>,
50        ) -> Result<(), Error> {
51            let h = h_coeffs(&xi, C::Scalar::ONE);
52            (u == multi_scalar_multiplication(&h, &dk.g).to_affine())
53                .then_some(())
54                .ok_or_else(|| Error::AssertionFailure("U == commit(G, h)".to_string()))
55        }
56
57        fn decide_all(
58            dk: &Self::DecidingKey,
59            accumulators: Vec<IpaAccumulator<C, NativeLoader>>,
60        ) -> Result<(), Error> {
61            assert!(!accumulators.is_empty());
62            accumulators
63                .into_iter()
64                .map(|accumulator| Self::decide(dk, accumulator))
65                .try_collect::<_, Vec<_>, _>()?;
66            Ok(())
67        }
68    }
69}