A new study shows that one of quantum mechanics’ strangest properties may be the secret ingredient that makes powerful quantum computers possible. According to research by physicists at A*STAR and the National University of Singapore (NUS), this property, known as contextuality, plays a central role in error-correcting codes – the mathematical tools that protect quantum information from noise. The finding suggests that quantum weirdness is not just an exotic curiosity. Instead, it’s baked into the very structure of the codes that keep quantum computers alive.
The tiniest disturbance – a stray vibration, a fluctuation in temperature – can corrupt the information that quantum computers process. To deal with this, physicists use quantum error correction: a clever strategy that spreads information across many physical quantum bits (qubits) and continuously checks them for faults, without directly reading the data they encode. But there’s a catch. Even a perfectly error-corrected quantum computer isn’t automatically powerful. To run any quantum algorithm you could ever want – what physicists call being “universal” – you need to perform a complete set of operations on your qubits, known as gates. These are the quantum equivalent of the logical operations that underpin classical computing.
It would be nice if we could accomplish this with gates that act independently on each physical qubit, as this would prevent errors from spreading between qubits. Unfortunately, a fundamental theorem called the Eastin-Knill theorem states that no single error-correcting code can implement a universal set of gates using only this type of gates, which are known as transversal gates.
The standard workaround is to use two complementary codes and switch between them, with each one supplying the transversal gates the other cannot. This strategy is called code-switching, and physicists regard it as one of the most promising routes towards truly capable quantum hardware.
For years, though, a basic question lingered: what allows code-switching to work? What resource makes universal fault-tolerant quantum computation possible in the first place?
A quantum resource hiding in plain sight
A new PRX Quantum paper by Kishor Bharti and colleagues at NUS and A*STAR points to a surprising answer: quantum contextuality. This is one of those quantum properties that sounds philosophical but has very real consequences. In everyday life, measuring something – say, the temperature of a room – gives you the same answer regardless of what else you measure at the same time. In contrast, the outcome of a quantum measurement can depend on the context – that is, on which other measurements you perform alongside it.
To make this more concrete, imagine you have two qubits. Some pairs of measurements you can perform on these qubits are incompatible. In mathematical terms, they do not commute with each other, and you cannot perform them simultaneously without one disturbing the other. Position and momentum are good examples: Heisenberg’s uncertainty principle states that they cannot be measured simultaneously at arbitrarily high precision. On the other hand, measuring the spin of qubit 1 along the x-axis and the spin of qubit 2 along the z-axis at the same time is perfectly allowed: these variables commute, so these measurements are compatible.
But here’s the really strange part: the statistics of what you observe for qubit 1 can depend on which measurement you choose to perform on qubit 2, even when the measurements are compatible. This isn’t a matter of ignorance or experimental imprecision. It is a provable, fundamental feature of quantum theory with no counterpart in classical physics, one that was made rigorous by the mathematicians Simon B Kochen and Ernst Specker in 1967 as a generalization of the more famous notion of quantum nonlocality articulated by John Bell.
Contextuality was already known to play a role in specific quantum computing tasks. In particular, it is important for a technique called magic state distillation, which is used to boost the power of fault-tolerant hardware. But the latest work goes much further. It shows that contextuality is not just a useful tool you can optionally invoke. Instead, it is a built-in feature of any error-correcting code capable of supporting universal computation.
A clean threshold with big consequences
Bharti and colleagues studied a broad family of error-correcting codes known as subsystem stabilizer codes, which use a mix of commuting and non-commuting measurements. They found a remarkably clean result: one of these codes is contextual if and only if it has at least two so-called gauge qubits, which are extra degrees of freedom that arise from those non-commuting measurements. Below that, the code’s measurement statistics can always be explained classically. Above it, quantum weirdness is irreducible.
Why error correction is quantum computing’s defining challenge
When this criterion is applied to code-switching protocols, the finding becomes even more striking. Every major protocol known to achieve universal quantum computation – including well-studied examples like switching between the Steane code and the Reed-Muller code – sits above this threshold. As team member Andrew Tanggara explains: “We show that a large family of code-switching protocols must necessarily use a contextual subsystem code.” The mathematics suggests this is no coincidence: universality and contextuality appear to be inseparable.
A new lens for quantum hardware design
The team’s result means that contextuality now joins entanglement as a fundamental resource that error-correcting codes possess to enable universal computation. This gives quantum engineers and theorists a powerful new diagnostic tool. If a proposed code architecture turns out to be non-contextual, no amount of clever engineering will make it universal through code-switching alone. Contextuality is not a nice-to-have – it is a prerequisite.
The new findings also deepen our understanding of why quantum computers can do things classical ones cannot. It is not simply because qubits can be in superposition, or because they can be entangled. It is because quantum systems are contextual – and that contextuality, it turns out, is precisely what gets encoded into the structure of the most powerful error-correcting codes we know how to build.
