Crate prism_q 

PRISM-Q, a fast Rust quantum circuit simulator.

OpenQASM 3.0 input, nine CPU backends selected at dispatch, AVX2 SIMD kernels, an optional CUDA path, an optional MPI path, QEC tooling, and Python bindings.

Quick start

use prism_q::run_qasm;

let qasm = r#"
    OPENQASM 3.0;
    include "stdgates.inc";
    qubit[2] q;
    bit[2] c;
    h q[0];
    cx q[0], q[1];
"#;

let result = run_qasm(qasm, 42).expect("parse/sim failed");
let probs = result.probabilities.expect("no probabilities").to_vec();
// Bell state: ~50% |00>, ~50% |11>
assert!((probs[0] - 0.5).abs() < 1e-10);
assert!((probs[3] - 0.5).abs() < 1e-10);

Input model

run_qasm takes OpenQASM 3.0 source; circuit::openqasm lists the supported subset.

Backends

• StatevectorBackend: full state-vector simulation
• StabilizerBackend: Clifford-only O(n^2) simulation
• SparseBackend: sparse state-vector O(k) simulation
• MpsBackend: Matrix Product State O(n * chi^2) simulation
• ProductStateBackend: per-qubit O(n) simulation for non-entangling circuits
• TensorNetworkBackend: deferred contraction for low-treewidth circuits
• FactoredBackend: dynamic split-state simulation for sparse-entanglement circuits
• FactoredStabilizerBackend: per-group tableaux for large sparse-entanglement Clifford circuits
• backend::density_matrix::DensityMatrixBackend: 4^n density matrix for exact channel semantics
• DistributedStatevectorBackend: statevector sharded across ranks (distributed feature)

Native QEC

Measurement-record QEC programs use QecProgram or parse_qec_program. run_qec_program executes supported Clifford QEC programs through packed compiled sampling with Pauli-noise annotations. run_qec_program_reference runs small correctness checks through the reference path.

Re-exports

pub use backend::density_matrix::DensityMatrixBackend;

pub use backend::distributed_statevector::DistributedStatevectorBackend;distributed

pub use backend::factored::FactoredBackend;

pub use backend::factored_stabilizer::FactoredStabilizerBackend;

pub use backend::mps::MpsBackend;

pub use backend::product::ProductStateBackend;

pub use backend::sparse::SparseBackend;

pub use backend::stabilizer::StabilizerBackend;

pub use backend::statevector::StatevectorBackend;

pub use backend::tensornetwork::TensorNetworkBackend;

pub use circuit::builder::CircuitBuilder;

pub use circuit::dynamic::DynamicProgram;

pub use circuit::dynamic::DynamicProgramBuilder;

pub use circuit::Circuit;

pub use circuit::ClassicalCondition;

pub use circuit::Instruction;

pub use circuit::ParamLink;

pub use circuit::Parameters;

pub use circuit::PreparedCircuit;

pub use circuit::SaveRecord;

pub use circuit::SaveSpec;

pub use circuit::SavedValue;

pub use circuit::SvgOptions;

pub use circuit::TextOptions;

pub use distributed::DistributedContext;distributed

pub use distributed::RankComm;distributed

pub use distributed::SerialComm;distributed

pub use error::PrismError;

pub use error::ResourceKind;

pub use error::ResourceLimit;

pub use error::Result;

pub use gates::BatchPhaseData;

pub use gates::Gate;

pub use gates::GeneratorKind;

pub use gates::McuData;

pub use gates::Multi2qData;

pub use gates::MultiFusedData;

pub use gates::UnitaryData;

pub use qec::BpMethod;

pub use qec::BpOsdDecoder;

pub use qec::BpOsdOptions;

pub use qec::DetectorErrorModel;

pub use qec::ErrorMechanism;

pub use qec::MatchingDecoder;

pub use qec::OsdMethod;

pub use qec::QecBasis;

pub use qec::QecCircuitNoise;

pub use qec::QecCompiledRows;

pub use qec::QecMeasurementRow;

pub use qec::QecNoise;

pub use qec::QecObservableEstimate;

pub use qec::QecObservableReroute;

pub use qec::QecOp;

pub use qec::QecOptions;

pub use qec::QecPauli;

pub use qec::QecProgram;

pub use qec::QecRecordRef;

pub use qec::QecSampleResult;

pub use qec::QecTStrategy;

pub use qec::UnionFindDecoder;

pub use qec::compile_qec_program_rows;

pub use qec::parse_qec_program;

pub use qec::run_qec_program;

pub use qec::run_qec_program_reference;

pub use qec::run_qec_program_spd_rerouted;

pub use qec::run_qec_program_with_strategy;

pub use sim::calibration::DeviceCalibration;

pub use sim::calibration::GateCalibration;

pub use sim::calibration::GateTimes;

pub use sim::calibration::QubitCalibration;

pub use sim::compiled::CompiledDetectorSampler;

pub use sim::compiled::CompiledSampler;

pub use sim::compiled::CorrelatorAccumulator;

pub use sim::compiled::DetectorSampleBatch;

pub use sim::compiled::HistogramAccumulator;

pub use sim::compiled::MarginalsAccumulator;

pub use sim::compiled::NullAccumulator;

pub use sim::compiled::PackedShots;

pub use sim::compiled::ParityStats;

pub use sim::compiled::PauliExpectationAccumulator;

pub use sim::compiled::ShotAccumulator;

pub use sim::compiled::ShotLayout;

pub use sim::compiled::compile_detector_sampler;

pub use sim::compiled::compile_forward;

pub use sim::compiled::compile_measurements;

pub use sim::compiled::run_shots_compiled;

pub use sim::gradient::ExpectationGradient;

pub use sim::gradient::run_expectation_gradient;

pub use sim::gradient::run_expectation_gradient_shift;

pub use sim::homological::ErrorChainComplex;

pub use sim::homological::noisy_marginals_analytical;

pub use sim::noise::DriftDistribution;

pub use sim::noise::GateFilter;

pub use sim::noise::NoiseBuilder;

pub use sim::noise::NoiseChannel;

pub use sim::noise::NoiseEvent;

pub use sim::noise::NoiseModel;

pub use sim::noise::NoisyCompiledSampler;

pub use sim::noise::ReadoutError;

pub use sim::noise::compile_noisy;

pub use sim::noise::density_matrix_expectation_values;

pub use sim::noise::run_shots_noisy;

pub use sim::stabilizer_rank::StabRankResult;

pub use sim::stabilizer_rank::run_stabilizer_rank;

pub use sim::stabilizer_rank::run_stabilizer_rank_approx;

pub use sim::stabilizer_rank::stabilizer_inner_product;

pub use sim::stabilizer_rank::stabilizer_overlap_sq;

pub use sim::unified_pauli::PauliAxis;

pub use sim::unified_pauli::PauliTerm;

pub use sim::unified_pauli::SpdObservableResult;

pub use sim::unified_pauli::SpdResult;

pub use sim::unified_pauli::SpdTruncation;

pub use sim::unified_pauli::SppObservableResult;

pub use sim::unified_pauli::SppResult;

pub use sim::unified_pauli::inverse_light_cone;

pub use sim::unified_pauli::run_spd;

pub use sim::unified_pauli::run_spd_observable;

pub use sim::unified_pauli::run_spd_observable_budgeted;

pub use sim::unified_pauli::run_spd_observable_light_cone;

pub use sim::unified_pauli::run_spd_with;

pub use sim::unified_pauli::run_spp;

pub use sim::unified_pauli::run_spp_observable;

pub use sim::BackendKind;

pub use sim::BondReport;

pub use sim::CountsResult;

pub use sim::Engine;

pub use sim::EntropyResult;

pub use sim::Exactness;

pub use sim::ExpectationResult;

pub use sim::FactoredBlock;

pub use sim::MarginalsResult;

pub use sim::ObservableExpectation;

pub use sim::ObservableVariance;

pub use sim::OverlapResult;

pub use sim::PauliObservable;

pub use sim::Placement;

pub use sim::Probabilities;

pub use sim::ReducedDensityMatrix;

pub use sim::ResolvedBackend;

pub use sim::RunMetadata;

pub use sim::RunOutcome;

pub use sim::Seeded;

pub use sim::ShotsResult;

pub use sim::Simulate;

pub use sim::SimulateProgram;

pub use sim::Unseeded;

pub use sim::bitstring;

pub use sim::run_expectation_values;

pub use sim::run_observable_expectation;

pub use sim::run_on;

pub use sim::run_on_state;

pub use sim::run_qasm;

pub use sim::simulate;

pub use sim::simulate_program;

pub use threading::ThreadPool;parallel

pub use sim::compiled::DevicePackedShots;gpu

pub use sim::compiled::run_shots_compiled_with_gpu;gpu

Modules

backend

Simulation backend trait and implementations.

circuit

Backend-agnostic circuit IR that every frontend lowers into.

circuits

Benchmark and test circuit builders. Randomized builders use ChaCha8Rng, so output is fixed per seed.

distributeddistributed

Distributed context, rank transport, and tuning thresholds.

error

Error types for PRISM-Q.

gates

Gate definitions and matrix representations.

gpugpu

GPU execution context that CPU backends attach to route their hot kernels to a CUDA device, plus the device statevector and tableau types.

qec

Measurement-record QEC programs (QecProgram): parser, runners, detector error models, and decoders. The IR is separate from Circuit so measurement records need not fit final-measurement OpenQASM semantics.

sim

Simulation orchestration: routes a circuit to a backend and answers the terminal queries. Entry points: simulate, run_qasm, run_on.

threadingparallel

Caller-supplied Rayon pool, for embedding PRISM-Q in an application that owns the process-wide pool.