Struct KeccakCols

#[repr(C)]
pub struct KeccakCols<T> {
    pub step_flags: [T; 24],
    pub export: T,
    pub preimage: [[[T; 4]; 5]; 5],
    pub a: [[[T; 4]; 5]; 5],
    pub c: [[T; 64]; 5],
    pub c_prime: [[T; 64]; 5],
    pub a_prime: [[[T; 64]; 5]; 5],
    pub a_prime_prime: [[[T; 4]; 5]; 5],
    pub a_prime_prime_0_0_bits: [T; 64],
    pub a_prime_prime_prime_0_0_limbs: [T; 4],
}

Note: The ordering of each array is based on the input mapping. As the spec says,

The mapping between the bits of s and those of a is s[w(5y + x) + z] = a[x][y][z].

Thus, for example, a_prime is stored in y, x, z order. This departs from the more common convention of x, y, z order, but it has the benefit that input lists map to AIR columns in a nicer way.

Fields

step_flags: [T; 24]

The ith value is set to 1 if we are in the ith round, otherwise 0.

export: T

A register which indicates if a row should be exported, i.e. included in a multiset equality argument. Should be 1 only for certain rows which are final steps, i.e. with step_flags[23] = 1.

preimage: [[[T; 4]; 5]; 5]

Permutation inputs, stored in y-major order.

a: [[[T; 4]; 5]; 5]

c: [[T; 64]; 5]

C[x] = xor(A[x, 0], A[x, 1], A[x, 2], A[x, 3], A[x, 4])

c_prime: [[T; 64]; 5]

C'[x, z] = xor(C[x, z], C[x - 1, z], C[x + 1, z - 1])

a_prime: [[[T; 64]; 5]; 5]

A'[x, y] = xor(A[x, y], D[x])
         = xor(A[x, y], C[x - 1], ROT(C[x + 1], 1))

a_prime_prime: [[[T; 4]; 5]; 5]

A''[x, y] = xor(B[x, y], andn(B[x + 1, y], B[x + 2, y])).

a_prime_prime_0_0_bits: [T; 64]

The bits of A''[0, 0].

a_prime_prime_prime_0_0_limbs: [T; 4]

A'''[0, 0, z] = A''[0, 0, z] ^ RC[k, z]

Implementations

impl<T: Copy> KeccakCols<T>

pub fn b(&self, x: usize, y: usize, z: usize) -> T

pub fn a_prime_prime_prime(&self, y: usize, x: usize, limb: usize) -> T

Trait Implementations

impl<T> Borrow<KeccakCols<T>> for [T]

fn borrow(&self) -> &KeccakCols<T>

Immutably borrows from an owned value.

impl<T> BorrowMut<KeccakCols<T>> for [T]

fn borrow_mut(&mut self) -> &mut KeccakCols<T>

Mutably borrows from an owned value.

impl<T: Debug> Debug for KeccakCols<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.