Struct PartitionRows 

pub struct PartitionRows<const W: usize> { /* private fields */ }

The p GF(2) rows part(v) = P·v that split a sum across 2^p partitions: a partition holds exactly the terms with part(v) equal to its rank.

A matrix separate from Gf2Hash’s and fixed for a run, since a row that moved as the bucket hash refines would change a term’s owner mid-run. Dependence on the bucket hash’s rows costs load balance, never correctness.

Implementations

impl<const W: usize> PartitionRows<W>

pub fn from_seed(num_qubits: usize, bits: u8, seed: u64) -> Self

Draw bits partition rows from seed, unrelated to Gf2Hash::new’s rows under the same seed.

Panics

Panics if bits > P_MAX_BITS, or in debug builds if num_qubits > 64 · W.

pub fn from_seed_excluding( num_qubits: usize, bits: u8, seed: u64, exclude_x: &[u64; W], exclude_z: &[u64; W], ) -> Self

Self::from_seed with the coordinates in (exclude_x, exclude_z) cleared from every row, so keys differing only there share a partition.

Panics

As Self::from_seed, and if bits > 0 while the exclusion covers every live column.

pub fn cut(num_qubits: usize, blocks: &[Vec<usize>]) -> Self

Rows that label a qubit cut: log2(blocks.len()) z-only rows giving block b the label b.

A term’s label is the XOR of the labels of the blocks it has odd z-weight in, so an x-only generator is local under any cut and a ZZ(i, j) bond is remote exactly when it crosses blocks. Blocks must be disjoint; qubits in no block behave as if in block 0.

Panics

Panics if blocks.len() is not a power of two or exceeds 2^P_MAX_BITS, if a qubit is >= num_qubits or appears in two blocks, or if some row would be all-zero.

pub fn none(num_qubits: usize) -> Self

The trivial partitioning: one partition, no rows.

pub fn bits(&self) -> u8

Number of partition bits.

pub fn num_partitions(&self) -> usize

Number of partitions, 1 << bits().

pub fn num_qubits(&self) -> usize

The qubit count the rows were masked against.

pub fn partition_of(&self, x: &[u64; W], z: &[u64; W]) -> u32

part(v) for a key given as separate x and z words.

pub fn rows(&self) -> (&[[u64; W]], &[[u64; W]])

The rows as (x-masks, z-masks), already masked to the live columns.

pub fn avoids(&self, mask_x: &[u64; W], mask_z: &[u64; W]) -> bool

true if no row reads a coordinate in (mask_x, mask_z), i.e. keys differing only there always share a partition.

pub fn is_independent_of(&self, hash: &Gf2Hash<W>) -> bool

true if the partition rows and hash’s active rows are jointly GF(2)-independent.

Trait Implementations

impl<const W: usize> Clone for PartitionRows<W>

fn clone(&self) -> PartitionRows<W>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<const W: usize> Debug for PartitionRows<W>

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

Formats the value using the given formatter.

impl<const W: usize> PartialEq for PartitionRows<W>

fn eq(&self, other: &PartitionRows<W>) -> 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<const W: usize> Eq for PartitionRows<W>

impl<const W: usize> StructuralPartialEq for PartitionRows<W>