1use ark_crypto_primitives::sponge::Absorb;
 2use ark_ec::{CurveGroup, Group};
 3use ark_ff::fields::PrimeField;
 4use ark_std::log2;
 5use ark_std::{One, Zero};
 6use std::marker::PhantomData;
 7use std::ops::Add;
 8
 9use ark_poly::{univariate::SparsePolynomial, Polynomial};
10
11use crate::pedersen::{Commitment, Params as PedersenParams, Pedersen, Proof as PedersenProof};
12use crate::transcript::Transcript;
13use crate::utils::*;
14
15// naive impl of pow_i for betas, assuming that betas=(b, b^2, b^4, ..., b^{2^{t-1}})
16fn pow_i<F: PrimeField>(i: usize, betas: &Vec<F>) -> F {
17    // WIP check if makes more sense to do it with ifs instead of arithmetic
18
19    let n = 2_u64.pow(betas.len() as u32);
20    let b = bit_decompose(i as u64, n as usize);
21
22    let mut r: F = F::one();
23    for (j, beta_i) in betas.iter().enumerate() {
24        let mut b_j = F::zero();
25        if b[j] {
26            b_j = F::one();
27        }
28        r *= (F::one() - b_j) + b_j * betas[j];
29    }
30    r
31}
32
33fn pow_i_over_x<F: PrimeField>(i: usize, betas: &Vec<F>, deltas: &Vec<F>) -> SparsePolynomial<F> {
34    assert_eq!(betas.len(), deltas.len());
35
36    let n = 2_u64.pow(betas.len() as u32);
37    let b = bit_decompose(i as u64, n as usize);
38
39    let mut r: SparsePolynomial<F> =
40        SparsePolynomial::<F>::from_coefficients_vec(vec![(0, F::one())]); // start with r(x) = 1
41    for (j, beta_i) in betas.iter().enumerate() {
42        if b[j] {
43            let curr: SparsePolynomial<F> =
44                SparsePolynomial::<F>::from_coefficients_vec(vec![(0, betas[j]), (1, deltas[j])]);
45            r = r.mul(&curr);
46        }
47    }
48    r
49}
50
51#[cfg(test)]
52mod tests {
53    use super::*;
54    use crate::pedersen::Pedersen;
55    use crate::transcript::poseidon_test_config;
56    use ark_bls12_381::{Fr, G1Projective};
57    use ark_std::One;
58    use ark_std::UniformRand;
59
60    #[test]
61    fn test_pow_i() {
62        let mut rng = ark_std::test_rng();
63        let t = 4;
64        let n = 16;
65        let beta = Fr::rand(&mut rng);
66        let betas = powers_of_beta(beta, t);
67        let not_betas = all_powers(beta, n);
68
69        for i in 0..n {
70            assert_eq!(pow_i(i, &betas), not_betas[i]);
71        }
72    }
73
74    #[test]
75    fn test_pow_i_over_x() {
76        let mut rng = ark_std::test_rng();
77        let t = 3;
78        let n = 8;
79        // let beta = Fr::rand(&mut rng);
80        // let delta = Fr::rand(&mut rng);
81        let beta = Fr::from(3);
82        let delta = Fr::from(5);
83        let betas = powers_of_beta(beta, t);
84        let deltas = powers_of_beta(delta, t);
85
86        // for i in 0..n {
87        //     dbg!(pow_i_over_x(i, &betas, &deltas));
88        // }
89    }
90}