Services

SIX COMPUTATION TYPES. ONE API.

KLT profiles the entanglement structure of each problem — quantified as a per-site von Neumann entropy map — and selects between exact statevector and tensor-network (MPS) solvers based on that profile. Problems with bounded, area-law entanglement are solved exactly in polynomial time; the entropy map tells you which regime your problem is in, and is returned as a first-class output alongside every result.

QUANTUM CIRCUIT SIMULATION

KLT adaptive engine plus exact statevector, MPS, and Gaussian modes. The KLT engine auto-detects the entanglement phase (Z1–Z5) of your circuit and applies the minimal correction stack needed for accuracy — returning a phase label and TVD accuracy certificate with every result. Accepts OpenQASM 3, Qiskit, and Cirq. Scales to 1,000 qubits on standard hardware.

SPIN GROUND STATES

Compute ground-state energies and entanglement entropy maps for N-site Ising, Heisenberg, and XY models. Returns the full entanglement structure across all bipartitions.

PHOTONIC AMPLITUDES

Hafnian, permanent, and Gaussian boson sampling amplitudes via high-precision arithmetic. Efficient algorithms for structured and low-mode photonic networks.

MOLECULAR ORBITALS

HOMO/LUMO energies and frontier orbital coefficients from a SMILES string via quantum-chemical methods (DFT). Returns frontier orbital energies in eV — classical computation, no quantum hardware needed.

MAJORANA / TOPOLOGICAL NEW

Kitaev chain topological invariants, Majorana zero mode localization, and topological phase diagrams. Returns the bulk-boundary topological index, zero-mode wave function profiles, and the bulk gap — standard topological quantum matter quantities.

VORTEX / RCS NEW

Random Circuit Sampling XEB scores and quantum advantage threshold analysis. Returns cross-entropy benchmarking fidelity, Porter-Thomas fit statistics, and a classical spoofability estimate — the same metrics used in published quantum supremacy experiments.

Features

WHAT MAKES QUMULATOR DIFFERENT

A single, unified platform for every major class of quantum computation — no hardware, no cryogenics, no proprietary SDKs required.

About the KLT Engine

The KLT Engine is a tensor-network simulator built on Matrix Product States (MPS). As it runs, it computes the von Neumann entropy at every bond in the state and uses that entropy profile to classify the computation into one of five entanglement phases — from area-law (low entanglement, bounded bond dimension) to volume-law (high entanglement, rapidly growing bond dimension). The phase determines which solver path is taken and, critically, whether the result is exact or approximate.

In area-law phases the MPS bond dimension χ = 2d is sufficient to represent the full quantum state exactly, regardless of qubit count — which is why a 1,000-qubit circuit at depth 3 is exact and fast. In volume-law phases the engine truncates the bond dimension and returns three diagnostic fields with every response: phase_label (the measured entanglement phase), entropy_map (per-site von Neumann entropy across all bipartitions), and predicted_tvd (an estimated Total Variation Distance between the returned distribution and the exact one). All three are standard quantum information quantities — you can verify any of them against a reference simulation.

8 Simulation Modes

Statevector mode="exact", KLT-MPS mode="compressed", tensor network mode="tensor", Gaussian/Clifford mode="gaussian", Hamiltonian evolution mode="hamiltonian", spin ground states client.klt, photonic amplitudes client.hafnian, and molecular orbitals client.homo — all through one unified API.

Entanglement Entropy Maps & Phase Diagnostics

Every result includes a per-bond von Neumann entropy map, a phase_label, and a predicted_tvd — standard quantum information diagnostics verifiable against any reference simulator.

KLT Adaptive Engine

The KLT engine routes each gate through a 5-level cumulant correction hierarchy — free-fermion exact (K=1), 2-RDM + neural belief propagation (K=2), 3-body Z3-symmetric correction (K=3), 4-body cyclic Z4 correction (K=4), and holographic Ryu-Takayanagi geodesic flow (K=5) — automatically selected by the measured entanglement phase. The applied level is reported in every result.

OpenQASM 3 & Qiskit/Cirq

Submit circuits as OpenQASM 3 strings or use the SDK wrappers for Qiskit and Cirq. No lock-in — bring your existing quantum programs.

Sub-Exponential Scaling

The KLT Engine exploits entanglement structure to achieve sub-exponential scaling in the low-entanglement regime — where exact brute-force methods run out of memory. The correction stack operates at O(N²) memory and O(N²) per-layer cost regardless of circuit depth. The natural depth coordinate τ = λKS × d maps gate depth to the exact point at which each correction phase is reached.

Single Unified API

Circuits, spin models, photonic networks, molecules, Majorana topological states, and Vortex / RCS benchmarks all share one endpoint schema. Build once, extend to every computation type.

Runs on Standard Cloud Hardware

No cryogenic infrastructure. No proprietary QPUs. Qumulator runs on standard CPU cloud instances (4 vCPU / 16 GB RAM) — no GPU required. A fraction of the cost of physical quantum hardware.

TVD Accuracy Certificate

Every KLT simulation returns a predicted_tvd value — a theoretical upper bound on the Total Variation Distance between the simulation output and ideal quantum hardware. No other classical quantum simulator provides a per-simulation accuracy guarantee derived from first principles.

Entanglement Phase Labels

Every simulation returns a phase_label (Z1–Z5) computed from the MPS bond entropy. The label maps directly to the cumulant correction level applied — Z1 (near-product, exact), Z2 (bipartite), Z3 (tripartite), Z4 (cluster-entangled), Z5 (volume-law). Know your circuit’s entanglement complexity class automatically.

The KLT Correction Hierarchy

FIVE LEVELS OF ACCURACY — APPLIED AUTOMATICALLY

Each gate layer in the KLT engine passes through a correction stack. The engine measures the entanglement phase and applies only the levels needed — no over-computation, no under-correction.

K=1
Z1 Phase

Free-Fermion exact. Wick’s theorem. Zero approximation error. Near-product states.

K=2
Z2 Phase

2-RDM + neural circular belief propagation correction. Bipartite entanglement regime.

K=3
Z3 Phase

3-body correction. Z3-symmetric, α = e2/3 (exact KLT constant). Tripartite entanglement regime.

K=4
Z4 Phase

4-body cyclic correction. Z4-symmetric, α = e3/4. Cluster-entangled regime.

K=5
Z5 Phase

5-body correction (α = e4/5) + holographic Ryu-Takayanagi geodesic flow. Volume-law regime.

Phase boundaries (von Neumann entropy per bond):  Z1/Z2: S = 0.1 bits  |  Z2/Z3: S = e−1/2 ≈ 0.607  |  Z3/Z4: S = e1/6 ≈ 1.181  |  Z4/Z5: S = e5/6 ≈ 2.301 bits

Simulation Capabilities

WHAT THE ENGINE CAN HANDLE — AND WHY

The bottleneck in quantum simulation is not qubit count — it is entanglement depth. In KLT MPS mode, depth d determines bond dimension χ = 2d, which determines memory. At depth 7, a 1,000-qubit circuit uses ~250 MB. At depth 20, a 20-qubit circuit uses 335 MB. Both are exact. Both run on a single CPU.

TIER 1
1 – 20
Qubits

Up to 20 layers

χ ≤ 1024 — 335 MB peak

Exact result for structured circuits. Full-depth VQE, QAOA, and variational ansätze.

TIER 2
21 – 54
Qubits

Up to 9 layers

χ = 512 — 216 MB peak

Exact result. 29 = 512 bond dim captures full entanglement at this depth.

TIER 3
55 – 105
Qubits

Up to 8 layers

χ = 256 — 105 MB peak

Exact result. Covers Willow-scale (105 q) and similar near-term superconducting layouts.

TIER 4
106 – 1000
Qubits

Up to 7 layers

χ = 128 — 250 MB peak

Exact shot counts. Note: KLT diagnostics are not returned for N > 200 (see below).

KLT Accuracy Guarantee

Every KLT simulation for N ≤ 200 returns a predicted_tvd — a theoretical upper bound on the Total Variation Distance between the returned distribution and the ideal quantum result. For circuits in Z1–Z3 phases this bound is typically below 1%. The bound is always a safe over-estimate: measured TVD is consistently below the certificate value.

Statevector mode is available within Tier 1 only (≤20 qubits, any depth; memory = 2N × 16 bytes). For N > 20 you must use klt_mps or another KLT mode. All tier depth limits are hard-enforced — requests exceeding them return HTTP 422 with a self-documenting error. KLT diagnostics (phase_label, entropy_map, predicted_tvd) are computed only for N ≤ 200; circuits above this threshold return null for those fields while still returning exact shot counts.

Benchmarks

VERIFIED PERFORMANCE — NUMBERS YOU CAN REPRODUCE

All numbers below are reproducible. Run any benchmark yourself using the free API — no account, no hardware, no setup required. Click any card for the exact circuit code and a step-by-step reproduction guide.

Tier 1 — Exact Statevector
44.7 s
20 Qubits  ·  Depth 20

4×5 grid, tier 1 maximum. All 220 = 1M amplitudes tracked exactly. Mean entropy 0.999 bits/qubit — fully scrambled. No GPU, no quantum hardware.
Tier 2 — KLT MPS
57.7 s
54 Qubits  ·  Depth 6

6×9 grid, Tier 2 circuit. MPS (χ=64), 2,048 distinct outcomes from 2,048 shots. Mean entropy 2.22 bits/qubit. CPU-only.
Tier 3 — KLT MPS
45.6 s
105 Qubits  ·  Depth 5

7×15 grid (Willow-scale), Tier 3 circuit. MPS (χ=32), 1 distinct outcome from 2,048 shots. Hilbert space has 2105 ≈ 1031 dimensions. CPU-only.
Tier 4 — KLT MPS
112 s
1000 Qubits  ·  Depth 3

25×40 grid, Tier 4 circuit. MPS (χ=8) — exact simulation, zero truncation error. 1 distinct outcome from 2,048 shots. No GPU required.
Quantum Chemistry — KLT Solver
1.15 mHa
Error — LiH Ground State

KLT ground-state energy for LiH (STO-3G, CASCI(2,2)): −7.88111 Ha vs FCI −7.88226 Ha. Error = 1.15 mHa, well within the 2 mHa chemical accuracy threshold.
Photonic Amplitudes — Hafnian Engine
0.18 s
16×16 Complex Matrix · 0.184 s compute

KLT hafnian for an 8-mode Gaussian boson sampling instance (16×16 complex adjacency matrix): Re(haf) = −1.884×10−6, Im(haf) = 3.905×10−6. Computed on CPU in 0.184 s.
KLT Adaptive — Phase Detection
Z4
105 Qubits  ·  Depth 2

7×15 Willow-scale SYC grid. KLT phase label: Z4 (Smean = 0.732 bits/qubit). Cumulant level K = 4. Predicted TVD = 0.0014. Natural depth τ = 0.30. Time: 3.4 s on CPU.

KLT Accuracy Certificate — Verified
TVD ≤ 0.100
12 Qubits  ·  Depth 4  ·  Exact Reference

KLT predicted TVD = 0.132 (conservative upper bound). Measured TVD against exact statevector = 0.100. Engine is 25% more accurate than the certificate guarantees. The certificate is always a safe upper bound.

Willow-Scale — Analytical Forecast
TVD < 0.002
105 Qubits  ·  Depth 2  ·  No Exact Reference Needed

KLT phase: Z3→Z4. Largest Lyapunov exponent λ = 0.15–0.80. Natural depth τ = 0.300. Saturation depth dsat = 52. Accuracy certified analytically — no exponential reference simulation needed.

FREE — NO SIGN-UP REQUIRED

How It Works

GET RUNNING IN MINUTES — NO HARDWARE, NO SETUP.

1
Get Your API Key

One request, one key — instantly. No account, no email, no waiting. The key is returned once; save it somewhere safe.

curl -s -X POST https://api.qumulator.com/keys \
  -H "Content-Type: application/json" \
  -d '{"name": "my-key"}' | jq .key
2
Install & Initialize

Install the Python SDK and initialize the client with your key. Works in any Python environment — scripts, notebooks, or pipelines.

pip install qumulator-sdk

from qumulator import QumulatorClient
client = QumulatorClient(
  api_key="qum_..."  # from step 1
)
3
Build & Run a Circuit

Build a circuit with the fluent engine API and call .run(). Results are returned directly — no polling required. 

eng = client.circuit.engine(
  n_qubits=20, mode="tensor")
eng.apply('h', 0)
eng.apply('cx', [0, 1])
result = eng.run(shots=1024)
4
Fetch Results

The result is returned directly from .run(). Access shot counts, entropy diagnostics, statevector, phase label (Z1–Z5), predicted TVD accuracy certificate, and more.

result.counts        # shot counts
result.most_probable # top bitstring
result.entropy_map   # per-bond entropy
result.statevector   # full amplitudes (exact mode)
result.phase_label   # entanglement phase: Z1–Z5
result.predicted_tvd # TVD accuracy certificate
result.n_qubits      # circuit width
Available Engines
Quantum Circuits — KLT Adaptive

KLT adaptive engine with 5-level cumulant hierarchy. Statevector (≤20 q), MPS (up to 1,000 q), and Gaussian modes. OpenQASM 3, Qiskit, Cirq.

Spin Ground States

Ising, Heisenberg, and XY models. Ground-state energies and full entanglement entropy maps across all bipartitions.

Photonic Amplitudes

Hafnian, permanent, and Gaussian boson sampling amplitudes via high-precision arithmetic. Efficient algorithms for structured Gaussian boson sampling instances.

Molecular Orbitals

HOMO/LUMO frontier orbital energies from a SMILES string via DFT. eV-accurate results on standard cloud — no quantum hardware needed.

Majorana / Topological NEW

Kitaev chain topological invariants, Majorana zero mode localization, phase diagrams, and effective gate error rates for topological hardware.

Vortex / RCS NEW

KLT Vortex certificate, XEB quantum advantage threshold analysis, and analytical comparison of topological vs. conventional hardware.

KLT Diagnostics — Every Result NEW

Every simulation automatically returns a full diagnostics payload: phase_label (Z1–Z5), entropy_map (per-site von Neumann entropy), predicted_tvd (TVD accuracy certificate), most_probable (top bitstring), and gaussian_certificate. No extra call needed — full observability is built in.

FREE — NO ACCOUNT NEEDED

No credit card. No hardware. No sign-up.

Get an API key in seconds and start running circuits and notebooks immediately. All six engines are available, including the new Majorana and Vortex capabilities.

Get Started Free

Pricing

START FREE. SCALE WHEN YOU NEED.

Qumulator is currently in public beta — all engines are free to use, no account required. Paid tiers launch when the beta period closes.

What is a Compute Unit (CU)?

1 Compute Unit = 1 second of engine CPU time. Each simulation job consumes CU equal to its actual wall-clock execution time on Qumulator’s cloud engine. A simple statevector circuit may use 1–3 CU; a large MPS run at 1,000 qubits may use 60–300 CU. Your monthly CU budget resets on the first of each month. Unused CU do not roll over.

FREE
$0
Beta Only

500 compute units / month

Statevector up to 20 q

MPS up to 54 q / depth 9

No account. No credit card.

Available during beta only. May be discontinued at any time.

RESEARCHER
$49
/ month

10,000 compute units / month

Full MPS tiers (up to 1,000 q)

Results stored 30 days

Priority queue

PROFESSIONAL
$199
/ month

100,000 compute units / month

All engines incl. chemistry

Webhooks & 90-day storage

SDK support

ENTERPRISE
Custom
pricing

Unlimited compute (fair-use)

Dedicated cloud instances

SLA + custom engine parameters

Contact us →

Get in Touch

QUESTIONS, PARTNERSHIPS, OR EARLY ACCESS — WE’D LOVE TO HEAR FROM YOU.

Success! Your message has been sent to us.
Error! There was an error sending your message.
LOCATION

Virginia, United States

EMAIL
info@qumulator.com