QBOM: Quantum Bill of Materials Guide

The Quantum Reproducibility Crisis

Quantum computing experiments are notoriously difficult to reproduce. When a paper claims "We achieved 73% fidelity on Grover's algorithm", reviewers and researchers have no way to verify or reproduce the result because critical information is missing.

You can't reproduce what you can't document. QBOM solves this by automatically capturing complete experiment provenance with zero code changes required.

What is QBOM

QBOM (Quantum Bill of Materials) automatically captures complete provenance for quantum computing experiments. Just add one import line to your code, and QBOM invisibly records everything needed to reproduce your experiment.

Getting Started

Installation

Requires Python 3.10+. Clone and install from source:

git clone https://github.com/csnp/qbom.git
cd qbom
pip install -e ".[qiskit]"    # Qiskit support
qbom --version

Framework options:

pip install -e ".[qiskit]"      # Qiskit support
pip install -e ".[cirq]"        # Cirq support
pip install -e ".[pennylane]"   # PennyLane support
pip install -e ".[all]"         # All frameworks

Basic Usage

Add a single import line to your quantum code:

import qbom  # Add this single line - that's it!

# Your existing quantum code - unchanged
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

backend = AerSimulator()
job = backend.run(qc, shots=4096)
result = job.result()

# View what was captured
qbom.show()

Sample Output

╭──────────────────────────── QBOM: qbom_c4b17b13 ─────────────────────────────╮
│ Summary: 2 circuits | on aer_simulator | 4,096 shots                         │
│ Created: 2025-01-15 14:30:07 UTC                                             │
│                                                                              │
│ ENVIRONMENT                                                                  │
│   Python:  3.11.12                                                           │
│   qiskit: 2.2.3, qiskit-aer: 0.17.2, numpy: 1.26.4                          │
│                                                                              │
│ CIRCUIT                                                                      │
│   Name: bell_state | Qubits: 2 | Depth: 3 | Gates: 5                        │
│                                                                              │
│ HARDWARE                                                                     │
│   Backend: aer_simulator | Type: Simulator                                   │
│                                                                              │
│ EXECUTION                                                                    │
│   Shots: 4,096                                                               │
│                                                                              │
│ RESULTS                                                                      │
│   |11⟩ ███████████████░░░░░░░░░░░░░░░  50.8%                                │
│   |00⟩ ██████████████░░░░░░░░░░░░░░░░  49.2%                                │
╰──────────────────────────────────────────────────────────────────────────────╯

What Gets Captured

How It Works

import qbom                    # 1. Import hook installed
from qiskit import ...         # 2. Qiskit adapter activates
transpile(circuit, backend)    # 3. Transpilation captured
job = backend.run(circuit)     # 4. Execution captured
result = job.result()          # 5. Results captured, trace saved

Traces are stored in ~/.qbom/traces/.

Reproducibility Score

QBOM calculates a 0-100 score showing how reproducible your experiment is:

$ qbom score qbom_c4b17b13

╭─────────────────────────── Reproducibility Score ────────────────────────────╮
│ 71/100 (Good)                                                                │
╰──────────────────────────────────────────────────────────────────────────────╯

┏━━━━━━━━━━━━━━━┳━━━━━━━┳━━━━━━━━┓
┃ Component     ┃ Score ┃ Status ┃
┡━━━━━━━━━━━━━━━╇━━━━━━━╇━━━━━━━━┩
│ Environment   │ 20/20 │ ●      │
│ Circuit       │ 17/20 │ ◐      │
│ Transpilation │  7/15 │ ◐      │
│ Hardware      │  9/25 │ ◐      │
│ Execution     │ 10/10 │ ●      │
│ Results       │  8/10 │ ●      │
└───────────────┴───────┴────────┘

CLI Reference

Example: List Recent Traces

$ qbom list

                          Recent QBOM Traces
╭───────────────┬──────────────────┬───────────────┬─────────┬───────╮
│ ID            │ Created          │ Backend       │ Circuit │ Shots │
├───────────────┼──────────────────┼───────────────┼─────────┼───────┤
│ qbom_c4b17b13 │ 2025-01-15 14:40 │ aer_simulator │ 2q, d=3 │ 4,096 │
│ qbom_bf522429 │ 2025-01-15 14:45 │ aer_simulator │ 2q, d=3 │ 1,024 │
│ qbom_b8678a13 │ 2025-01-15 14:46 │ aer_simulator │ 2q, d=3 │ 1,024 │
╰───────────────┴──────────────────┴───────────────┴─────────┴───────╯

Example: Generate Paper Statement

$ qbom paper qbom_c4b17b13

Reproducibility Statement

(For Methods section)

Experiments were performed using qiskit==2.2.3 on the aer_simulator simulator.
Circuits were transpiled with optimization level 2. Each experiment used 4,096
shots.

Complete QBOM trace: qbom_c4b17b13
Content hash: a9463e429a524897

Export Formats

qbom export <id> trace.json              # JSON (default)
qbom export <id> trace.cdx.json -f cyclonedx   # CycloneDX SBOM
qbom export <id> trace.spdx.json -f spdx       # SPDX SBOM
qbom export <id> trace.yaml -f yaml            # YAML

Python API

import qbom

# View current trace
qbom.show()

# Get trace object
trace = qbom.current()
print(trace.environment.packages)
print(trace.hardware.backend_name)

# Export
qbom.export("experiment.json")

# Scoped experiments
with qbom.experiment(name="VQE optimization"):
    # quantum code here
    pass

Related Resources

• CryptoScan Guide - Source code cryptographic discovery
• TLS Analyzer Guide - Network security assessment
• CryptoDeps Guide - Dependency crypto analysis
• PQC-Bench Guide - Post-quantum algorithm recommendations