Struct FactoredCircuitFactory 

pub struct FactoredCircuitFactory<EF> { /* private fields */ }

Factory caching the order-invariant parts of a factored multi-AIR composition.

Implementations

impl<EF> FactoredCircuitFactory<EF>

where EF: ExtensionField<Felt>,

pub fn new(factored: FactoredMultiAirCircuit<EF>) -> Result<Self, AceError>

Build the factory, fixing the order-invariant stream sections.

Encodes the canonical (identity) order once to fix the constants and common sections, then proves the encode-only leaf path against that assembled stream on the deployed composition: the canonical order’s shuffle window must match byte for byte, and the resumed sponge must reproduce the digest of the full prefix. Divergence between the two paths is configuration-dependent (it hides in the padding arithmetic), so a fixture test elsewhere cannot stand in for this check.

pub fn factored(&self) -> &FactoredMultiAirCircuit<EF>

The factored composition this factory serves.

pub fn const_felts(&self) -> usize

Felt length of the order-invariant constants section.

pub fn leaf_for_order( &self, proof_order: &[usize], buffer: &mut ShuffleEncodeBuffer, ) -> Result<Word, AceError>

Compute the registry leaf for one proof order without assembling its circuit.

Encodes only the shuffle section into buffer and resumes the cached post-constants sponge state, so a caller enumerating every ordering pays per leaf only the per-order bytes and their hash — this is what makes an n!-leaf registry build feasible. Equality with Self::circuit_for_order’s commitment is pinned at construction (canonical order) and must be re-pinned per order wherever a registry is minted.

pub fn leaves_for_orders( &self, orders: &[&[usize]], scratch: &mut PackedLeafScratch, out: &mut Vec<Word>, ) -> Result<(), AceError>

Compute registry leaves for a batch of proof orders, hashing LEAF_LANES orders per packed Poseidon2 permutation.

Produces exactly the leaves Self::leaf_for_order produces, in order — the shuffle sections of every proof order have identical length, which is what makes lane-lockstep absorption sound. Chunks shorter than LEAF_LANES (the batch tail) pad unused lanes with the last order and discard the duplicates, so the packed path is the only code path. Equality with the scalar path is pinned by packed_leaves_match_the_scalar_path and, wherever a registry is minted, by the per-order dual-path check (whose assembled side hashes scalar).

pub fn circuit_for_order( &self, proof_order: &[usize], ) -> Result<FactoredEncodedCircuit, AceError>

Assemble, encode, and hash the circuit for one proof order.

Only the shuffle section is hashed live (resuming from the cached post-constants sponge state); the common-section digest is reused. The resulting commitments are definitionally equal to hashing the full stream segments, which the caller’s segment tests pin per order.