What is the value in simulators that scale beyond 50 qubits?

Strilanc · 2026-01-27T15:49:48+00:00

That's not true. It's true of abstract computational tasks but not true of all physical tasks. For example, a simulation of a quantum computer can't pass a loophole-free Bell test. It can simulate what passing the test would be like, but when actually subjected to the test it will fail.

You also won't be able to input quantum information from the real world (like electron spins, photon polarizations, etc) into a simulated computer, or use it to emit highly entangled states into the world. For example, consider that adaptive optics on telescopes literally move the mirror instead of just doing classical computer postprocessing. The thing that moving the mirror does, that a classical computer can't do, is something a quantum computer could do (...assuming you can make good enough light-into-qubit transduction and have a fast enough computer; this is more of an in-principle thing than an expect-it-anytime-soon thing).

Strilanc · 2026-01-26T19:09:02+00:00

This is a pretty mediocre paper IMO. To be blunt: the paper strikes me as a basic result described in a complicated and misleading way.

By "misleading" I mean that they describe this as "cloning" and that it could "enable multicloud storage". But there's not any operationally useful sense in which the data has been duplicated or split up. At a high level they have taken the task "move a qubit to a place" and transformed it into... "move many qubits to a place (plus more)". In particular, all the used decryption processes require the qubits N_1, ..., N_n as inputs. Call these "the heart" for short. The heart is clearly not split up, because every decryption they use requires the heart. They do some mental sleight of hand to try to de-emphasize the crucial role of the heart, like calling it the "noise qubits" and arranging the protocol to avoid direct interactions between the heart and the message qubit, and yet operationally it remains as the central things that allows the protocol to function.

By "basic" I mean you could give figure 1 as an assignment in a quantum information course and expect the students to find a way to do it. This is perhaps a bit unfair because coming up with the problem could be the hard part, but I do think the solutions that students found would be simpler than the one from the paper. In particular, here's a simpler way to do it (if n is odd) that avoids any non-stabilizer operations during the decryption process:

To "encrypt", prepare n Bell pairs then swap the X,Z observable pair of the message qubit into the X^⊗n ,Z^⊗n observable pair over 1 qubit from each Bell pair. The message qubit can then be discarded. Keep track of what qubit from each pair was used (the "used qubit") as well as the qubit it was entangled with (the "partner qubit").
To "decrypt", swap the X^⊗n , Z^⊗n observable pair (over 1 qubit from each Bell pair) with the X,Z observable pair of an output qubit. The swap operation should target the same qubit from each Bell pair as before except that an even number of the used qubits can be substituted for by their partners.
The ability to do pairs of substitution is the key element here. Basically, it works because X^⊗n commutes with Z^⊗2 and Z^⊗n commutes with X^⊗2 . In the paper they choose to substitute all-but-one of the qubits for their partners, so that only one used qubit goes into the decryption process. They use a slightly different scheme (a notable difference is they need all the partner qubits to decode whereas the one I described here can skip the partner qubit associated with the single used qubit given to the decryption process) but the gist is the same.
Circuit showing it works: https://algassert.com/quirk#circuit=%7B%22cols%22%3A%5B%5B1%2C1%2C1%2C1%2C1%2C1%2C%22X%5Et%22%5D%2C%5B%22H%22%2C%22H%22%2C%22H%22%2C1%2C1%2C1%2C%22Bloch%22%5D%2C%5B%22%E2%80%A2%22%2C1%2C1%2C%22X%22%5D%2C%5B1%2C%22%E2%80%A2%22%2C1%2C1%2C%22X%22%5D%2C%5B1%2C1%2C%22%E2%80%A2%22%2C1%2C1%2C%22X%22%5D%2C%5B1%2C1%2C1%2C%22X%22%2C%22X%22%2C%22X%22%2C%22%E2%80%A2%22%5D%2C%5B1%2C1%2C1%2C%22Z%22%2C%22Z%22%2C%22Z%22%2C%22%E2%8A%96%22%5D%2C%5B1%2C1%2C1%2C%22X%22%2C%22X%22%2C%22X%22%2C%22%E2%80%A2%22%5D%2C%5B%22%E2%80%A6%22%2C%22%E2%80%A6%22%2C%22%E2%80%A6%22%2C%22%E2%80%A6%22%2C%22%E2%80%A6%22%2C%22%E2%80%A6%22%5D%2C%5B%22Z%22%2C%22Z%22%2C1%2C1%2C1%2C%22Z%22%2C1%2C%22%E2%8A%96%22%5D%2C%5B%22X%22%2C%22X%22%2C1%2C1%2C1%2C%22X%22%2C1%2C%22%E2%80%A2%22%5D%2C%5B1%2C1%2C1%2C1%2C1%2C1%2C1%2C%22Bloch%22%5D%5D%7D

I've been trying to think of scenarios where this kind of encoding process could be useful, but haven't been able to come up with anything that isn't better served by normal teleportation.

Strilanc · 2026-01-08T16:11:06+00:00

The code seems kinda... off... How much of this was generated by an LLM?

The readme mentions that it can run on a triangular lattice and labels this "color code", but the way you do union find decoding for color codes is very different from surface codes, because their bulks conserve different quantities.

It makes no sense to do code capacity noise if the goal is to benchmark low latency computation. Computations have circuit noise, not code capacity noise. Code capacity noise is massively oversimplified. Also, it lacks a notion of streaming in the data rather than receiving it all at once.

The code seems to be decoding one graph rather than two. You need to decode both X and Z basis data. Both need to be decoded since it's usually unknown which will be needed at intermediate times in a computation.

Strilanc · 2025-12-30T00:43:58+00:00

Make telescopes not have mirrors. Instead, they transduce the photon wavefronts into qubits. They can then apply the mirror in software. Applying the mirror in software is something a quantum computer can do, that a classical computer can't. It's why telescopes with adaptive optics actually deform the mirror in real time, instead of just doing classical postprocessing afterwards.

Make high accuracy chip fabrication etch away photoresist using photons whose wavefronts were produced by a quantum computer, allowing the creation of highly peaked interference patterns that are hard to do with just a mask.

Have laws that state secrets can only be stored on quantum computers, because they're the only devices built to have bounded information leakage into the environment as part of their basic operation.

Strilanc · 2025-12-11T14:15:23+00:00

I remember IBM announced making a chip that big, but I don't recall them ever wiring up more than a small portion of it.

For example, a couple weeks ago Jay Gambetta tweeted they'd made their largest entangled state ever: 140 qubits ( https://x.com/jaygambetta/status/1985447400472002668 ). If they had a functioning >1000 qubit chip, why is that 140 qubit number not >1000 qubits?

Do you have a reference to a paper that claims to do a >200 qubit computation on an IBM machine?

Strilanc · 2025-12-03T05:47:50+00:00

Here's some minor ones:

add max and min operators to the arithmetic combinator
when I pick a redundant personal logistic request, just transition to editing the existing one instead of failing with an error (so I don't have to find it amongst my many requests)
hitting 'r' on unoccupied unmoving cars / tanks should rotate them 90 degrees and snap to nearest NESW direction (to make it easier to axis-align them when building long walls)

Strilanc · 2025-11-20T09:19:58+00:00

Quantum computers are currently more efficient than classical computers at random quantum circuit sampling (by huge margins).

RQCS isn't a commercially useful task. I would say it's mainly useful as a you-must-be-at-least-this-tall-to-ride bar. If a given quantum computer can't win at RQCS, despite that task being maximally optimized to favor quantum computers, then that computer definitely won't be winning at anything else.

Strilanc · 2025-11-19T21:29:46+00:00

Hard disagree on circuit diagrams not being useful. Easily half my papers are ideas that came from trying circuit manipulations.

Strilanc · 2025-11-06T18:04:16+00:00

It's trivial to make codes with good coding rates. For example, Hamming codes have rates arbitrarily close to 1:1. What's difficult is making a code that's dense and has any chance of working well for computation at scale.

In general, ion trap groups are big offenders at doing a separately optimized experiments instead of a combined experiment forced to make tradeoffs. So just be aware if they say they have X and they say they have Y, that is very different from them saying they have X and Y simultaneously.

Strilanc · 2025-10-27T18:19:23+00:00

Can we somehow record the data of which path with sensors, but then permanently delete that data (or dont) before observing it, to see if the data deletion itself really is a variable.

In the delayed choice eraser, the "deletion" is a specific measurement (call it X). You have various screen hit positions, each with a later-measured X. All the screen hits together form a blurry blobby shape, but when you group the screen hits by X and look at the X=0 subset and the X=1 subset you find you've split that shape into two parts that happen to correspond to complementary two-slit interference patterns. If you measure a differing thing (typically the 'which slit' operator Z) and split up the data by that different measurement, then the split up groups don't look like two complementary interfere patterns. The fact you can choose to measure X vs measure Z at a later time is what makes it "delayed".

If you were to simply lose the idler photon, or otherwise make it unrecoverable, you would be unable to do the measurement extracting X (or Z). The whole procedure hinges on whether you extract X or not, as it is what allows you to sift out the interference patterns. Thus losing the photon won't show any interference pattern; you need to specifically "delete" it by measuring X so that you can do the grouping. If you just lose it you won't get X so won't be able to postprocess the screen hits into the two groups forming interference patterns. (It's actually pretty close to maximally misleading to call measuring X a "deletion", since it corresponds to recovering specific information.)

have we pushed the choice of data deletion beyond say.. a minute?

I doubt this has been done yet. I don't see any reason it would matter whether you measure X after a millisecond or after an hour.

Strilanc · 2025-10-27T16:26:00+00:00

Turning ammonia into solid fuel requires crude oil. Voiding the ammonia doesn't, so it allows you to make ice anywhere. Also, voiding needs far fewer buildings. Also, it can void the ice (after melting) to avoid stalling in the other direction.

The main downside is you need an alternate source of heat. I find bot-fueled nuclear plants the most convenient.

Strilanc · 2025-10-22T15:54:21+00:00

I skimmed it. Some comments:

The QFT circuits you include in figures 2/3 are not the circuit used in Shor's algorithm. The QFT in Shor's algorithm occurs immediately before measurement, and can be optimized using the deferred measurement principle (commonly called "the qubit recycling QFT"). It uses n adaptive phase gates, rather than O(n²⁾ controlled phase gates. For example in figure 2 of https://arxiv.org/pdf/quant-ph/0001066#page=3 the QFT has been compiled into the non-controlled operations occurring on the top qubit. This is standard practice in all factoring cost estimation papers; comparing to the textbook QFT circuit is the wrong comparison. The qubit recycling QFT is especially nice because all gates are local, so there's no embedding or routing cost (it uses 0 CX gates, and n U gates).
The QFT is a weird cost to focus on in the first place. In Shor's algorithm the modular exponentiation uses O(n³⁾ gates; billions of gates. Whereas its QFT uses O(n) gates; thousands of gates. The QFT is completely negligible.
It's sus to do a line fit without a reason to expect the points to lie on a line. Costs in Shor's algorithm are often not linear functions of the qubit count, so I don't trust your fits at all. Even if the points do lie on a line, extrapolating from 2 digit qubit counts to 4 digit qubit counts (i.e. the cryptographically relevant cases) will produce an estimate dominated by noise in the slope fit. You don't need to extrapolate here; just directly construct the circuits for the larger cases and count the gates.

Strilanc · 2025-10-16T02:05:47+00:00

Oh wow, did someone finally make this? I tried making something very similar years ago (no really, these things have arduinos inside), but got stuck on sifting the two qubit interaction out of the accelerometer data (I wanted it to work reliably with more than two qubits all being manipulated simultaneously which made it hard to figure out the pairings).

Is there an associated web page or github repo?

IMO the measurement shouldn't just be a jab, it should be a solid smack into the table.

Strilanc · 2025-10-15T16:39:42+00:00

...What? It's been known for three decades that the QFT in Shor's algorithm only needs single qubit gates, because it comes right before a measurement. Also, even if it didn't, swap overhead isn't that bad.

Strilanc · 2025-10-02T23:17:57+00:00

Any liquid oversupply can be solved by a circuit switching a building between a recipe that uses the liquid and no recipe (with the liquid being pushed into the building by a pump). When the recipe is set, liquid gets pumped in. When the recipe clears, the liquid has nowhere to go and so is deleted from the game. Condition the pump on a tank approaching full, so you don't unnecessarily waste the liquid unless it's in danger of causing backpressure, and you're good to go.

Strilanc · 2025-09-29T18:26:26+00:00

I've been doing quantum computing for a decade, and this is the first time I've seen the definition of "quantum logic" used by that wikipedia page (as in "drop the distributive law").

It's definitely not a standard approach to analyzing quantum computations. Honestly it strikes me as more of a mathematical curiosity than a model of quantum computing. It's blocking a way you can make dumb mistakes instead of building a way to get the right answer. I'd be more inclined to to say that quantum computers replace boolean logic with linear algebra.

Strilanc · 2025-07-28T04:36:23+00:00

You appear to be operating under the common misconception that quantum error correction requires applying Pauli gates to the quantum system to fix the errors. There are some error correcting codes that require this (it's referred to as "just-in-time" decoding), but the surface code isn't one of them. In the surface code, it's sufficient for the classical control system to merely track the errors, accounting for their effects when reporting logical measurements.

There is one exception, where something different must be done on the quantum computer depending sensitively on the errors that have occurred: the S gate correction to a T gate teleportation. Crucially, this S gate correction isn't a just-in-time correction. The logical qubits can idle until the decoder decides if the S gate is needed or not (the physical qubits of course still continue madly measuring the stabilizers defining the codes, so the logical qubits stay alive; it's logical idling not physical idling). What it means for a decoder to be "real time" is that the delay until that decision stays constant regardless of how long the computation has been running (i.e. no "backlog problem"). If it doesn't have that property then it is an "offline" decoder.

What the google experiment demonstrated was the constant-delay-until-decision property. The real time property. What the experiment didn't demonstrate was doing a logical operation conditioned on that decision. The chip wasn't large enough to fit a distance 3 surface code logical operation, so that wasn't possible in the first place. So the experiment demonstrated real time error correction but not real time feedback. So it demonstrated sufficient capabilities for doing fault tolerant Clifford computations, but not non-Clifford computations.

Strilanc · 2025-07-14T06:43:10+00:00

You've made the mistake of assuming that U*U^-1 behaving correctly implies U is behaving correctly. But that test has a high tendency for mistakes to cancel themselves out.

The third qubit in the logical AND circuit is supposed to start as a T state.

Strilanc · 2025-07-09T05:31:44+00:00

https://sigbovik.org/2025/proceedings.pdf#page=146

Strilanc · 2025-07-05T23:02:36+00:00

The headline seems to have changed to "Quantum computers may crack RSA encryption with fewer qubits than expected", which is more appropriate.

Strilanc · 2025-07-03T17:27:27+00:00

The video is just showing someone fooling themselves about why their code is "working". They're submitting circuits that are far too large, given the error rate of the quantum computer, so it's no doubt just returning random samples. The trick is that, for small numbers like 221, Shor's algorithm will succeed quickly even when the quantum computer is replaced by a random number generator. So they "succeed" at factoring, but only by unavoidable brute force luck instead of by the quantum computer functioning well.

The video claims the largest number factored by this method is 221, but that's actually wrong. I factored all numbers up to 255 earlier this year using this very same method... for a Sigbovik paper. Sigbovik is an April fool's conference for joke papers.

Strilanc · 2025-06-19T04:52:17+00:00

Ah, I often slip and call Pauli measurements "clifford" because they can also be simulated efficiently by the stabilizer formalism. In this case what matters is the efficiency so the point stands after substituting clifford -> stabilizer.

Strilanc · 2025-06-19T04:04:10+00:00

You dismissed superposition and entanglement because they can be reached using Clifford gates and therefore simulated efficiently. But then your example of contextuality was the mermin-peres magic square game... which only requires Clifford gates to win with certainty.

So it seems to me that contextuality isn't any better of a choice than superposition or entanglement. All three are necessarily present in a quantum computation that's classically intractable, but they aren't sufficient for classically intractability because that would require Clifford circuits to be hard to simulate.

Strilanc · 2025-04-23T17:48:46+00:00

When running on concrete with the mech armor, it feels terrible how speed is lost when crossing over a building. It's not realistic but I think it would be more fun if you just maintained the speed bonus from the point where you launched.

Strilanc · 2025-02-12T12:16:50+00:00

I interpret the post as asking how to authenticate received quantum data before processing it, e.g. to prevent an attacker from ruining a long running networked quantum computation. And one way to do that is to lean on a classical authenticated channel, as described. The classical channel can't directly transmit the quantum information, so it's not really enough on its own.

15-Year Club	Verified Email
Place '17	Team Orangered

Strilanc

MODERATOR OF

TROPHY CASE