**A scrape stood out on the back of my left hand. The scrape had turned greenish-purple, I noticed while opening the lecture-hall door. I’d jounced the hand against my dining-room table while standing up after breakfast. The table’s corners form ninety-degree angles. The backs of hands do not.**

Earlier, when presenting a seminar, I’d forgotten to reference papers by colleagues. Earlier, I’d offended an old friend without knowing how. Some people put their feet in their mouths. I felt liable to swallow a clog.

The lecture was for Ph 219: Quantum Computation. I was TAing (working as a teaching assistant for) the course. John Preskill was discussing quantum error correction.

Computers suffer from errors as humans do: Imagine setting a hard drive on a table. Coffee might spill on the table (as it probably would have if I’d been holding a mug near the table that week). If the table is in my California dining room, an earthquake might judder the table. Juddering bangs the hard drive against the wood, breaking molecular bonds and deforming the hardware. The information stored in computers degrades.

How can we protect information? By encoding it—by translating the message into a longer, encrypted message. An earthquake might judder the encoded message. We can reverse some of the damage by *error-correcting*.

Different types of math describe different codes. John introduced a type of math called *symplectic vector spaces*. “Symplectic vector space” sounds to me like a garden of spiny cacti (on which I’d probably have pricked fingers that week). Symplectic vector spaces help us translate between the original and encoded messages.

Say that an earthquake has juddered our hard drive. We want to assess how the earthquake corrupted the encoded message and to error-correct. Our encryption scheme dictates which operations we should perform. Each possible operation, we represent with a mathematical object called a *vector*. A vector can take the form of a list of numbers.

We construct the code’s vectors like so. Say that our quantum hard drive consists of seven phosphorus nuclei atop a strip of silicon. Each nucleus has two *observables*, or measurable properties. Let’s call the observables *Z* and *X*.

Suppose that we should measure the first nucleus’s *Z*. The first number in our symplectic vector is 1. If we shouldn’t measure the first nucleus’s *Z*, the first number is 0. If we should measure the second nucleus’s *Z*, the second number is 1; if not, 0; and so on for the other nuclei. We’ve assembled the first seven numbers in our vector. The final seven numbers dictate which nuclei’s *X*s we measure. An example vector looks like this: .

The vector dictates that we measure four *Z*s and no *X*s.

A *vector space* is a collection of vectors. Many problems—not only codes—involve vector spaces. Have you used Google Maps? Google illustrates the step that you should take next with an arrow. We can represent that arrow with a vector. A vector, recall, can take the form of a list of numbers. The step’s list of two^{1 }numbers indicates whether you should walk^{ }.

I’d forgotten about my scrape by this point in the lecture. John’s next point wiped even cacti from my mind.

Say you want to know how similar two vectors are. You usually calculate an *inner product*. A vector *v* tends to have a large inner product with any vector *w* that points parallel to *v*.

The vector *v* tends to have an inner product of zero with any vector *w* that points perpendicularly. Such *v* and *w* are said to *annihilate* each other. By the end of a three-hour marathon of a research conversation, we might say that *v* and *w* “destroy” each other. *v* is *orthogonal* to *w*.

You might expect a vector *v* to have a huge inner product with itself, since *v* points parallel to *v*. Quantum-code vectors defy expectations. In a symplectic vector space, John said, “you can be orthogonal to yourself.”

A symplectic vector^{2}^{ }can annihilate itself, destroy itself, stand in its own way. A vector can oppose itself, contradict itself, trip over its own feet. I felt like I was tripping over my feet that week. But I’m human. A vector is a mathematical ideal. If a mathematical ideal could be orthogonal to itself, I could allow myself space to err.

Lloyd Alexander wrote one of my favorite books, the children’s novel *The Book of Three*. The novel features a stout old farmer called Coll. Coll admonishes an apprentice who’s burned his fingers: “See much, study much, suffer much.” We smart while growing smarter.

An ant-sized scar remains on the back of my left hand. The scar has been fading, or so I like to believe. I embed references to colleagues’ work in seminar Powerpoints, so that I don’t forget to cite anyone. I apologized to the friend, and I know about symplectic vector spaces. We all deserve space to err, provided that we correct ourselves. Here’s to standing up more carefully after breakfast.

^{1}Not that I advocate for limiting each coordinate to one bit in a Google Maps vector. The two-bit assumption simplifies the example.

^{2}Not only symplectic vectors are orthogonal to themselves, John pointed out. A string of an even number of bits has a bit-wise inner product of zero with itself. Examples of such strings include (0, 0, 0, 0, 1, 1, 1).