open-standards/wai/wai-quantum/Cargo.toml

[package]
name = "wai-quantum"
version = "0.6.14"
edition = "2024"
rust-version = "1.97"
license = "Apache-2.0"
description = "A deterministic quantum stack in pure Rust: byte-exact circuit simulation (statevector / stabilizer / tensor-network MPS / sparse-Pauli backends), sparse Pauli dynamics at utility scale (arbitrary angles, 1024 qubits), belief-propagation tensor networks on the hardware graph, error mitigation, qLDPC decoding, noise learning, circuit-equivalence proofs, a phasor interference-ML layer, information-theoretic limits, noisy channels and state tomography, and signed energy-accounted receipts. No QPU, no cloud, no system libraries in the default features — identical results native, in the browser, and as a WASI component at the edge; the opt-in WebGPU member reaches the platform's GPU interface."
repository = "https://git.transaction.science/Transaction-Science/open-standards"
homepage = "https://wai.transaction.science/quantum-ide"
documentation = "https://docs.rs/wai-quantum"
keywords = ["quantum", "simulation", "wasm", "deterministic", "qec"]
categories = ["science", "simulation", "wasm", "mathematics"]
readme = "README.md"
# Holds a file outside this package (quantum-conformance/fabric/expected.json) to
# the crate; it runs in the repository only.
exclude = ["tests/fabric_expected.rs"]

# docs.rs builds with DEFAULT features only, which would document 3 of 21
# modules and hide the entire operational + ML layers. Document everything.
[package.metadata.docs.rs]
all-features = true

[dependencies]
# Hashes for circuit / statevector / receipt identity. Required: the base
# `quantum` feature binds every reconstruction to a BLAKE3 hash.
blake3 = "1"
# Canonical receipt JSON (sorted keys, byte-stable round-trip).
serde_json = { version = "1", features = ["preserve_order"] }
# The engine's request and plan types (feature quantum_engine).
serde = { version = "1", features = ["derive"], optional = true }
# Receipt signatures. Optional — only the sealing features need it.
ed25519-dalek = { version = "2", optional = true }

# The WebGPU member of the fabric: the gate kernel in WGSL through the platform's
# GPU interface natively, and through a browser's WebGPU on wasm32-unknown-unknown.
# Absent on every other target; wasm32-wasip2 has no GPU interface.
[target.'cfg(not(target_arch = "wasm32"))'.dependencies]
wgpu = { version = "30.0.1", optional = true, default-features = false, features = ["std", "wgsl", "metal", "vulkan", "dx12"] }
# The CUDA member: the driver and the runtime compiler are loaded when first used,
# so a build with the feature needs no CUDA installed and finds no member where
# there is none.
cudarc = { version = "0.19.10", optional = true, default-features = false, features = ["std", "driver", "nvrtc", "dynamic-loading", "cuda-12080"] }
# The OpenCL member: the ICD loader is opened when first used, so a build with the
# feature needs no OpenCL installed and finds no member where there is none.
opencl3 = { version = "0.12.3", optional = true, default-features = false, features = ["dynamic"] }

# The neural-processor member: the platform's model runtime on macOS, its
# framework loaded by the system; absent on every other target.
[target.'cfg(target_os = "macos")'.dependencies]
objc2 = { version = "0.6.5", optional = true }
block2 = { version = "0.6.2", optional = true }
objc2-foundation = { version = "0.3.2", optional = true, default-features = false, features = ["std", "NSArray", "NSDictionary", "NSError", "NSProcessInfo", "NSString", "NSURL", "NSValue"] }
objc2-core-ml = { version = "0.3.2", optional = true, default-features = false, features = [
    "std", "block2", "MLModel", "MLModel_MLModelCompilation", "MLModelConfiguration", "MLMultiArray", "MLDictionaryFeatureProvider",
    "MLFeatureProvider", "MLFeatureValue", "MLComputePlan", "MLComputePlanDeviceUsage", "MLComputeDeviceProtocol",
    "MLNeuralEngineComputeDevice", "MLModelStructure", "MLModelStructureProgram", "MLModelStructureProgramFunction",
    "MLModelStructureProgramBlock", "MLModelStructureProgramOperation",
] }
# The Metal member: the platform's GPU interface, its kernels compiled at run
# time by the system's own compiler.
objc2-metal = { version = "0.3.2", optional = true, default-features = false, features = [
    "std", "MTLAllocation", "MTLBuffer", "MTLCommandBuffer", "MTLCommandEncoder", "MTLCommandQueue", "MTLComputeCommandEncoder",
    "MTLComputePipeline", "MTLDevice", "MTLLibrary", "MTLPipeline", "MTLResource", "MTLTypes",
] }

[target.'cfg(all(target_arch = "wasm32", target_os = "unknown"))'.dependencies]
wgpu = { version = "30.0.1", optional = true, default-features = false, features = ["std", "wgsl", "webgpu"] }

[features]
default = ["quantum", "quantum_toolchain", "quantum_receipt"]

# Internal: signature support, pulled in by every sealing feature.
# (Mirrors the `world` feature in the parent `wai` crate.)
_signing = ["dep:ed25519-dalek"]

# --- core simulation -------------------------------------------------------
quantum = []
quantum_toolchain = ["quantum"]
quantum_mps = ["quantum"]
quantum_stabilizer = ["quantum"]
quantum_tableau = []
# Exact amplitudes, probabilities and samples of a Clifford circuit measured in a
# product basis, at a cost set by its cut-rank (src/quantum_cutrank.rs).
quantum_cutrank = ["quantum_tableau", "quantum_sv"]
# OpenQASM 3 (and the OpenQASM 2 forms in common use) read to one program and
# lowered to each method's input (src/qasm.rs).
quantum_qasm = ["quantum", "quantum_sv", "quantum_spd", "quantum_tableau"]
quantum_mpsim = ["quantum_sv", "quantum_mps"]
# The job service's engine: a request planned onto a method, run, and answered
# as the service's JSON, for every host that runs jobs (src/engine/). Numbers
# are read correctly rounded, so a result a client sends back reads as the
# double it was.
quantum_engine = ["quantum_qasm", "quantum_tn", "quantum_cutrank", "quantum_mpsim", "quantum_noisy", "dep:serde", "serde_json/float_roundtrip"]
quantum_pauli = ["quantum"]
# Sparse Pauli dynamics at utility scale: arbitrary-angle Pauli rotations on up
# to 1024 qubits, reproducible bit for bit, with a rigorous truncation bound.
# Independent of the dyadic core; `from_dyadic` appears when `quantum` is on.
quantum_spd = []
# Signed, energy-accounted receipts for it, re-checkable bit for bit anywhere.
quantum_spd_receipt = ["quantum_spd", "_signing"]
# Tensor-network states on the hardware graph: simple-update evolution, belief-
# propagation environments; exact on trees, an independent check on loopy graphs.
quantum_bptn = ["quantum_spd"]
# Fault-tolerant resource estimation: logical layout, code distance, exhaustive
# T-factory search and the space-time frontier, reproducible bit for bit.
quantum_resource = []
# Signed, energy-accounted receipts for it, re-checkable bit for bit anywhere.
quantum_resource_receipt = ["quantum_resource", "_signing"]
# Noisy Clifford circuits at QEC scale: bit-packed Pauli-frame sampling, detector
# error models by backward sensitivity, and exact minimum-weight matching.
quantum_frame = []
# Tensor-network contraction: hyper-optimised contraction trees, slicing, and
# amplitudes of circuits far past the state vector, reproducible bit for bit.
quantum_tn = []
# Gaussian boson sampling, exactly: hafnians, torontonians, lossy Gaussian states,
# pattern probabilities, exact samples and the marginals any sampler must match.
quantum_gbs = []
# The dense state vector at any angle: gate fusion, diagonal fast paths, threads,
# the same bits everywhere.
quantum_sv = []
# Architecture-level estimation: yoked storage, magic-state cultivation, CCZ
# factories and reaction-limited time, assembled into whole-machine estimates.
quantum_arch = []
# qLDPC memory at circuit level: bivariate-bicycle codes, their depth-8 syndrome
# cycle, and BP-OSD decoding of the circuit's error model.
quantum_ldpc = ["quantum_frame"]
# Quantum-inspired optimisation: simulated bifurcation (ballistic, discrete,
# heated), simulated annealing and an exact referee, on Ising and Max-Cut.
quantum_qio = []
# Union-find decoding in near-linear time over the matching graph.
quantum_uf = ["quantum_frame"]
# Noisy circuits: quantum trajectories on the state vector, an exact density-
# matrix referee, and cross-entropy fidelity against the digital error model.
quantum_noisy = ["quantum_sv"]
# Ground states of spin chains by two-site DMRG, held to exact diagonalisation
# and to the free-fermion solution of the transverse-field Ising chain.
quantum_dmrg = []
# Time evolution of spin chains by the time-dependent variational principle,
# held to exact evolution and to the free-fermion solution of a quench.
quantum_tdvp = ["quantum_dmrg"]
# Molecules by DMRG: FCIDUMP integrals, the second-quantised Hamiltonian as an
# exact MPO, and full configuration interaction as the referee.
quantum_chem = ["quantum_dmrg"]
# Neural quantum states: a restricted Boltzmann machine trained by variational
# Monte Carlo with stochastic reconfiguration, held to exact diagonalisation
# and DMRG on chains and square lattices.
quantum_nqs = ["quantum_dmrg"]
# Mixed states and the observables that distinguish quantum theory from a classical
# account: density matrices, the partial trace, exact Pauli expectations, CHSH.
quantum_info = ["quantum"]
# Qubits AND qutrits: the Weyl-Heisenberg group, the Fourier gate over Z_d, and
# the controlled sum. Exact for d = 2 and 3; other dimensions are refused.
quantum_qudit = ["quantum"]
# Quantum communication and security: BB84 key distribution with an
# intercept-resend eavesdropper, and the no-cloning theorem priced.
quantum_comm = ["quantum"]
# What quantum theory says about encoding and transport: von Neumann entropy, the
# Schumacher limit, and the Holevo bound that refuses classical compression.
quantum_source = ["quantum", "quantum_info"]
# Transport itself: Kraus channels, and tomography to see what arrived.
quantum_channel = ["quantum", "quantum_info", "quantum_source"]
# QIR (LLVM-based quantum IR) export — the compiler-facing sibling of OpenQASM.
quantum_qir = ["quantum", "quantum_toolchain"]

# --- receipts & operations -------------------------------------------------
quantum_receipt = ["quantum", "_signing"]
quantum_ops = ["_signing"]
quantum_cal = ["quantum_ops"]
quantum_mitigate = ["quantum_ops"]
quantum_qec = ["quantum_ops"]
quantum_control = ["quantum_cal"]
quantum_noise = ["quantum_cal"]
quantum_compile = ["quantum_ops"]
quantum_atom = ["quantum_ops"]
quantum_qbom = ["quantum_ops"]
# The fabric: members, parity against the CPU reference, certification,
# placement by joules, and a signed receipt naming where a result ran. With the
# fixed-point core in 32-bit lanes, the kernel an integer-only fabric runs.
quantum_fabric = ["quantum", "quantum_ops", "quantum_toolchain"]
# The WebGPU member: one WGSL kernel on Metal, Vulkan, DX12 or a browser's
# WebGPU, certified bit-exact against the CPU reference on each adapter. Opt-in,
# and not in `full`: it is the one feature that reaches a platform interface.
quantum_fabric_webgpu = ["quantum_fabric", "dep:wgpu"]
# The CUDA member of the fabric (an NVIDIA GPU, native targets only).
quantum_fabric_cuda = ["quantum_fabric", "dep:cudarc"]
# The HIP member of the fabric (a GPU the HIP runtime drives, Linux): the CUDA kernel's text, built by HIP's runtime compiler; both libraries loaded at run time.
quantum_fabric_hip = ["quantum_fabric"]
quantum_fabric_opencl = ["quantum_fabric", "dep:opencl3"]
# The simulated FPGA member: Verilator, invoked at run time, compiles the datapath.
quantum_fabric_fpga = ["quantum_fabric"]
# The neural-processor member: exact fp16 limb products on the platform's neural processor.
quantum_fabric_npu = ["quantum_fabric", "dep:objc2", "dep:block2", "dep:objc2-foundation", "dep:objc2-core-ml"]
quantum_fabric_metal = ["quantum_fabric", "dep:objc2", "dep:objc2-foundation", "dep:objc2-metal"]
# The dense state vector in single precision on the platform's GPU (macOS).
quantum_sv_metal = ["quantum_sv", "dep:objc2", "dep:objc2-foundation", "dep:objc2-metal"]
# The cut-rank table in single precision on the platform's GPU (macOS).
quantum_cutrank_metal = ["quantum_cutrank", "dep:objc2", "dep:objc2-foundation", "dep:objc2-metal"]
# The npu-cores member: the gate's arithmetic on a neural processor's compute core, programmed directly (Linux): the program built by the tile array's open toolchain, the host side compiled against the device runtime, both at run time.
quantum_fabric_npu_cores = ["quantum_fabric"]
# The tensor-engine member: the gate's products as exact bf16 limb convolutions on a tensor processor's matrix engine, through its kernel toolchain's Python run as a helper.
quantum_fabric_tensor_engine = ["quantum_fabric"]
# The matrix-extension member: the gate's arithmetic in the processor's streaming vector mode (SME).
quantum_fabric_sme = ["quantum_fabric"]
# The DSP vector-unit member: the gate's arithmetic in the signal processor's vector unit.
quantum_fabric_dsp = ["quantum_fabric"]
# The CPU vector-unit members: the gate's arithmetic in the processor's vector extension (avx2, sve, rvv).
quantum_fabric_vector = ["quantum_fabric"]
# The dataflow member: the gate's arithmetic on a dataflow accelerator's RISC-V cores, through a device library loaded at run time.
quantum_fabric_dataflow = ["quantum_fabric"]

# --- interference / ML layer ----------------------------------------------
quantum_vml = []
quantum_phasor = []
quantum_qfhrr = ["quantum_vml"]
quantum_kernel = []
quantum_qdata = []
quantum_phasor_meter = ["_signing"]

# Everything.
full = [
    "quantum", "quantum_toolchain", "quantum_mps", "quantum_stabilizer", "quantum_tableau", "quantum_cutrank", "quantum_qasm", "quantum_engine", "quantum_mpsim", "quantum_pauli", "quantum_spd", "quantum_spd_receipt", "quantum_bptn", "quantum_resource", "quantum_resource_receipt", "quantum_frame", "quantum_tn", "quantum_gbs", "quantum_sv", "quantum_arch", "quantum_ldpc", "quantum_qio", "quantum_uf", "quantum_noisy", "quantum_dmrg", "quantum_tdvp", "quantum_chem", "quantum_nqs", "quantum_qir", "quantum_info", "quantum_qudit", "quantum_comm", "quantum_source", "quantum_channel",
    "quantum_receipt", "quantum_ops", "quantum_cal", "quantum_mitigate", "quantum_qec",
    "quantum_control", "quantum_noise", "quantum_compile", "quantum_atom", "quantum_qbom", "quantum_fabric",
    "quantum_vml", "quantum_phasor", "quantum_qfhrr", "quantum_kernel", "quantum_qdata",
    "quantum_phasor_meter",
]

[[test]]
name = "webgpu_member"
required-features = ["quantum_fabric_webgpu"]

[[test]]
name = "cuda_member"
required-features = ["quantum_fabric_cuda"]

[[test]]
name = "cuda_tensor"
required-features = ["quantum_fabric_cuda"]

[[test]]
name = "metal_member"
required-features = ["quantum_fabric_metal"]

[[test]]
name = "metal_matrix"
required-features = ["quantum_fabric_metal"]

[[test]]
name = "metal_tensor_ops"
required-features = ["quantum_fabric_metal"]

[[test]]
name = "cuda_sv"
required-features = ["quantum_fabric_cuda", "quantum_sv"]

[[test]]
name = "hip_wmma"
required-features = ["quantum_fabric_hip"]

[[test]]
name = "hip_member"
required-features = ["quantum_fabric_hip"]

[[test]]
name = "hip_sv"
required-features = ["quantum_fabric_hip", "quantum_sv"]

[[test]]
name = "npu_cores_member"
required-features = ["quantum_fabric_npu_cores"]

[[test]]
name = "tensor_engine_member"
required-features = ["quantum_fabric_tensor_engine"]

[[test]]
name = "opencl_member"
required-features = ["quantum_fabric_opencl"]

[[test]]
name = "opencl_sv"
required-features = ["quantum_fabric_opencl", "quantum_sv"]

[[test]]
name = "fpga_member"
required-features = ["quantum_fabric_fpga"]

[[test]]
name = "npu_member"
required-features = ["quantum_fabric_npu"]

[[test]]
name = "sme_member"
required-features = ["quantum_fabric_sme"]

[[test]]
name = "dsp_member"
required-features = ["quantum_fabric_dsp"]

[[test]]
name = "vector_member"
required-features = ["quantum_fabric_vector"]

[[test]]
name = "dataflow_member"
required-features = ["quantum_fabric_dataflow"]

[[test]]
name = "fabric_expected"
required-features = ["quantum_fabric"]

[[example]]
name = "stablehlo_gate"
required-features = ["quantum_fabric"]

[[example]]
name = "rv32_listing"
required-features = ["quantum_fabric_dataflow"]

[[example]]
name = "tn_cost"
required-features = ["quantum_tn"]

[[example]]
name = "patch_xeb"
required-features = ["quantum_sv"]

[[example]]
name = "cutrank_qasm"
required-features = ["quantum_cutrank"]

[[example]]
name = "cutrank_gpu"
required-features = ["quantum_cutrank_metal"]

[[example]]
name = "npu_onnx"
required-features = ["quantum_fabric"]

[[example]]
name = "qio_gset"
required-features = ["quantum_qio"]

[[example]]
name = "tdvp_quench"
required-features = ["quantum_tdvp"]

[[example]]
name = "nqs_ground"
required-features = ["quantum_nqs"]

[[example]]
name = "chem_dmrg"
required-features = ["quantum_chem"]

[[example]]
name = "dmrg_chain"
required-features = ["quantum_dmrg"]

[[example]]
name = "uf_bench"
required-features = ["quantum_uf"]

[[example]]
name = "ldpc_memory"
required-features = ["quantum_ldpc"]

[[example]]
name = "arch_factoring"
required-features = ["quantum_arch"]

[[example]]
name = "sv_run"
required-features = ["quantum_sv"]

[[example]]
name = "sv_bench"
required-features = ["quantum_sv"]

[[example]]
name = "noisy_bench"
required-features = ["quantum_noisy"]

[[example]]
name = "gbs_check"
required-features = ["quantum_gbs"]

[[example]]
name = "tn_path"
required-features = ["quantum_tn"]

[[example]]
name = "tn_sweep"
required-features = ["quantum_qasm", "quantum_tn"]

[[example]]
name = "qec_threshold"
required-features = ["quantum_frame"]

[[example]]
name = "qec_frame"
required-features = ["quantum_frame"]

[[example]]
name = "utility"
required-features = ["quantum_spd"]

[[example]]
name = "utility_mz"
required-features = ["quantum_spd"]

[[example]]
name = "utility_bptn"
required-features = ["quantum_bptn"]

[[example]]
name = "bell"
required-features = ["quantum", "quantum_toolchain"]

[[example]]
name = "threshold"
required-features = ["quantum_qec"]

[[example]]
name = "receipt"
required-features = ["quantum_toolchain", "quantum_receipt"]