Technology Deep Dive
From the exponential complexity of quantum mechanics to the compressed representations that make large-scale simulation possible
Quantum computers promise exponential speedups for problems in chemistry, optimization, cryptography, and materials science. But today's quantum hardware is noisy, limited in qubit count, and expensive to access.
Before running on real hardware, researchers and engineers need a way to develop, test, and validate quantum algorithms — with full access to the quantum state, deterministic results, and no queue times.
A quantum emulator simulates the behavior of a quantum computer on classical hardware. Unlike a real quantum device, it gives you:
The challenge is that simulating quantum systems on classical computers is fundamentally hard.
The state of an n-qubit quantum computer lives in a Hilbert space of dimension 2n. Each additional qubit doubles the amount of information needed to describe the system.
A naïve classical simulation must store and manipulate all 2n complex amplitudes. At 50 qubits you need 16 petabytes of RAM — more than any computer on Earth. This is the exponential wall.
The most straightforward approach: store the full state vector |ψ⟩ as an array of 2n complex numbers. Apply each quantum gate as a unitary matrix multiplication.
This gives exact results — every amplitude is computed precisely. It's the gold standard for small circuits and the method most simulators use internally.
MIMIQ™’s statevector engine is one of the fastest available, exploiting low-level CPU instructions (AVX/SIMD), cache-aware memory layouts, and advanced circuit pre-conditioning to minimize gate count before execution.
|ψ⟩ = [α0, α1, α2, ..., α2n-1]
# Apply gate U to qubit k:
for each pair of amplitudes
(αi, αj) where i,j differ in bit k:
(αi, αj) ← U · (αi, αj)
Memory: O(2n)
Time per gate: O(2n)Exact but limited: practical up to ~32 qubits on a workstation, ~42 on an HPC cluster. Beyond that, the exponential wall is insurmountable.
Not all quantum circuits are equally hard to simulate. Circuits composed entirely of Clifford gates (H, S, CNOT, and their relatives) can be simulated in polynomial time using the Gottesman–Knill theorem.
Instead of tracking 2n amplitudes, a Clifford simulator tracks n stabiliser generators — an exponentially compressed representation. This allows simulation of thousands of qubits in seconds.
Clifford simulation is essential for quantum error correction, where circuits are overwhelmingly Clifford.
Most interesting quantum algorithms require non-Clifford gates. We need a more general approach.
Every simulator navigates a fundamental trade-off: generality vs. efficiency.
The key insight: most physically relevant quantum states occupy a tiny corner of the full Hilbert space. Tensor networks exploit this structure.
Instead of storing the full 2n-dimensional state vector, decompose it into a network of smaller tensors connected by shared indices.
The amount of information flowing between tensors is controlled by the bond dimension χ. Low entanglement means small χ, and the state can be represented with far fewer parameters than 2n.
This is not an approximation for many important circuits — the Quantum Fourier Transform, many error-correction schemes, and variational circuits with limited entanglement have exact tensor network representations that are exponentially smaller than the full state vector.
The bond dimension χ captures how entangled neighboring parts of the system are. As entanglement grows, χ must grow to maintain accuracy — up to a maximum of 2n/2 (recovering the full state vector).
For circuits with bounded entanglement, tensor networks give exact results with polynomial resources. For highly entangled states, they still provide controllable approximations with fidelity guarantees.
But how do we actually compress a large object into smaller pieces while preserving the essential information? The answer is the singular value decomposition.
The singular value decomposition (SVD) factorizes any matrix M = U Σ V†, where Σ is a diagonal matrix of singular values ranked by magnitude. Discarding the smallest singular values gives the best possible low-rank approximation.
An image stored as a matrix of pixel values can be reconstructed from a handful of singular values. Discarding 95% of the data barely changes the visual result.
A quantum state reshaped into a matrix can be compressed the same way. The singular values encode the entanglement spectrum — small singular values correspond to negligible quantum correlations that can be safely truncated.
Apply SVD sequentially along the qubit chain, and the quantum state decomposes into a Matrix Product State (MPS): a chain of small tensors, each connected to its neighbors by bonds of dimension χ.
Linear in qubit count, quadratic in bond dimension
Polynomial operations per gate application
Controlled accuracy: χ = 1 (product state) to exact
Gates are applied by absorbing them into the MPS tensors and re-compressing via SVD. MIMIQ converts every quantum circuit into a Matrix Product Operator (MPO) and contracts it into the MPS — the animation on the MIMIQ page shows this process in action.
MIMIQ™ combines all of these techniques into a single, production-grade quantum computing platform.
MIMIQ™ is benchmarked against the MQT Bench library: 28 algorithms, 70,000+ circuits, 2–130+ qubits. It achieves 100% accuracy for the vast majority — more than any other quantum platform.
The combination of exact statevector (for small circuits), MPS (for large circuits), and Clifford (for error correction) means MIMIQ can handle any quantum circuit you throw at it — choosing the right backend automatically.
Run quantum algorithms at scale — with the speed, accuracy, and flexibility that only MPS-based simulation can deliver.