switched to PrimeField32 and debbuging

Author: CarloModicaPortfolio

keccak-air/src/columns.rs

@@ -1,4 +1,6 @@
 use core::borrow::{Borrow, BorrowMut};
+use core::array;
+use core::fmt::{Debug, Formatter, Result};
 use core::mem::{size_of, transmute};
 
 use p3_util::indices_arr;
@@ -62,24 +64,43 @@ pub struct KeccakCols<T> {
     pub a_prime_prime_prime_0_0_limbs: [T; U64_LIMBS],
 }
 
-impl<T: Default + Copy> Default for KeccakCols<T> {
+impl<T: Default> Default for KeccakCols<T> {
     fn default() -> Self {
         Self {
-            step_flags: [T::default(); NUM_ROUNDS],
+            step_flags: array::from_fn(|_| T::default()),
             export: T::default(),
-            preimage: [[[T::default(); U64_LIMBS]; 5]; 5],
-            postimage: [[[T::default(); U64_LIMBS]; 5]; 5],
-            a: [[[T::default(); U64_LIMBS]; 5]; 5],
-            c: [[T::default(); 64]; 5],
-            c_prime: [[T::default(); 64]; 5],
-            a_prime: [[[T::default(); 64]; 5]; 5],
-            a_prime_prime: [[[T::default(); U64_LIMBS]; 5]; 5],
-            a_prime_prime_0_0_bits: [T::default(); 64],
-            a_prime_prime_prime_0_0_limbs: [T::default(); U64_LIMBS],
+            preimage: array::from_fn(|_| array::from_fn(|_| array::from_fn(|_| T::default()))),
+            postimage: array::from_fn(|_| array::from_fn(|_| array::from_fn(|_| T::default()))),
+            a: array::from_fn(|_| array::from_fn(|_| array::from_fn(|_| T::default()))),
+            c: array::from_fn(|_| array::from_fn(|_| T::default())),
+            c_prime: array::from_fn(|_| array::from_fn(|_| T::default())),
+            a_prime: array::from_fn(|_| array::from_fn(|_| array::from_fn(|_| T::default()))),
+            a_prime_prime: array::from_fn(|_| array::from_fn(|_| array::from_fn(|_| T::default()))),
+            a_prime_prime_0_0_bits: array::from_fn(|_| T::default()),
+            a_prime_prime_prime_0_0_limbs: array::from_fn(|_| T::default()),
         }
     }
 }
 
+impl<T: Debug> Debug for KeccakCols<T> {
+    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
+        f.debug_struct("KeccakCols")
+            .field("step_flags", &self.step_flags)
+            .field("export", &self.export)
+            .field("preimage", &self.preimage)
+            .field("postimage", &self.postimage)
+            .field("a", &self.a)
+            .field("c", &self.c)
+            .field("c_prime", &self.c_prime)
+            .field("a_prime", &self.a_prime)
+            .field("a_prime_prime", &self.a_prime_prime)
+            .field("a_prime_prime_0_0_bits", &self.a_prime_prime_0_0_bits)
+            .field("a_prime_prime_prime_0_0_limbs", &self.a_prime_prime_prime_0_0_limbs)
+            .finish()
+    }
+}
+
+
 impl<T: Copy> KeccakCols<T> {
     pub fn b(&self, x: usize, y: usize, z: usize) -> T {
         debug_assert!(x < 5);

keccak-air/src/generation.rs

@@ -1,7 +1,7 @@
 use alloc::vec;
 use alloc::vec::Vec;
 use core::iter;
-use p3_field::PrimeField64;
+use p3_field::PrimeField32;
 use p3_matrix::dense::RowMajorMatrix;
 use tracing::instrument;
 
@@ -11,7 +11,7 @@ use crate::logic::{andn, xor};
 use crate::{BITS_PER_LIMB, NUM_ROUNDS, U64_LIMBS};
 
 #[instrument(name = "generate Keccak trace", skip_all)]
-pub fn generate_trace_rows<F: PrimeField64>(inputs: Vec<[u64; 25]>) -> RowMajorMatrix<F> {
+pub fn generate_trace_rows<F: PrimeField32>(inputs: Vec<[u64; 25]>) -> RowMajorMatrix<F> {
     let used_rows = inputs.len() * NUM_ROUNDS + 1;
     let num_rows = used_rows.next_power_of_two();
     let mut trace =
@@ -46,7 +46,7 @@ pub fn generate_trace_rows<F: PrimeField64>(inputs: Vec<[u64; 25]>) -> RowMajorM
 }
 
 /// `rows` will normally consist of 24 rows, with an exception for the final row.
-fn generate_trace_rows_for_perm<F: PrimeField64>(rows: &mut [KeccakCols<F>], input: [u64; 25]) {
+fn generate_trace_rows_for_perm<F: PrimeField32>(rows: &mut [KeccakCols<F>], input: [u64; 25]) {
     // Populate the preimage for each row.
     for row in rows.iter_mut() {
         for y in 0..5 {
@@ -86,7 +86,7 @@ fn generate_trace_rows_for_perm<F: PrimeField64>(rows: &mut [KeccakCols<F>], inp
     }
 }
 
-fn generate_trace_row_for_round<F: PrimeField64>(row: &mut KeccakCols<F>, round: usize) {
+fn generate_trace_row_for_round<F: PrimeField32>(row: &mut KeccakCols<F>, round: usize) {
     row.step_flags[round] = F::one();
 
     // Populate C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4]).

keccak-air/src/logic.rs

@@ -1,6 +1,6 @@
-use p3_field::{AbstractField, PrimeField64};
+use p3_field::{AbstractField, PrimeField32};
 
-pub(crate) fn xor<F: PrimeField64, const N: usize>(xs: [F; N]) -> F {
+pub(crate) fn xor<F: PrimeField32, const N: usize>(xs: [F; N]) -> F {
     xs.into_iter().fold(F::zero(), |acc, x| {
         debug_assert!(x.is_zero() || x.is_one());
         F::from_canonical_u64(acc.as_canonical_u64() ^ x.as_canonical_u64())
@@ -17,7 +17,7 @@ pub fn xor3_gen<AF: AbstractField>(x: AF, y: AF, z: AF) -> AF {
     xor_gen(x, xor_gen(y, z))
 }
 
-pub(crate) fn andn<F: PrimeField64>(x: F, y: F) -> F {
+pub(crate) fn andn<F: PrimeField32>(x: F, y: F) -> F {
     debug_assert!(x.is_zero() || x.is_one());
     debug_assert!(y.is_zero() || y.is_one());
     let x = x.as_canonical_u64();