Fusion Based Quantum Computing (FBQC)
We’re excited that our work on Fusion Based Quantum Computing (FBQC) has recently been published in nature communications. FBQC is a new framework for quantum computing, one with fault tolerance woven into its core. FBQC also has huge advantages when implemented with the single-photon hardware we develop at PsiQuantum.
Circuit-breaking: Alternative quantum computing frameworks
If you’ve ever delved into quantum computing, you already know more than you might think about frameworks. The ubiquitous quantum circuit diagrams adorning textbooks and technical articles are a particular choice of framework for how to perform computations – the aptly named circuit model framework. The circuit model suggests a computational recipe with three stages: prepare qubits in some state, perform operations on them, and then measure them to get an answer.
The most common quantum computing framework, the circuit model, generally follows a prepare-transform-measure paradigm (occasionally measurements may occur earlier to inform later transformations).
But despite its popularity, this isn’t the only possible strategy for quantum computing. Different frameworks are different high-level, prescriptions for how to set about executing a given quantum algorithm. It’s a bit like the choice between running a conventional computer program on a parallelized GPU or a threaded CPU – in either case the program runs just the same, but the strategy for how to run it is different.
The best-known alternative to the circuit-model is Measurement Based Quantum Computing (MBQC). First proposed in 2000, this framework switches things around by prescribing that you prepare a large, application-independent entangled state of all your qubits. Then any given algorithm is performed by executing a particular recipe of single-qubit measurements on this pre-prepared state. A key nicety of MBQC is that the initial entangled state can be ‘fixed’. This means that the tricky work of entanglement-generation can be performed independently of the algorithm-dependent computations with fixed and highly optimized hardware.
Like the circuit-model, MBQC is a universal framework, meaning that it can implement any quantum algorithm just as well as the circuit-model can[1]. This is a point that bears emphasizing; changing framework doesn’t change the remit of what applications a quantum computer can run – just how it does it. And sometimes one framework’s particular strategy can better suit the limitations or advantages of a particular type of quantum computing hardware.
Fusion-Based Quantum Computing: The best of many worlds
Both the circuit model and MBQC have their pros and cons. On the one-hand, the circuit-model requires only 2-qubit entangling gates, but it also requires most qubits to retain their state for the whole computation before being finally measured (not so good for photons!). On the other hand, MBQC requires large, fixed, entangled states, and its prescription for creating them requires a number of steps (even in schemes that ‘chunk’ the production of these large states). Consequently MBQC involves maintaining large entangled states for impractically long times.
Fusion Based Quantum Computing (FBQC) is a framework hitting the sweet spot between these two frameworks. Like MBQC, it benefits from factoring out much of the entanglement generation to a separate fixed part of the computation. But unlike MBQC, FBQC permits schemes requires production much smaller resource states and only maintaining them for very short periods of time. Resource states juggle just tens of entangled qubits and, crucially, they are immediately measured after being produced. But despite these simplifications, FBQC still manages to build up the long-range entanglement needed for universal, fault tolerant quantum computation. All this is made possible thanks to a particular kind of two-qubit measurement known as a fusion. FBQC continually consumes resource states, performing fusion measurements between them. At a high level that’s all there is to it.
It's worth re-emphasizing that FBQC is not just a more circuitous route to ultimately build a large unwieldy entangled state like in MBQC. The key distinction is that in FBQC only small entangled states need to stay alive for very short times, and though they don’t exist very long their information is teleported to qubits at later timesteps. Or to put it another way, FBQC operates like a relay-race of entanglement – passing a baton of quantum information through time. Qubits from resource state A undergo fusion measurements with some qubits from resource state B – becoming entangled with them. Then some qubits from resource state B are entangled with some from new resource state C. Resource state A is no longer needed. During its earlier fusion measurements with B all the classical information needed from it was also extracted, and its qubits can die a quick and happy death. All in all they only lived for a small fixed time – one independent of the size of the computation. As the baton of quantum information is handed over from one short-lived resource state to the next, algorithm output is gradually accrued from the resulting fusion network.
It’s worth noting that all seemingly ‘circuit-based’ approaches to QC are ultimately implemented purely in terms of measurements, like MBQC, once they employ error correction and fault tolerance.
FBQC involves regularly producing small, entangled states known as resource states, which are simultaneously both amalgamated and discarded in a fusion. Crucially, resource states qubits are measured and dispensed of almost immediately after being created, meaning their state only needs to be maintained for short periods. Like a computational relay race, their information is teleported to freshly created qubits in the next time-step.
Putting FBQC to work
To use a high-level framework like FBQC we need to narrow down its implementation by specifying more operational details – giving a specific architecture. Since we’re interested in fault tolerant quantum computing we ideally want an architecture that can weave error-correcting properties in with the measurements implementing the logical operations of an algorithm.
The incredible thing is that we have found FBQC architectures in which fusion measurements can roll four critical jobs into their singular, simple operation!
They join together resource states to produce the large-scale entanglement needed for quantum computing.
They perform the syndrome measurements needed for error correction.
Their outputs gradually build-up the algorithm’s classical output.
Errors arising from non-deterministic operations specific to photonics can be uniquely dealt with by FBQC’s unique error-correction implementation.
One thing might seem to be missing – how do we program an FBQC computation? Where in the FBQC recipe of ‘fuse together sequential resource states’ do we have the chance to do any configuration specific to one algorithm or another? Another great advantage of FBQC is that programming is about as simple as it can get – each fusion measurement has a single toggle, which slightly changes what it measures. Orchestrating how fusions are toggled throughout the computation implements a particular algorithm. Orchestrating classical control across a quantum computer is a notoriously difficult task – but FBQC’s simplistic control requirements make it a more achievable prospect.
Illuminating FBQC with photonics
If you’ve spent a lot of time with the circuit-model, FBQC seems a little… weird, and some of its more subtle elegance is easily overshadowed by unfamiliarity. Decoupling resource state generation from the rest of the computation might seem innocuous but has important repercussions. For example, an important question for any candidate quantum computing technology is whether the clock rates involved are too fast for the classical side-processing required by error correction to keep up. In FBQC there are multiple clock rates in play, and when realizing it with photonics the clock rates associated with producing resource states need not constrain error correction. This is because ‘resource state generator’ hardware can be used repeatedly, or in parallel to fuel the fusion network performing error correction as it consumes them. This is a great example of how FBQC is exceptionally well-suited to exploit the advantages of photonics.
Much of FBQC’s sophistication really comes to the fore when single-photon qubits are used to realize the framework. The source of noise that affects photons is loss – they’re eventually absorbed by their environment. The fact photons must only live for very short times in the relay-race of FBQC helps reduce the risk of photon loss. Moreover, errors caused by the inherently non-deterministic nature of some photonic operations become seamlessly absorbed into error-correction within FBQC.
We designed FBQC with the nuances of our hardware front of mind, and that’s allowed us to fully leverage the advantages, and circumvent the shortcomings, of single-photon quantum computing. Much fundamental quantum computing theory was developed in a time when an actual computer was far-fetched, and FBQC is a reminder of how fruitful it can be to revisit these fundamentals with the realities of fault tolerant hardware in mind. Doing so has brought us a substantial step closer to building the world’s first useful quantum computer.