Crate pauliverse 

Fast stabilizer simulation for quantum error correction research.

pauliverse provides multiple stabilizer simulation implementations, each optimized for different use cases in quantum computing and quantum error correction.

These simulation algorithms are based on the framework described in arXiv:2309.08676.

Overview

This crate offers four simulation modes:

• OutcomeSpecificSimulation: Traditional simulation with random (or caller-supplied) measurement outcomes. Best for Monte Carlo sampling and estimating error rates.

• OutcomeCompleteSimulation: Tracks all possible measurement outcomes simultaneously. Achieves asymptotic speedup when enumerating outcomes.

• OutcomeFreeSimulation: Simulation without tracking specific outcomes. Minimal overhead when you only care about stabilizer state evolution up to global phase.

• FaultySimulation: Noisy simulation, combining outcome-complete simulation with Pauli frame propagation.

All simulators implement the Simulation trait.

Quick Start

use pauliverse::{OutcomeSpecificSimulation, Simulation};
use paulimer::{UnitaryOp, SparsePauli};

// Create a simple Bell state simulation
let mut sim = OutcomeSpecificSimulation::new_with_random_outcomes(2);

// Apply gates
sim.unitary_op(UnitaryOp::Hadamard, &[0]);
sim.unitary_op(UnitaryOp::ControlledX, &[0, 1]);

// Measure
let observable: SparsePauli = "ZI".parse().unwrap();
let outcome = sim.measure(&observable);

Choosing a Simulator

All simulators have worst-case complexity O(n_gates × n_qubits²), though actual cost depends on circuit composition.

Simulator	Best For	Key Advantage
OutcomeSpecificSimulation	Monte Carlo sampling with few shots	Single concrete execution path
OutcomeCompleteSimulation	Whole-circuit analysis, enumerating outcomes	Avoids re-simulating for each outcome sample
OutcomeFreeSimulation	Stabilizer queries without outcomes	Minimal overhead, no outcome tracking
FaultySimulation	Noisy simulation with error correction	Efficient frame-based noise propagation

When to use outcome-complete over outcome-specific: If you need many samples and the circuit has n_random random measurements, outcome-complete saves a factor of n_random by computing the outcome distribution once, then sampling efficiently without re-running the circuit. Outcome-complete simulation is also ideal for circuit characterizations, like verification or outcome codes.

Performance Features

• SIMD acceleration: Via binar for bit matrix operations
• Cache alignment: For efficient memory access
• Batch processing: Simulate millions of shots with minimal overhead
• Amortized enumeration: OutcomeCompleteSimulation pays circuit cost once, then permits enumeration of outcomes without re-simulating.

Architecture

Built on paulimer for Pauli and Clifford operations, which in turn uses binar for efficient bit matrix operations.

The simulation algorithms implement the general form representation described in the paper, allowing efficient tracking of measurement outcomes and their correlations with stabilizer states. This enables verification of stabilizer circuits by exhaustively characterizing their behavior across all possible measurement outcomes.

Features

Optional cargo features:

• python: Python bindings (included with paulimer Python package)

See Also

• paulimer: Pauli and Clifford algebra primitives
• binar: Efficient bit vector and matrix operations

Re-exports

pub use faulty_simulation::FaultySimulation;

pub use noise::OutcomeCondition;

pub use noise::PauliDistribution;

pub use noise::PauliFault;

pub use outcome_complete_simulation::OutcomeCompleteSimulation;

pub use outcome_free_simulation::OutcomeFreeSimulation;

pub use outcome_specific_simulation::OutcomeSpecificSimulation;

Modules

action

faulty_simulation

High-level noisy simulation using frame-based error propagation.

frame_propagator

Frame-based Pauli error propagation with O(n_gates × n_qubits) complexity.

noise

Noise instructions and Pauli distributions for faulty simulation.

outcome_complete_simulation

outcome_free_simulation

outcome_specific_simulation

sampling

Shared sampling utilities for noisy simulation.

Macros

implement_common_simulation_methods

Structs

Circuit

CircuitBuilder

A simulation that records instructions into a Circuit without tracking state.

Traits

Simulation

Common interface for stabilizer simulation.

Type Aliases

OutcomeId

QubitId