A-01 · Protocol
Bell state
Two qubits, maximally entangled: only 00 and 11 appear, half each.
Quantum Research Lab · Varna, Bulgaria · Est. 23 March 2003
Quantum computing research,
built on 23 years of engineering.
Founded in Varna in 2003, Quanterall now works on quantum algorithms, quantum error correction and quantum circuit simulation. What exists: ten quantum circuits you can run on this page, simulated on the Erlang virtual machine, with their source code public; a simulation engine we built over the last two years for the EU research project TechUPGRADE, which we now use for simulations in other fields, quantum computing among them; and an Erlang practice that goes back to 2009.
The name was coined in 2002 at the Joint Institute for Nuclear Research in Dubna. The company was incorporated on 23 March 2003 to pursue it once the technology allowed.
23yrs
Since 2003
17yrs
Erlang, since 2009
10
Live circuits
// Where we are · 29 October 2026
What exists, what is simplified,
what is missing.
Exists
- Ten quantum circuits on a pure-Elixir state-vector simulator (QxSim, in our demo service), run live on this page; every run can be repeated with its seed.
- Shor's algorithm for N = 15 in full: controlled modular exponentiation, inverse QFT and the classical step, ending in 3 × 5.
- Teleportation with Bob's corrections: Bob's qubit reads the sent |1⟩ in every shot.
- Grover's search on 2 to 10 qubits, with its success probability per iteration against theory.
- The full distance-3 surface code: eight stabilizers, a decoder, every single error corrected.
- A stabilizer simulator on the BEAM with gate-level noise, checked against Stim; benchmarks against Stim and Qiskit Aer.
- Two process models: entanglement as linked processes, with the CHSH value S measured live and shown with its error, against 2 (classical) and 2√2 (quantum); teleportation between two BEAM nodes.
- Exact logical-error sweeps of repetition codes of distance 3 to 9, on the simulation engine we built for TechUPGRADE (not yet published here).
Simplified
- Shor's algorithm uses three counting qubits, enough for N = 15 and a = 7 only (the period is 4); a general circuit needs more.
- The bit-flip code corrects by a majority vote of the readout, not by gates.
- The state-vector codes: one error per run, noiseless gates. Gate-level noise runs on the stabilizer simulator.
- Our state-vector simulator stops at 19 qubits in its 1 GB container, and is far slower than Qiskit Aer.
Missing or not yet right
- A full distance-3 surface code (9 data, 8 ancilla qubits) with a matching decoder.
- Our own decoder: the gate-level results are decoded with PyMatching.
- No published paper yet.
Next
- A decoder of our own (union-find or matching) on the BEAM, to decode live.
- Other noise models (biased, leakage), and codes beyond the surface code.
- A results page for the logical-error sweeps, with data; benchmarks; a first preprint.
Progress log
29 Oct 2026Grover on 2 to 10 qubits; the full distance-3 surface code; QxStab, a stabilizer simulator with gate-level noise, checked against Stim; the surface-code threshold study and benchmarks against Stim and Qiskit Aer, with their data.
29 Oct 2026Shor's algorithm for N = 15 in full (15 = 3 × 5); teleportation completed with Bob's corrections; a seed for every run; the repetition-code sweeps published with their data.
29 Oct 2026The phase-flip, Shor-9 and Steane codes now run a full correction cycle and correct every single-qubit error (Shor-9 and Steane: bit and phase flip at once).
29 Oct 2026The process models get their physical pictures: photon pairs for the Bell test, a photon's polarization for teleportation. The text of this page revised claim by claim.
28 Oct 2026The ten circuits run live on this page; the two process models published, with their measured statistics.
23 Mar 2026Quanterall becomes a quantum computing research company (below).
// Check it yourself
Three things you can
check for yourself.
01
Ten quantum circuits, on the BEAM
A state-vector simulator written in Elixir and Erlang, running on the Erlang virtual machine: a Bell pair, teleportation, Grover's search, a variational classifier, Shor's algorithm for N = 15, and five error-correcting codes in which you can inject an error and watch the syndrome. Every run is a real simulation, in its own Erlang process, and can be repeated exactly with its seed; the source code is on GitHub. Run them →
02
A simulation engine, built for TechUPGRADE
Over the last two years we built the simulation engine of TechUPGRADE, an EU Horizon Europe research project on thermochemical heat recovery: component models, scenario runs, physics-informed neural networks and 3D flow simulation of a real reactor. We now use the same engine to prepare simulations in other areas. For quantum computing it runs the same ten circuits, and noise sweeps of repetition codes in which the logical error rate is computed exactly. Watch the platform's films →
03
Erlang, since 2009
We have built on Erlang since 2009, and we teach it: in our own academy; at Varna Free University, now; and in the past at the Technical University of Varna and New Bulgarian University. The BEAM was made for systems of very many small processes that must not fail, which is why we use it to model quantum circuits and protocols.
23
March · 2026
Archive · 23 March 2026
Quanterall returned to its founding purpose
after 23 years.
after 23 years.
On 23 March 2026, 23 years to the day after incorporation, Quanterall changed from a distributed-systems engineering firm into a quantum computing research company. The name "Quanter-all" was chosen in 2002 at the Joint Institute for Nuclear Research in Dubna as a statement of intent toward quantum computing.
// What we do
Quantum algorithms.
Error correction.
Simulated on the BEAM.
A research programme begun on 23 March 2026, not a product company. We keep it to what we can show: quantum algorithms and error-correcting codes, implemented and tested in a state-vector simulator in our demo service. Its first public pieces are the circuits and the simulation work above.
Quantum computing research
We implement quantum algorithms and the error-correcting codes that let them survive noisy hardware, and check each against its exact prediction. Current threads: search and phase estimation; repetition, stabiliser and surface codes, and their decoders.
AlgorithmsError correctionDecodersLogical error rates
Quantum circuit simulation
A state-vector simulator written in Elixir and Erlang, on the Erlang virtual machine: each run its own process, isolated from the others, many runs in parallel. Beside it, the simulation engine we built for TechUPGRADE, for exact noise sweeps. Quantum machine learning stays a planned area until we have results to show.
State vectorElixir · ErlangNoise sweepsOpen source
Why now
In 2024 a surface-code quantum memory was run below the error-correction threshold: its logical error rate fell by about half with each step up in code distance (Google Quantum AI, Nature 638, 920; 2025). Fault-tolerant computation at a useful scale has not been demonstrated yet, and practical advantage on real problems is still argued over. That is the gap where simulation is useful: codes, decoders and noise can be studied before the hardware exists.
Where our past work carries over: we already test systems by injecting faults, and supervision trees and parallel Monte Carlo are how the BEAM runs many noisy shots with each failure isolated. The BEAM suits offline, parallel simulation and the orchestration around it; it is soft real-time, so it is not a decoder for real hardware, which needs microsecond latency from FPGAs or ASICs. Our track record in simulation is the two years building TechUPGRADE's simulation engine.
Where it does not: a quantum state cannot be copied (no-cloning), so redundancy cannot mean replication; and errors are found indirectly, by measuring syndromes without reading the data. Those are the parts we are learning.
Where our past work carries over: we already test systems by injecting faults, and supervision trees and parallel Monte Carlo are how the BEAM runs many noisy shots with each failure isolated. The BEAM suits offline, parallel simulation and the orchestration around it; it is soft real-time, so it is not a decoder for real hardware, which needs microsecond latency from FPGAs or ASICs. Our track record in simulation is the two years building TechUPGRADE's simulation engine.
Where it does not: a quantum state cannot be copied (no-cloning), so redundancy cannot mean replication; and errors are found indirectly, by measuring syndromes without reading the data. Those are the parts we are learning.
// Research areas
Three core pillars, three planned,
two exploratory tracks
R-01
Quantum Algorithms
We implement quantum algorithms in our simulator and check them against their exact predictions; a speedup is a claim to verify, not to assume. Focus: search, phase estimation and factoring; later, quantum simulation of physical systems.Today: Grover's search on 2 to 10 qubits; Shor's algorithm for N = 15 in full, from the controlled modular exponentiation to the factors 3 and 5.
R-02
Quantum Error Correction and Fault Tolerance
Repetition, stabiliser and surface codes, and the decoders that make them practical: the field's central engineering problem, and the one where simulation helps most.Today: five codes among the live circuits, each with a full correction cycle (the surface code with all eight stabilizers); the surface code under gate-level noise on our stabilizer simulator, d = 3 to 7, with its threshold. Exact noise sweeps of repetition codes of distance 3 to 9 under independent bit flips, published with their data: they check the simulator against the closed form.
R-03
Quantum circuit simulation on the BEAM
A pure-Elixir state-vector simulator (QxSim) inside our demo service, with no simulator library underneath. Every run is an Erlang process, isolated from the others, and runs go in parallel. Benchmarked against Qiskit Aer and Stim, including where the BEAM loses: raw single-thread numerical speed.Today: the circuits and the two process models on this page; QxStab, a stabilizer simulator for hundreds of qubits with gate-level noise; benchmarks; the source code on GitHub.
P-01
Quantum Machine Learning
When does quantum hardware give learning a real advantage, and when not? Kernel methods and variational classifiers, always with a tuned classical baseline beside them.Planned. Today: one variational classifier circuit among the live circuits.
P-02
Quantum-Classical Hybrid Architectures
The orchestration layer where HPC and QPUs actually meet: VQE and QAOA implementations, workload scheduling, error-mitigation budgets, and the plumbing that decides whether near-term hardware is useful. Close to our engineering history.Planned. Nothing published yet.
P-03
Post-Quantum Cryptography Migration
A service rather than research: cryptographic inventory and migration to the NIST post-quantum standards published in August 2024 — FIPS 203 (ML-KEM), FIPS 204 (ML-DSA) and FIPS 205 (SLH-DSA) — inside distributed systems where key rotation, latency budgets and legacy protocols are the real constraints. "Harvest now, decrypt later" concerns data protected by RSA or elliptic-curve cryptography that must stay secret for years: it can be recorded today and decrypted once a large enough quantum computer exists.Planned. Nothing published yet.
// Exploratory tracks — speculative, and labelled as such
X-01 · Entanglement as linked processes
We model an entangled pair as two Erlang processes whose states are linked: measuring one fixes what the other will show. This is a classical simulation: a third process holds the shared state centrally and both sides ask it, so the model reproduces the statistics of entanglement, not nonlocality. The demo below measures S live and shows it with its standard error (about ±0.06 over 2000 rounds), against 2 for any classical model and 2√2 ≈ 2.83 in theory. For teaching: it makes visible that the correlation comes from the shared state, not from a message between the two.
X-02 · Teleportation as process migration
We model teleportation as a process that migrates between two BEAM nodes: the state leaves one node and is rebuilt on the other, carried only by a Bell pair shared in advance and two classical bits sent over the network — as in the protocol, where nothing quantum travels after the pair is made. The simulator knows ψ — it draws it at random and checks the result — so the demo shows the protocol's structure, not a physical transmission. For teaching and for prototyping protocols.
Why we publish the speculative work: a lab that only shows finished results is telling you nothing about how it thinks.
// Results · repetition-code sweeps
Logical against physical error rate,
with the data.
Noise model. A bit-flip repetition code of distance d keeps logical |0⟩ on d data qubits, with d − 1 ancillas measuring neighbouring parities. Each data qubit flips (X) independently with probability p; gates and syndrome measurements are perfect; a minimum-weight decoder picks the correction.
Exact, and what that means. There are only 2ᵈ error patterns. Each is run once through the syndrome circuit on the state-vector simulator, and the logical error rate is the sum of the failing patterns' probabilities. For this noise model a closed form exists — the binomial tail Σk>d/2 C(d,k) pᵏ(1−p)ᵈ⁻ᵏ — and the two agree to 6 × 10⁻¹⁶. So this result validates the simulator against theory; it is not new physics. A Monte Carlo experiment with 100,000 shots per point (seed 20261029) is drawn beside it.
What it does not show. Circuit-level noise — errors in the gates and in the syndrome measurement itself — has no simple formula, and is where real study begins. That, and codes beyond the roughly 20 qubits a state vector allows, need a stabilizer simulator; both are on our list (see Where we are).
Data (CSV, 88 rows) · Chart (SVG) · computed on the simulation engine we built for TechUPGRADE, 29 October 2026; the generator is tools/repetition_sweep.py in the repository
// Results · gate-level noise, on a stabilizer simulator
The surface code under circuit noise,
checked against Stim.
The simulator. QxStab, a stabilizer simulator written in Elixir: a tableau (Aaronson–Gottesman) runs each circuit once without noise for a reference, then a Pauli-frame sampler runs the shots, bit-packed — 1,024 shots in one integer per qubit — in parallel batches, one BEAM process each. It is the method Stim uses, written for the BEAM.
The experiment. Rotated surface codes of distance 3, 5 and 7 (17, 49 and 97 qubits) keep a logical |0⟩ for d rounds of stabilizer measurements. Noise at rate p everywhere: depolarizing after every gate (one- and two-qubit), bit flips after resets and before measurements, depolarizing on the data at each round.
Validation. Each circuit is written out in Stim's format: Stim accepts every detector as deterministic and finds the code distance d for each (our first CNOT order gave only (d+1)/2, a hook-error mistake Stim caught). The same circuits sampled by Stim and by us, both decoded by PyMatching on the detector error model Stim derives, give the same logical error rates: the largest gap over 21 points is 2.3 standard errors.
What it shows. The curves cross between p = 0.6 % and 0.8 %, the known threshold for this noise model with matching: below it, a larger code protects better. The decoder is PyMatching's, not ours; ours is on the list.
Data (CSV, 21 points, 100,000 shots each) · Chart (SVG) · tools/beam_runs.exs, tools/stab_study.py · stim 1.16.0, pymatching 2.4.0
// Benchmarks · 2026-10-29
Where the BEAM is fast,
and where it is not.
State vector · ms for n layers of Rx and CNOTs, 1,024 shots
| qubits | gates | QxSim (BEAM) | qsim (NumPy) | Qiskit Aer |
|---|---|---|---|---|
| 8 | 120 | 1.0 | 0.8 | 4.0 |
| 10 | 190 | 4.0 | 1.3 | 4.9 |
| 12 | 276 | 36.0 | 2.9 | 7.9 |
| 14 | 378 | 180 | 8.7 | 18.9 |
| 16 | 496 | 1,323 | 46.1 | 97.6 |
| 17 | 561 | 3,063 | 95.2 | 90.8 |
| 18 | 630 | 5,490 | 215 | 138 |
| 19 | 703 | 13,480 | 1,984 | 227 |
| 20 | 780 | out of memory | 7,464 | 320 |
Our state vector is an Erlang tuple of boxed complex numbers, one process, rebuilt for every gate: fine for teaching circuits, and 60× slower than Qiskit Aer at 19 qubits. At 20 qubits it runs out of its 1 GB container. For larger state vectors we use the NumPy engine or Aer.
Stabilizer sampling · ms for 100,000 shots, p = 0.1 %
| circuit | qubits | detectors | QxStab (BEAM) | Stim | BEAM / Stim |
|---|---|---|---|---|---|
| repetition d9 | 17 | 80 | 19.8 | 12.4 | 1.6× |
| surface d3 | 17 | 24 | 9.3 | 3.3 | 2.8× |
| surface d5 | 49 | 120 | 27.5 | 19.5 | 1.4× |
| surface d7 | 97 | 336 | 139 | 82.4 | 1.7× |
| surface d9 | 161 | 720 | 367 | 256 | 1.4× |
Here the BEAM comes close: 1.4 to 2.8 times Stim's time. But our sampler spreads the shots over all 20 cores and Stim used one, so per core Stim is in the order of 30 to 60 times faster (an estimate: the ratio times 20 cores). What the BEAM gives is the parallelism for free, and shots that cannot crash one another.
Data (CSV) · one machine, 20 Arm (aarch64) cores, stim 1.16.0, pymatching 2.4.0, qiskit-aer 0.18.2 (statevector) · tools/beam_runs.exs, tools/stab_study.py
// The substrate
The science of
superposition
A register of n qubits is described by 2n complex amplitudes. A measurement returns one outcome, with probability given by its amplitude squared; the amplitudes themselves are never read out. Speedups come from interference: an algorithm arranges the amplitudes so that wrong answers cancel and right ones reinforce before that one measurement.
Superposition — n qubits, 2n amplitudes; a measurement returns one n-bit outcome. The demos' histograms are many such outcomes.
Entanglement — correlated states that cannot be described independently: a resource for quantum communication and, in many algorithms, for speedups. See it in the Bell pair.
Interference — amplitudes cancel wrong paths and reinforce right ones. Many quantum algorithms work this way. See it in the Grover circuit.
|ψ⟩ = α|0⟩ + β|1⟩, |α|² + |β|² = 1
// Run it yourself
Ten circuits,
simulated live on the BEAM.
Quantum circuit simulation, written in Elixir and Erlang and running on the Erlang virtual machine: four algorithms and protocols, one quantum ML circuit, five error-correcting codes. The charts below are not pictures: each card ran its circuit when this section came into view, and draws the outcomes it measured, shot by shot. Run any of them again, or open the full demo page for the circuits in OpenQASM and the error-correction details.
A-02 · Protocol
Teleportation
A |1⟩ sent from Alice to Bob through a Bell pair and two classical bits, with Bob's corrections: Bob's qubit (leftmost) reads 1 every time.
A-03 · Algorithm
Grover's search, 2–10 qubits
A random marked state among N = 2ⁿ. Line: its probability after each iteration, exact; dots: theory sin²((2k+1)θ). The optimum is near (π/4)√N.
M-01 · Quantum ML
Variational classifier
Rx rotations and an entangling CNOT layer — the shape of a quantum ML model.
A-04 · Algorithm
Shor's algorithm, N = 15
In full: controlled ×7 and ×4 mod 15, the inverse QFT, and the classical step. The counting register shows period 4: 15 = 3 × 5.
E-01 · Code
Bit-flip code
Logical |0⟩ on three qubits, an X error on qubit 1; two ancillas measure the parities, a majority vote of the readout corrects it. Noiseless gates.
E-02 · Code
Phase-flip code
Logical |0⟩ as |+++⟩, a Z error on qubit 1; checks X₀X₁ and X₁X₂ on one reused ancilla find it, a Z corrects it. Read out in the X basis.
E-03 · Code
Shor's 9-qubit code
A Y error (bit and phase flip) on qubit 1; six Z checks and two X checks find both, the decoder corrects both. Bars: the logical qubit, 0 or 1.
E-04 · Code
Steane [[7,1,3]] code
A Y error on qubit 1; three Z and three X checks give its position twice, in binary; X and Z correct it. Bars: the logical qubit, 0 or 1.
E-05 · Code
Surface code, distance 3
The full distance-3 code: nine data qubits, all eight stabilizers on one reused ancilla, a Y error on qubit 1; a lookup decoder corrects both flips. Bars: the logical qubit.
Reproduce this
curl "https://quanterall.com/quantum/bell?shots=1024&seed=42" curl "https://quanterall.com/quantum/shor15?shots=1024&seed=42" curl "https://quanterall.com/quantum/qec/steane7?shots=1024&error_qubit=3&seed=42" curl "https://quanterall.com/quantum/entangle?shots=2000" curl "https://quanterall.com/quantum/migrate?shots=100"
Every card is one such call: the path is the demo's name (bell, teleport, grover, qml, shor15, qec/…), the answer is JSON with the counts and the circuit in OpenQASM. Add seed (0 to 2³²−1) and the same call gives the same counts; without one, the answer reports the seed it drew, so any run can be repeated. The process models run many processes of their own and are not seeded. Limits: up to 10,000 shots a call, 5 calls a second per visitor (bursts of 20), 4 simulations at once. About the code: the demos began on qx, Craig Richards' Elixir quantum simulator (Apache-2.0; we used version 0.5.1), and we credit it. The simulator now running, QxSim, is a separate pure-Elixir implementation on Erlang tuples inside our demo service, with no simulator library underneath: we compared it with every qx release (0.2.0 to 0.11.0, all built on Nx tensors) and found no shared code. Earlier labels here that read "qx_sim 0.5.1" named the starting point, not the code that runs.
// Process models on the BEAM
Entanglement as linked processes. Teleportation as a process that migrates.
Two quantum concepts modelled with what the Erlang virtual machine does best — isolated processes and nodes — for teaching and for demonstrating the concepts. Both run live below, on real BEAM processes; the numbers are measured, not drawn.
X-01 · Entanglement
Each round spawns three processes: a pair process holding the shared state |Φ⁺⟩, and Alice and Bob. They never message each other; each asks the pair to measure its own qubit at an angle. Whoever asks first collapses the shared state, and the other reads a correlated result. A classical simulation: the pair process is a central state holder, so this shows the statistics of entanglement, not nonlocality.
The physical system: two photons with entangled polarization
A crystal makes the photon pair; neither photon has a polarization of its own until one meets a polarizer. A polarizer turns half as much as the qubit's measurement axis, so the settings are 0° or 45° for Alice and 22.5° or 67.5° for Bob, as in the Bell tests of Aspect (1982) and Weihs (1998). Played: this run's first 24 pairs.
running…
X-02 · Teleportation
Node A is this server's BEAM; node B is a second BEAM node, a separate operating-system process. Alice's process holds a qubit ψ, measures it against her half of a Bell pair and ends; only two classical bits go to node B, where a new process applies the correction and holds the same state. ψ is unknown to the protocol but known to the simulator, which checks the result: this shows the protocol's structure, not a physical transmission.
The physical system: a photon's polarization
As in the first teleportation experiment (Bouwmeester et al., Innsbruck 1997) and from the ground to the Micius satellite over 1,400 km (2017): |0⟩ is horizontal and |1⟩ vertical polarization, ψ is drawn as its polarization ellipse. A Bell-state analyser built only from beam splitters tells apart two of the four outcomes; the model, like trapped-ion experiments, uses all four.
running…
// People
Who leads this work,
and where else the founder works.
Anton Andonov
Founder and CEO, Quanterall
- Part of the Institute for Advanced Physical Studies (IAPS), New Bulgarian University, Sofia — a personal affiliation, not the company's.
- Teaches Erlang at Varna Free University; has taught at the Technical University of Varna and New Bulgarian University.
- Building on Erlang since 2009. Quanterall built the TechUPGRADE simulation engine.
Students and universities
We propose thesis topics and seminars around our circuit simulator — a decoder, a noise model, the full Shor circuit — for students at Varna Free University, and joint work through IAPS and New Bulgarian University where it fits. Students who take part are credited here. To propose or take a topic: [email protected].
Collaborate, join, work with us
Write to [email protected] — for research collaboration, to join, or to work with us. Or through the code: open an issue or a pull request on GitHub; or on LinkedIn.
Quanterall Ltd. is a private company, separate from the Institute for Advanced Physical Studies and from the universities named here. Their names say where our people work and teach; they do not endorse this site.
// 2003 – 2026 · The foundation
23 years.
The work behind the move.
2002 ✦
Dubna
At the Joint Institute for Nuclear Research, our founder coins "Quanter-all" with two colleagues, Penka Christova and Gizo Nanava — an explicit statement of intent toward quantum computing.
23 March 2003
Varna
Quanterall is incorporated as the vehicle for that intent, with the understanding that it may take decades. It did.
2003–2016
Systems at scale
Enterprise and industrial platforms across European markets — distributed systems where downtime is measured in revenue, not minutes.
2009
Erlang
We start building on Erlang. Teaching follows: our own academy, and for years courses at three universities.
2016–2020
Correctness · blockchain
A turn toward formal methods, functional programming, and provable behaviour. Blockchain and crypto products, built mainly in Erlang, Elixir and Haskell.
2020–2025
Breadth
Healthcare, logistics, finance, bioinformatics, communications, insurance.
2024–2026
A simulation engine
For the EU research project TechUPGRADE we build its simulation engine: physical models, scenarios, physics-informed neural networks and 3D flow simulation of a thermochemical reactor.
23 March 2026 ✦
Return
Full commitment to quantum computing research. The circle closes on schedule, 23 years late and 23 years early.
The twenty-three years behind this move are distributed and fault-tolerant software, not quantum physics. They carry over in specific places — concurrency, fault-injection testing, simulation — and not in others. What we lack is quantum-specific depth; we are building it in the open, on this page.