// Research

Research areas,
and where each stands.

Quantum computing is our central research direction. Around it, PQCF's scientific engine now covers quantum optics, quantum field theory, QCD and Feynman integrals. Each area below says what is done, how it is checked, and what is next.

// The areas

Eight areas,
one framework under most of them.

Tested
checked by our own tests against an independent reference
Benchmarked
timed against an established tool on the same machine
Reproduced
rerun by us from a fresh clone, with a step-by-step page
Prototype
working, but not yet in its final place or form
In development
implementation underway; not yet complete
Planned
intended work that has not started
Independently reviewed
evaluated by a reviewer outside the development team: nothing yet
TestedReproduced

Quantum algorithms and error correction

  • Circuits and codes on QxSim, our state-vector simulator, checked against Qiskit
  • The surface code under circuit noise on QxStab, checked against Stim
  • Benchmarks against Qiskit Aer and Stim, including where we lose
  • Our research question: its first hypothesis falsified
Quantum computing →
BenchmarkedReproduced

Photonic quantum computing

  • PQCF against five photonic simulators, every week
  • The KLM gates, fusion, detectors and loss, GKP and cat states
  • Erasure decoding with heralded losses
Photonics →
TestedBenchmarkedReproduced

Quantum optics

  • Master equations, steady states and spectra at any precision
  • Four problems with closed-form solutions: PQCF agrees to 36 digits; QuTiP to 5–16 digits under the tested default and tightest tolerances
  • QuTiP is faster at time evolution: 12 to 280 times on the driven Jaynes–Cummings model
Quantum optics →
TestedBenchmarked

Mathematical physics

  • Quantum field theory, QCD, Feynman integrals
  • High-precision mathematics: series, spectra, geometry
  • Holographic QCD: seven computations against their papers
Mathematical physics →
TestedReproduced

QED and QCD

  • Feynman diagrams and rules from a Lagrangian
  • The running of QCD to five loops
  • The one-loop box D0; the three-loop β-function
QED and QCD →
BenchmarkedReproduced

Feynman integrals

  • Reduction by finite-field reconstruction
  • Against FIRE on its double box, and Forcer on four loops
Feynman integrals →
BenchmarkedReproduced

Symbolic computation

  • PQCF's symbolic engine against FORM 5, every week
  • Dense products 3 to 5 times faster; sparse products and powers 1.5 to 2.8 times slower
  • Compiled programs with fewer operations than FORM's O4 on its resultant benchmarks
Symbolic computation →
TestedReproduced

Genomics

  • Can a photonic simulator help genome research?
  • Five routes measured against the best classical methods
  • Mostly no, and why
Genomics →
// 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, stabilizer and surface codes, and their decoders.
AlgorithmsError correctionDecodersLogical error rates
Quantum circuit simulation
QxSim, a state-vector simulator written in Elixir 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 a factor of about 2.1 with each step up in code distance (from 3 to 5 to 7) (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.
// 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 and 21 with any base a, from controlled modular multiplication to the factors (and a compiled N = 15 circuit that shows the structure).
R-02
Quantum Error Correction and Fault Tolerance
Repetition, stabilizer 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, not demonstrated: we have shown no quantum advantage, in theory, in simulation or on quantum hardware. Today: one variational classifier circuit among the live circuits, run on our simulator.
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.