Blog post: "Actually, you can't test if quantum uses complex numbers" algassert.com/post/2501 I doom the concept of that 2021 Nature paper by showing how to compile any distributed quantum protocol into real-only gates while preserving locality.

Remember the Nature paper constructing an experiment to distinguish real-number-only QM from complex-number-using QM? In the supplementary material, they admit it doesn't work if pre-shared entanglement is present. Which there's no way to test for. So the experiment doesn't actually do the thing.

Apparently September 5th is "cultivate with fold-transversal S" day: arxiv.org/abs/2509.05232 arxiv.org/abs/2502.017... arxiv.org/abs/2509.05212

I used to write TODOs in my code. Now I write DIDNTDOs. Because let's be honest... these are apologies, not promises. // DIDNTDO: handle negative values

Been awhile since I wrote a blog post. Anyways... why haven't quantum computers factored 21 yet? algassert.com/post/2500

Was wondering why my code suddenly got HALF AS FAST. I traced it to extra error info.. in a switch default that never even runs! I think the compiler was unconditionally constructing a location for the temporary string or something?? 🤮 Clear example why people trust C more than C++.

Been experimenting with generating circuit-specialized simulation code, to reduce branch mispredictions. Generating a 1M line NASM file has gone far better than a 1M line C++ file. nasm finishes in a few seconds on inputs of that size (gcc was taking hours). But still unnecessarily slow...

The recording of my talk on denser planar storage, at QEC2025: yale.hosted.panopto.com/Panopto/Page... And the slides: docs.google.com/presentation...

An identity that'd be great... if it did 2 things instead of 3. If one of the two CCZs on the right wasn't there, it'd yield an n-qubit incrementer with ̶4̶n̶→3n T gates. If the CCCZ wasn't there, it'd yield n single-shared-control Toffolis to be done with ̶4̶n̶→3n T gates.

The first novel thing I did in quantum computing was find a way add +1 to a register using O(1) space and O(n) gates. For 10 years I've wanted to know how to generalize that from x+=1 to x+=C... and I finally figured out a way to do it! arxiv.org/abs/2507.23079

Chevignard's QIP2025 talk on reducing the space cost of quantum factoring: www.youtube.com/watch?v=R3yM... And her co-author Schrottenloher's talk at the Simons Summer Cluster on Quantum Computing: www.youtube.com/watch?v=0pnX...

My QIP2025 talk on magic state cultivation: www.youtube.com/watch?v=bbR0... A later longer version of the talk, given at the Simons quantum colloquium: www.youtube.com/watch?v=gxzt...

People complain that the "find the cycle in a linked list" interview question is contrived. I thought that too… til I was writing the loop analysis in stim's circuit-to-dem conversion, realized it was analogous, and the standard answer was way better than what I'd been writing.

A circuit compilation exercise. Show that MX+CX+T is a universal gateset by constructing an H gate. MX: X basis measurement CX: controlled NOT T: 45 degree rotation around Z axis (Classical feedback and ancillas is allowed.)

A reminder that if your paper has open data containing stim circuits, I keep a list of those and you can be on the list. I know my 2025 list so far is incomplete: github.com/quantumlib/S...

Based on Zenodo stats, people like the cultivation and factoring papers way more than my others. In the same league as downloads of the below surface code threshold experiment data! Could be recency bias (average rate should drop over time) but the totals are already higher.

I found a nice way to draw multi-qubit-parity controls. Lattice surgery likes accessing these kinds of operators, so it'd be counter-productive to decompose them using CX gates while hoping a later step would put them back together. Having notation that avoids that is handy.

A CPU can add 32bit numbers in a nanosecond. In my quantum factoring estimate, I also used 32bit adders. They're a bit slower. Each superposed add costs TWO MILLION nanoseconds. Quantum factoring isn't fast because of fast operations; it's fast because it uses *few* operations.

Quantum attacks on elliptic curve crypto have costs dominated by one operation: uncomputing a division (see fig15 and fig20 of arxiv.org/abs/2302.06639). Masking makes it easy to *compute* a division, but isn't reversible (arxiv.org/abs/2008.04577). Very unusual situation. I bet it can be fixed.

I'm often asked if I'll redo the 2019 quantum factoring estimate. Denser storage by yokes, smaller magic factories by cultivation, slimmer approx arithmetic by Chevignard et al… surely the cost is lower now? Yes, it's lower now. security.googleblog.com/2025/05/trac... arxiv.org/abs/2505.15917

Mike finally paid for the "pro" version of sketchup, so we owned the 3d models attached to the paper, meaning the yoked surface codes paper is now published! www.nature.com/articles/s41... The message of this paper is: anytime someone says they're 10x better than surface codes, actually it's 4x.

Just released stim v1.15 (github.com/quantumlib/S...) Probably the most important change is instructions can now be tagged with arbitrary strings (for custom tools that want to smuggle info into circuits). Also, now all 24 single qubit Clifford rotations have names.

Months ago, Greg K-M told me something amazing: the QFT is approximated by a 1D-local circuit! Well.. not quite. I realized that'd make the Draper adder local, so carries couldn't possibly work. Greg and others then proved the local circuit works in most relevant cases: arxiv.org/abs/2505.00701

I added MBQC decompositions to the stim gate documentation (github.com/quantumlib/S...). These were made by hand (with automation to solve the feedback), so I kinda wonder if it's possible to do substantially better. Like... my SQRT_ZZ uses 8 two-qubit measurements. Surely that's suboptimal?

A diagram of the 3 coupler surface code cycle (from arxiv.org/abs/2412.14360). It's interesting people missed it for so long. I'd have sworn it was impossible before we found it. I think it was hard to find because it oscillates between two surface codes. Probably lots of stuff like that out there.

For world quantum day this year I've turned off all collapse processes, ensuring a fully quantum world all day. Don't worry, your experiences will have been real again tomorrow when collapse turns back on. Plus there's no observable distinction. I'm not even sure if I hit the right button. /s

Tomorrow I'm giving a zoom talk on magic state cultivation at the Simons quantum Colloquium. Apr 8, 10am PST, see simons.berkeley.edu/programs-eve... Cultivation is the (current) culmination of a decade of work ending the reign of T gates as the dominant cost in fault tolerant quantum computation.

More evidence you should be thinking about fault tolerance in terms of circuits, not codes: arxiv.org/abs/2504.02749 An error correcting code is a cross section of a fault tolerant circuit. Cross sections are useful, but so is standing back and considering the whole object.

For sigbovik, I factored all 8 bit ints (up to 255) with a quantum computer github.com/strilanc/fal... I did it as legit as I possibly could. I ran a correct circuit with no optimization shenanigans. I did correct pre/postprocessing. It took 121 quantum samples to finish the entire task. But...

Stim has a lot of Q&A-driven-design. Someone asks a question on stack exchange, I start writing an answer, I think "this answer is lame, why isn't it just __", then I add __ to the API. Recent example: github.com/quantumlib/S... due to quantumcomputing.stackexchange.com/questions/41...

Wrote down the brute force case by case has-to-be-right-by-being-explicit version of single-qubit Clifford multiplication. Then applied identities for longer than I want to admit. It got a lot smaller (see image).

I'm adding the rest of the single qubit cliffords to the next version of stim. It's just convenient, when generating/optimizing/parsing circuits, to know for sure that every rotation can be a single instruction. Now tempted to define a CliffordString class... Just haven't *needed* it yet.

A misleading slide shown at QIP2025. The surface code number is 10x too high (should be 0.1% not 1%; see fig 1c of arxiv.org/abs/2408.13687) and the tesseract number omits the worst 18% of shots (see table III of arxiv.org/abs/2409.04628).

Slides from my QIP talk on magic state cultivation: docs.google.com/presentation...

If qubits only talk to 1D neighbors, is constant rate fault tolerance possible? Last year I referee'd a paper claiming it wasn't. My review was "this is wrong but the constructive disproof is too large for this review". Clearly a reviewer 2 move. Sorry. But I was right! scirate.com/arxiv/2502.1...

If you approximate a phase gradient state with stabilizers it kinda... just... works? Mostly? The approximation has a fidelity of ~80%, so there needs to be 80% overlap with the correct result even when doing things like QFTs that want fine grained angles. Weird! algassert.com/quirk#circui...

Me? Nerd sniped? I needed phase gradient qubits, and was using sequences from gridsynth. That has 33% waste because gridsynth makes rotations (3DOF) not states (2DOF). But this isn't a key part of the paper. And it's fine. It doesn't matter. There's more important... Hm. Maybe mitm would work...

Here is the Simons institute talk I never got to give, due to a flight cancellation. Given to whoever I could round up, instead: youtu.be/SyW1LkbFv6k It definitely shows that this was intended for a technical audience. But there's some good audience interaction.

With two qubits of storage you can measure a series of shingled operators like AB, BC, CD, DE, etc while touching each data qubit once. The trick is to mask measurements of A,B,C,D,E, etc with a GHZ state. ...kinda equivalent to storing X til you get Y, to compute XY, now drop X but store Y, etc.

Who hurt you

Tried my hand at vectorizing sampling of a geometric distribution (it's useful for qec sims). Got it down to 1.5 nanoseconds per sample, but with sorta low quality (~100k samples for a perfect distinguisher to become 2:1 confident it's not perfect). gist.github.com/Strilanc/4f0...

It's weird. Often when I answer a stack exchange question, they ask me wtf I did to make the circuit. Isn't it obvious? /sarc

God github actions are so brittle. Every month there's some random thing that breaks despite no change to the config file. Currently my javascript tests are failing because puppeteer can't start chromium because [???]. Separately, clion decided it doesn't understand my cmake files now. Ughhhhhhhh

Superposition masking (arxiv.org/abs/2008.04577) gives a cheap way to compute |x⟩ → |x⁻¹,x⟩ using a few quantum*=classical multiplications. But the trick doesn't work for uncomputing |x⁻¹,x⟩ → |x⁻¹⟩, so afaik ~all the cost of inverting is clearing the original register. Easy to grow, hard to squish.

How to write a paper. (1) Come up with a clever idea. (2) Write a lot of paragraphs describing it. (3) Delete those paragraphs because there's a simpler idea that makes all that irrelevant. (4) Repeat.

After spending a day trying to solve a thing ... wait... is this just matrix multiplication ...? 🤦 okay well that fixes that now onto the next thing that's secretly just matrix multiplication

A tell for theory-vs-practice in quantum magic states is mentioning γ. In theory, γ dominates by determining how costs compound as stages are added. In practice we'll do MAYBE 1 stage of distillation past cultivation, enough to be more reliable than transistors, and then stop. Making γ irrelevant.

Stim is a tool for simulating quantum error correction. I made it because previous tools were limited to operating on the abstractions used to make QEC circuits, instead of the circuits themselves. It took a few years to catch on, but is now common. Used by 198 papers in 2024.

Interesting paper implementing magic state distillation with neutral atoms: arxiv.org/abs/2412.15165 They're in a weird regime: below the distillation threshold but over the color code threshold. They see improvements!... But hit a ceiling imposed by their d=3 memory error (because d=5 does worse).

Over the past year I played a supporting role on experiments showing we have a flexibility in how we do QEC on a planar chip. We do a color code (arxiv.org/abs/2412.14256), and three interesting variations of the surface code circuit (arxiv.org/abs/2412.14360), all below threshold.