Enum InputKey 

pub enum InputKey {
    Public(usize),
    AuxRandAlpha,
    AuxRandBeta,
    Main {
        offset: usize,
        index: usize,
    },
    AuxCoord {
        offset: usize,
        index: usize,
        coord: usize,
    },
    AuxBusBoundary(usize),
    Z,
    Alpha,
    ZPowN,
    GInv,
    GInv2,
    ZK,
    Weight0,
    G,
    S0,
    InvZMinusGInv,
    InvZMinusOne,
    InvVanishing,
    QuotientChunkCoord {
        offset: usize,
        chunk: usize,
        coord: usize,
    },
}

Logical inputs required by the ACE circuit.

Variants

Public(usize)

Public input at the given index.

AuxRandAlpha

Aux randomness α supplied as an input.

AuxRandBeta

Aux randomness β supplied as an input.

Main

Main trace value at (offset, index).

Fields

offset: usize

index: usize

AuxCoord

Base-field coordinate for an aux trace column.

Fields

offset: usize

index: usize

coord: usize

AuxBusBoundary(usize)

Aux bus boundary value at the given index.

Z

Out-of-domain evaluation point zeta.

Alpha

Composition challenge used to fold constraints.

ZPowN

zeta^N, where N is the trace length.

GInv

g^{-1}, inverse trace domain generator.

GInv2

g^{-2}, squared inverse trace domain generator.

ZK

zeta^(N / max_cycle_len) for periodic columns.

Weight0

First barycentric weight for quotient recomposition.

G

g = h^N, the chunk shift ratio.

S0

s0 = offset^N, the first chunk shift.

InvZMinusGInv

1 / (zeta - g^{-1}) (selector denominator).

InvZMinusOne

1 / (zeta - 1) (selector denominator).

InvVanishing

1 / (zeta^N - 1) (vanishing inverse).

QuotientChunkCoord

Base-field coordinate for a quotient chunk opening at offset (0 = zeta, 1 = g * zeta).

Fields

offset: usize

chunk: usize

coord: usize

Trait Implementations

impl Clone for InputKey

fn clone(&self) -> InputKey

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InputKey

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

Formats the value using the given formatter.

impl Hash for InputKey

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for InputKey

fn eq(&self, other: &InputKey) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for InputKey

impl Eq for InputKey

impl StructuralPartialEq for InputKey