logos-co
/
nomos-node
mirror of
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Use domaın and ark fft

This commit is contained in:
mgonen 2024-06-20 20:06:53 +02:00
parent c8f2a8f4c9
commit 391d2852ef
1 changed files with 25 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
nomos-da/kzgrs/src/fk20.rs
View File

@ -4,43 +4,44 @@ use ark_ff::{FftField, Field};
use ark_poly::{EvaluationDomain, GeneralEvaluationDomain, Polynomial as _}; use ark_poly::{EvaluationDomain, GeneralEvaluationDomain, Polynomial as _};
use num_traits::Zero; use num_traits::Zero;
use crate::common::compute_roots_of_unity; //use crate::common::compute_roots_of_unity;
use crate::fft::{fft_fr, fft_g1, ifft_g1}; use crate::fft::{fft_fr, fft_g1, ifft_g1};
use crate::{GlobalParameters, Polynomial, Proof}; use crate::{GlobalParameters, Polynomial, Proof};
fn toeplitz1(global_parameters: &[G1Affine], polynomial_degree: usize) -> Vec<G1Affine> {
fn toeplitz1(global_parameters: &[G1Affine], polynomial_degree: usize) -> Vec<G1Projective> {
debug_assert_eq!(global_parameters.len(), polynomial_degree); debug_assert_eq!(global_parameters.len(), polynomial_degree);
debug_assert!(polynomial_degree.is_power_of_two()); debug_assert!(polynomial_degree.is_power_of_two());
let roots_of_unity = compute_roots_of_unity(polynomial_degree * 2); let domain: GeneralEvaluationDomain<Fr> =
let vector_extended: Vec<G1Affine> = global_parameters GeneralEvaluationDomain::new(polynomial_degree*2).expect("Domain should be able to build");
let vector_extended: Vec<G1Projective> = global_parameters
.iter() .iter()
.copied() .copied().map(|pi| G1Projective::from(pi))
.chain(std::iter::repeat_with(G1Affine::zero).take(polynomial_degree)) .chain(std::iter::repeat_with(G1Projective::zero).take(polynomial_degree))
.collect(); .collect();
fft_g1(&vector_extended, &roots_of_unity) domain.fft(&vector_extended)
} }
fn toeplitz2(coefficients: &[Fr], extended_vector: &[G1Affine]) -> Vec<G1Affine> { fn toeplitz2(coefficients: &[Fr], extended_vector: &[G1Projective]) -> Vec<G1Projective> {
debug_assert!(coefficients.len().is_power_of_two()); debug_assert!(coefficients.len().is_power_of_two());
// let domain: GeneralEvaluationDomain<Fr> = let domain: GeneralEvaluationDomain<Fr> =
// GeneralEvaluationDomain::new(coefficients.len()).expect("Domain should be able to build"); GeneralEvaluationDomain::new(coefficients.len()).expect("Domain should be able to build");
// let toeplitz_coefficients_fft = domain.fft(coefficients); // let toeplitz_coefficients_fft = domain.fft(coefficients);
let roots_of_unity = compute_roots_of_unity(coefficients.len()); let roots_of_unity = domain.elements().take(coefficients.len()).collect();
let toeplitz_coefficients_fft = fft_fr(coefficients, &roots_of_unity); let toeplitz_coefficients_fft = fft_fr(coefficients, &roots_of_unity);
extended_vector extended_vector
.iter() .iter()
.copied() .copied()
.zip(toeplitz_coefficients_fft) .zip(toeplitz_coefficients_fft)
.map(|(v, c)| (v * c).into_affine()) .map(|(v, c)| (v * c))
.collect() .collect()
} }
fn toeplitz3(h_extended_fft: &[G1Affine], polynomial_degree: usize) -> Vec<G1Affine> { fn toeplitz3(h_extended_fft: &[G1Projective], polynomial_degree: usize) -> Vec<G1Projective> {
let roots_of_unity: Vec<Fr> = compute_roots_of_unity(h_extended_fft.len()); let domain: GeneralEvaluationDomain<Fr> =
ifft_g1(h_extended_fft, &roots_of_unity) GeneralEvaluationDomain::new(h_extended_fft.len()).expect("Domain should be able to build");
.into_iter() domain.ifft(h_extended_fft)
.take(polynomial_degree)
.collect()
} }
pub fn fk20_batch_generate_elements_proofs( pub fn fk20_batch_generate_elements_proofs(
@ -50,7 +51,8 @@ pub fn fk20_batch_generate_elements_proofs(
let polynomial_degree = polynomial.len(); let polynomial_degree = polynomial.len();
debug_assert!(polynomial_degree <= global_parameters.powers_of_g.len()); debug_assert!(polynomial_degree <= global_parameters.powers_of_g.len());
debug_assert!(polynomial_degree.is_power_of_two()); debug_assert!(polynomial_degree.is_power_of_two());
let roots_of_unity: Vec<Fr> = compute_roots_of_unity(polynomial_degree); let domain: GeneralEvaluationDomain<Fr> =
GeneralEvaluationDomain::new(polynomial_degree).expect("Domain should be able to build");
let global_parameters: Vec<G1Affine> = global_parameters let global_parameters: Vec<G1Affine> = global_parameters
.powers_of_g .powers_of_g
.iter() .iter()
@ -66,10 +68,10 @@ pub fn fk20_batch_generate_elements_proofs(
.collect(); .collect();
let h_extended_vector = toeplitz2(&toeplitz_coefficients, &extended_vector); let h_extended_vector = toeplitz2(&toeplitz_coefficients, &extended_vector);
let h_vector = toeplitz3(&h_extended_vector, polynomial_degree); let h_vector = toeplitz3(&h_extended_vector, polynomial_degree);
fft_g1(&h_vector, &roots_of_unity) domain.fft(&h_vector)
.into_iter() .into_iter()
.map(|g1| Proof { .map(|g1| Proof {
w: g1, w: g1.into_affine(),
random_v: None, random_v: None,
}) })
.collect() .collect()
@ -78,7 +80,7 @@ pub fn fk20_batch_generate_elements_proofs(
#[cfg(test)] #[cfg(test)]
mod test { mod test {
use crate::common::compute_roots_of_unity; use crate::common::compute_roots_of_unity;
use crate::fk20::fk20_batch_generate_elements_proofs; use crate::fk20::{fk20_batch_generate_elements_proofs};
use crate::{ use crate::{
common::bytes_to_polynomial, kzg::generate_element_proof, GlobalParameters, Proof, common::bytes_to_polynomial, kzg::generate_element_proof, GlobalParameters, Proof,
BYTES_PER_FIELD_ELEMENT, BYTES_PER_FIELD_ELEMENT,
@ -107,7 +109,7 @@ mod test {
let (evals, poly) = let (evals, poly) =
bytes_to_polynomial::<BYTES_PER_FIELD_ELEMENT>(&buff, domain).unwrap(); bytes_to_polynomial::<BYTES_PER_FIELD_ELEMENT>(&buff, domain).unwrap();
let polynomial_degree = poly.len(); let polynomial_degree = poly.len();
let roots_of_unity: Vec<Fr> = compute_roots_of_unity(size); //let roots_of_unity: Vec<Fr> = compute_roots_of_unity(size);
let slow_proofs: Vec<Proof> = (0..polynomial_degree) let slow_proofs: Vec<Proof> = (0..polynomial_degree)
.map(|i| { .map(|i| {
generate_element_proof(i, &poly, &evals, &GLOBAL_PARAMETERS, domain).unwrap() generate_element_proof(i, &poly, &evals, &GLOBAL_PARAMETERS, domain).unwrap()