w3f-pcs 0.0.7

Collection of tools for augmenting polynomial commitment schemes
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use ark_poly::Polynomial;
use ark_serialize::{CanonicalDeserialize, CanonicalSerialize};
use ark_std::vec::Vec;

use crate::pcs::*;
use crate::utils::poly;
use crate::Poly;

#[derive(Clone, PartialEq, Eq, Debug, CanonicalSerialize, CanonicalDeserialize)]
pub struct WrappedPolynomial<F: PrimeField>(pub Poly<F>);

impl<F: PrimeField> WrappedPolynomial<F> {
    fn evaluate(&self, x: &F) -> F {
        self.0.evaluate(x)
    }
}

impl<F: PrimeField> Add<Self> for WrappedPolynomial<F> {
    type Output = WrappedPolynomial<F>;

    fn add(self, other: WrappedPolynomial<F>) -> Self::Output {
        WrappedPolynomial(self.0 + other.0)
    }
}

impl<F: PrimeField> Sub<Self> for WrappedPolynomial<F> {
    type Output = WrappedPolynomial<F>;

    fn sub(self, other: WrappedPolynomial<F>) -> Self::Output {
        WrappedPolynomial(self.0 - other.0)
    }
}

impl<F: PrimeField> Sum<Self> for WrappedPolynomial<F> {
    fn sum<I: Iterator<Item = Self>>(iter: I) -> Self {
        iter.reduce(|a, b| a + b).unwrap()
    }
}

impl<F: PrimeField> Mul<F> for WrappedPolynomial<F> {
    type Output = WrappedPolynomial<F>;

    fn mul(self, by: F) -> Self {
        (&self).mul(by)
    }
}

impl<F: PrimeField> Commitment<F> for WrappedPolynomial<F> {
    fn mul(&self, by: F) -> Self {
        WrappedPolynomial(&self.0 * by)
    }

    fn combine(coeffs: &[F], commitments: &[Self]) -> Self {
        let polys = commitments
            .to_vec()
            .into_iter()
            .map(|c| c.0)
            .collect::<Vec<_>>();
        let combined = poly::sum_with_coeffs(coeffs.to_vec(), &polys);
        WrappedPolynomial(combined)
    }
}

impl CommitterKey for () {
    fn max_degree(&self) -> usize {
        usize::MAX >> 1
    }
}

impl VerifierKey for () {
    fn max_points(&self) -> usize {
        1
    }
}

impl RawVerifierKey for () {
    type VK = ();

    fn prepare(&self) -> () {
        ()
    }
}

impl PcsParams for () {
    type CK = ();
    type VK = ();
    type RVK = ();

    fn ck(&self) -> () {
        ()
    }

    fn vk(&self) -> () {
        ()
    }

    fn raw_vk(&self) -> () {
        ()
    }
}

#[derive(Clone)]
pub struct IdentityCommitment {}

impl<F: PrimeField> PCS<F> for IdentityCommitment {
    type C = WrappedPolynomial<F>;
    type Proof = ();
    type CK = ();
    type VK = ();
    type Params = ();

    fn setup<R: Rng>(_max_degree: usize, _rng: &mut R) -> Self::Params {
        ()
    }

    fn commit(_ck: &(), p: &Poly<F>) -> Result<Self::C, ()> {
        Ok(WrappedPolynomial(p.clone()))
    }

    fn open(_ck: &(), _p: &Poly<F>, _x: F) -> Result<Self::Proof, ()> {
        Ok(())
    }

    fn verify(_vk: &(), c: Self::C, x: F, z: F, _proof: Self::Proof) -> Result<(), ()> {
        (c.evaluate(&x) == z).then(|| ()).ok_or(())
    }
}