Struct CollapseSample 

pub struct CollapseSample {
    pub cache: usize,
    pub seed: u64,
    /* private fields */
}

Replace the sum by one Pauli string, drawn with probability |c|² / Σ|c|² and given coefficient 1, whenever it holds more than cache terms.

One seed is one Monte Carlo trajectory: the draw at the k-th layer pass is a function of (seed, k) only, and the pass counter lives in the policy, so reusing a policy continues its sequence. Partitioned runs agree with unpartitioned ones in distribution, not string for string, and count passes and collapses on rank 0’s policy only. A collapse panics if the sum’s total weight is zero or not finite.

Fields

cache: usize

Largest sum left untouched.

seed: u64

Trajectory seed.

Implementations

impl CollapseSample

pub fn new(cache: usize, seed: u64) -> Self

A fresh trajectory: collapse above cache terms, draws keyed by seed.

pub fn collapses(&self) -> u64

Collapses performed so far (rank 0’s count in partitioned mode).

Trait Implementations

impl Debug for CollapseSample

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

Formats the value using the given formatter.

impl From<CollapseSample> for BuiltinTruncation

fn from(p: CollapseSample) -> Self

Converts to this type from the input type.

impl PartialEq for CollapseSample

Equal when cache, seed and both counters are.

fn eq(&self, other: &Self) -> 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> TruncationPolicy<W> for CollapseSample

fn finalize_layer_partitioned( &self, local: &mut PauliSum<W>, collectives: &dyn Collectives, )

Reduces [len, pass] (the pass from rank 0) and the per-partition Σ|c|², then picks a partition by weight and a term within it, as finalize_layer picks a bucket and then a term.

fn finalize_layer(&self, sum: &mut PauliSum<W>)

Pass over the whole sum after each layer; PauliSum::retain is the easy way to write a filter here.

fn supports_partitioned(&self) -> bool

Whether finalize_layer_partitioned runs above one partition; every partitioned driver checks it before the first layer.

fn keep_term(&self, _x: &[u64; W], _z: &[u64; W], _c: Complex64) -> bool

Per-term filter, run inside the merge on every output, so it must be cheap.

fn finalizes_layer(&self) -> bool

Whether finalize_layer does anything, a hint that lets the engine skip it.