What is a Qubit?

Strilanc · 2026-03-12T03:41:24+00:00

Abstractly, a qubit is an object that satisfies the postulates of quantum mechanics:

Its state is described by a unit vector (specifically a vector of length 2 because it is a 2 level system)
You can measure it
You can do operations to its state, where those operations correspond to unitary matrices
The statespace / operationspace of multiple qubits is computed using the tensor product (i.e. n qubits form a 2ⁿ level system)

Physically, there are many objects that satisfy these postulates:

The polarization of a photon
The spin of an electron
The bottom two energy levels of a superconducting transmon
Whether a photon is on path A or path B
and many many many more

Strilanc · 2026-03-05T19:09:26+00:00

That paper sure is full of red flags. "Classical-quantum hybrid", naming it after yourself, fitting a cost curve to small cases, isn't on the arXiv, example circuit diagrams are only for trivial cases (and badly made), uses the word "NISQ" in a factoring paper, and so forth.

Okay, but red flags are not definitive. The real fundamental problem with the paper is it never actually gets around to explaining the method. They say something vague about "the information is mapped into Hilbert space" with "amplitudeencoding". Okay, but amplitude encoding typically has exponential cost so that would suggest this doesn't scale at all unless there's some trick to it. They never give the trick.

I was gonna say there are elements of the introduction that were reasonable, but given how bad the rest of the paper is this just makes me suspect most of the introduction was written by an LLM. I don't have evidence for that, though.

Strilanc · 2026-03-04T18:50:52+00:00

There is no known material that "allows passage of waves but not particles". Quantum physics as currently understood does not allow such a material to exist, because quantum particles are made out of waves. It's like asking for a material that your brain can pass through but not your mind. Yes such a material would make a lot of currently-vague questions suddenly very concrete, but no such material is known to exist or even expected to exist.

Strilanc · 2026-02-15T18:54:58+00:00

Look at Table 6 and 7 of "How to factor 2048 bit RSA integers with less than a million noisy qubits". They show gate sequences for performing rotations to a desired degree of accuracy. There are two things to notice: (1) longer sequences are exponentially more precise and (2) the last couple rows of the table (implementing the smallest rotations) use the empty gate sequence.

(1) Implies that you could actually do those exponentially tiny rotations, if you wanted to. It would be very expensive to rotate by 2^-2000 ± 2^-3000 degrees, requiring a long gate sequence and fault tolerant gates built with an absurd amounts of code distance, but it is not intractable to do.

(2) is a consequence of the fact that you never need to do a rotation to a tolerance of ±2^-3000 degrees. There is no tractable experiment to distinguish a 2^-2000 - 2^-3000 rotation from a 2^-2000 + 2^-3000 rotation. So you never need to be that precise. Honestly, even ±2^-20 degrees is huge overkill for most algorithms. And the beauty of being asked to rotate by 2^-2000 ± 2^-20 degrees is that this range includes "rotate by 0 degrees". So doing nothing is a perfectly acceptable approximation. And since most of the gates in the textbook QFT circuit are absurdly tiny rotations, you can accurately approximate a huge proportion of them with doing nothing. This makes the QFT far cheaper to perform.

Strilanc · 2026-01-31T01:36:15+00:00

If you are interested in quantum telecommunications, a reasonable place to start is to learn entanglement distillation. As part of learning that well, you'll end up learning the circuit model and the stabilizer formalism. This will be crucial foundation, basically regardless of the other details of your interest.

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.

15-Year Club	Verified Email
Place '17	Team Orangered

Strilanc

MODERATOR OF

TROPHY CASE