这是一道适合周日报纸风格的谜题,你可以现在就尝试一下。画一个 3×3 的网格。在每个单元格中填入 +1 或 −1,需满足两条规则:每行的乘积必须为 +1,每列的乘积必须为 −1。
你没成功,对吧?这背后有一个优雅的原因。为了让一行的乘积为 +1,它需要偶数个 −1。为了让一列的乘积为 −1,它需要奇数个。把所有行加起来,你会发现网格中包含偶数个 −1。把所有列加起来,你会发现它包含奇数个。嗯……这是不可能的!
现在把这个谜题变成一场游戏:每一轮,Alice 拿到一行,Bob 拿到一列。在不交谈的情况下,Alice 按照行规则填写她的行,Bob 按照列规则填写他的列。如果他们在行和列相交的方格中填入相同的数字,他们就赢了。任何预先制定的计划只是一张预写的表格,这意味着他们最多只能在 9 轮中赢 8 轮。如果他们使用量子计算机,情况就会改变。它不会填充那个不可能的网格,但在原则上,它让他们每轮都能赢。
纠缠通常被视为量子计算的“魔法成分”。但越来越多的理论表明,语境性是更深层的资源,是真正推动某些量子算法超越其经典对应物的东西。问题在于,直到最近,语境性几乎 exclusively 在少数粒子的小系统中得到证明。它在由真实量子计算机构成的多体系统中能否幸存并保持有用,一直是一个开放的问题。
理论上最好的经典策略至少会在九轮中输掉一轮,胜率最高为 88.89%。当我们每种版本的九局游戏各玩 100,000 次时,我们的量子比特大约六十轮输一次,胜率为 98.30% (0.9830 ± 0.0001)。
这一差距具有意义且具有统计显著性:我们的量子比特协调得比任何预写表格所允许的都要好。这是因为没有单元格的值是预先固定的。每个答案只有在与其所在行或列的其余部分(其语境)一起测量时才形成,而共享的纠缠使得 Alice 和 Bob 对于共享单元格的答案达成一致。
两个量子比特是一回事,但量子效应是脆弱的,每增加一个量子比特都会带来噪音,从而抵消这些效应。有用的量子计算需要许多量子比特协同工作,因此问题是语境性在规模化后是否还能幸存。
在这个证明中,恒定深度至关重要。这意味着随着问题变大,电路不会变得更深。因为每个输出位都是在固定数量的步骤中计算的,信息只能传播很短的距离。因此,每个经典输出只能“看到”输入的很小邻域,就像一条谣言必须在三分钟内穿越一座城市一样。量子电路由于已经铺设好了纠缠,不受此限制。
在进行这些实验的过程中,顺便发生了一件有益的事情。这些任务要求许多量子比特同时且精确地达成一致。运行它们暴露了我们系统中的细微相干误差,这种误差会将量子状态稍微偏离目标,而传统的随机电路基准测试往往将其平均到不可见。
关于物理系统在无人观察时是否总是存在的争论已近一个世纪,结果发现它有一个可测量的测试。对于我们的量子比特来说,结论很明确:并非我们测量的所有事物都有预先存在的值等待被观察。理论将语境性 与纠错量子计算机运行完整算法所需的“魔法态”联系起来,我们团队最近使用 魔法态培养 准备了这些状态。
查看原文
Here is a Sunday paper-style puzzle you can try right now. Draw a 3×3 grid. Fill every cell with either +1 or −1, subject to two rules: each row must multiply to +1, and each column must multiply to −1.
Go ahead. We’ll wait…
You didn’t manage it, right? There is an elegant reason for that. For a row to multiply to +1, it needs an even number of −1s. For a column to multiply to −1, it needs an odd number. Add up the rows and you learn the grid contains an even number of −1s. Add up the columns and you learn it contains an odd number. Well…That’s impossible!
The grid would have to be two contradictory things at once. No such table exists; it is a paradox.
Now turn the puzzle into a game: Each round, Alice is handed a row and Bob a column. Without talking, Alice fills her row by the row rule and Bob fills his column by the column rule. They win if they put the same number in the square where their row and column intersect. Any plan made in advance is just a pre-written table, meaning at best they will win 8 out of 9 rounds. This changes if they use a quantum computer. It won't fill in the impossible grid, but in principle, it lets them win every round.
The reason is a property called quantum contextuality, arguably the strangest feature of quantum mechanics. Einstein once famously asked whether the moon is there when nobody looks, his way of insisting that physical properties ought to exist whether or not anyone measures them. For quantum systems, contextuality is the precise, experimentally testable statement that the answer can be no: you cannot assign fixed, pre-existing values to everything you might measure.
What a measurement yields can depend on which other compatible measurements you make alongside it (i.e., on its context). This is not only a deep philosophical statement, but more so, cutting-edge science and the basis of a new technology. And in the game above, Alice and Bob can use it to engineer a solution. Their answers are not looked up in a hidden table written in advance; the table does not exist. Their answers come into being as they measure, and quantum correlations stitch them together more tightly than any classical rulebook permits.
Entanglement usually gets top billing as the “magic ingredient” of quantum computing. But a growing body of theory suggests contextuality is the deeper resource, the thing that actually powers certain quantum algorithms past their classical counterparts. The catch is that, until recently, contextuality had been demonstrated almost exclusively in small systems of a few particles. Whether it survives, and stays useful, in the many-body systems that real quantum computers are made of was an open question.
That is the question we set out to answer. In "Quantum-classical separation in bounded-resource tasks arising from measurement contextuality," published in Science, we demonstrate and measure contextuality on our superconducting quantum processors. Our qubits win the magic square game 98.3% of the time, exceed the classical limit on a contextuality test, and outperform classical strategies in tasks spanning up to 105 qubits. Along the way, these tasks proved to be a sensitive new benchmark for quantum hardware, catching subtle errors that random-circuit tests miss.
Beating the classical bound
We ran what is commonly called the magic square game on our Willow quantum processor. Alice and Bob each hold two qubits, sharing two entangled Bell pairs instead of a pre-written table, and measure them using preset settings for their assigned row or column to get their ±1 entries.
The best conceivable classical strategy loses at least one round in nine, winning at most 88.89% of the time. When we played all nine versions of the game 100,000 times apiece, our qubits lost roughly one in sixty, winning 98.30% of them (0.9830 ± 0.0001).
The gap is meaningful and statistically significant: our qubits coordinated better than any pre-written table allows. That's because no cell has a value fixed in advance. Each answer takes shape only when it is measured alongside the rest of its row or column (its context), and shared entanglement makes Alice's and Bob's answers for the shared cell agree.
Putting a number on contextuality
The magic square game demonstrated the potential power of contextuality, so next we set out to measure how contextual a machine is. We used a Bell–Kochen–Specker inequality, closely related to the famous Bell test which showed that entangled particles like the Bell pairs above can't carry answers fixed in advance. Our inequality bundles a set of correlations into a single number, χ. In terms of the rows and columns from the game above it reads, χ = R1 + R2 + R3 − C1 − C2 − C3, where R and C represent the products of the rows and columns Alice and Bob had to calculate earlier:
+1
+1
+1
R1 = (+1)*(+1)*(+1) = +1
+1
−1
−1
R2 = (+1)*(−1)*(−1) = +1
−1
+1
−1
R3 = (−1)*(+1)*(−1) = +1
C1 = (+1)*(+1)*(−1) = −1
C2 = (+1)*(−1)*(+1) = −1
C3 = (+1)*(−1)*(−1) = +1
χ = 4
Any universe where measurement outcomes are predetermined must obey χ ≤ 4 (try a few tables and you will see that χ can only take values -4, 0, and 4). Quantum mechanics permits values up to 6, which can only happen if all Rs = +1 and all Cs = -1. And unlike most such tests, this one is state-independent: it doesn’t matter how you prepare the qubits, which makes it a property of the machine rather than of a carefully chosen input.
Measuring χ is demanding: every row and column must be measured on the same two qubits, one after another, without disturbing them. We did this with an extra helper qubit (an "ancilla") that picks up each result and is measured instead, leaving the two main qubits intact. We ran 540 measurements in a row, repeated 1,000 times.
We measured χ = 5.590 ± 0.008.
Comfortably past the classical bound of 4 and only 7% away from the quantum limit. A number that says: the contextuality is in this machine in this quantity.
Does it survive at scale?
Two qubits are one thing, but quantum effects are fragile, and every added qubit brings noise that can wash them out. Useful quantum computing needs many qubits working together, so the question is whether contextuality survives at scale.
In the GHZ parity game, N players share one entangled GHZ state (a superposition of all qubits being 0 and all being 1). Each player gets a one-bit question and answers with one bit, without communicating. They win if the parity (even or odd) of all the answers matches a rule set by the questions. Random guessing wins half the time, and the best classical plan does only a bit better: 75% for three players, shrinking toward 50% as players are added. A shared GHZ state wins every time. We played with up to 71 players, one per qubit. Noise keeps us below 100% and grows with each added qubit, so our lead narrows, but we stay above the classical bound throughout. We also verified genuine entanglement across 45 qubits, more than the full size of many earlier GHZ experiments.
Beyond multiplayer games, the same physics separates shallow quantum and classical circuits. In 2018, a landmark theorem proved that a specific problem, finding a hidden linear function, can be solved by a constant depth quantum circuit, and that no classical circuit of constant depth can. The source of this quantum advantage traces back to contextuality.
In this proof, constant depth matters. It means the circuit doesn’t get deeper as the problem gets bigger. Because every output bit is computed in a fixed number of steps, information has time to travel only a short distance. Each classical output can therefore only “see” a small neighborhood of the input, like a rumor that must cross a city in three minutes. Quantum circuits, with entanglement already laid down, are not so limited.
That algorithm had never been run at scale on real hardware. We ran it, solving hidden-linear-function instances on grids of up to 105 qubits, with success probabilities above one-half, using exactly the shallow-circuit recipe the theory prescribes.
The unexpected dividend: A better ruler
While running these experiments, something useful happened along the way. These tasks demand that many qubits agree simultaneously and exactly. Running them surfaced subtle coherent errors in our system, the kind that rotates a quantum state slightly off-target, which conventional random-circuit benchmarks tend to average away into invisibility.
That suggests a second use for contextuality: not just as a computational resource, but as a ruler.
Most benchmarks ask whether a processor can clear some classical bar. These tasks instead give hardware a ceiling set by physics itself: χ = 6, a win probability of 1, a perfect contextual fraction. The distance between what a machine achieves and what nature permits becomes an objective, meaningful score. And unlike classical bars that get easier to clear, this ceiling never moves. The better our quantum processors get, the more precisely such a benchmark discriminates. This is particularly relevant for real-world applications, such as simulations of molecules for chemistry and materials science, because it measures a processor’s ability to run structured algorithms, where subtle errors can’t hide.
What comes next
A nearly century-old argument about whether physical systems always exist when nobody looks turns out to have a measurable test. For our qubits, the verdict is clear: not everything we measure can have pre-existing values waiting to be observed. Theory links contextuality to the "magic states" that error-corrected quantum computers need to run full algorithms, which our team recently prepared using magic state cultivation.
Measuring contextuality across many qubits lets us probe an open question in physics and computer science on real hardware: what gives quantum computers their edge.
Acknowledgements
This work was carried out by the Google Quantum AI team together with our academic collaborators. We thank everyone who built and maintained the hardware, control electronics, cryogenics and software that made these experiments possible.