Equivalent Quantum Codes

Question

In quantum error correction, two codes are considered to be equivalent if they differ by a locally unitary operator and a permutation. I would imagine that such codes should have the same error-correcting capabilities. Maybe it is too basic, but I am failing to see this, and I am also failing to find it explained in literature.

To make the answer easier, I am looking for the following:

1) If an error set is correctable by a code, is it also correctable by an equivalent code? And why?

2) Is this equivalence notion a natural thing to do? And why?

If it helps, feel free to restrict yourselves on stabilizer codes.

UPDATE: Why do two equivalent codes have the same error correcting capabilities?For instance, do they have the same minimum distance?

Answer 1

Two equivalent quantum error-correcting codes have the same distance. They don't necessarily have the same set of correctable errors if it is an asymmetric set.

Consider the definition of distance: $$\langle \psi_i | E | \psi_j \rangle = C_{E} \delta_{ij}$$ for basis vectors $|\psi_i\rangle$ and errors $E$ with weight less than the distance $d$. Let $U$ be a local unitary and permutation mapping between two equivalent codes. Then a basis for the second code is $U |\psi_i\rangle$. We thus want to show that $$\langle \psi_i | U^\dagger E U |\psi_j \rangle = C'_{E} \delta_{ij}.$$

A local unitary is a tensor product of single-qubit operations, in which case $U^\dagger E U$ has the same weight as $E$. Similarly, if $U$ is a permutation, $U^\dagger E U$ also has the same weight as $E$. Letting $F=U^\dagger E U$, the result follows, with $C'_{E} = C_F$.

To be more explicit re question 2: Local unitaries plus permutations is exactly the set of unitaries that preserve weight for all $E$. If you care about distance, it is a completely natural thing to look at.

Answer 2

There's at least some trivial cases where the equivalence doesn't hold.

The error set {I, X} is corrected by classical error correcting codes (over the computational basis Z). But switch the computational basis from Z to X (which you can do with local transformations), and you aren't protected anymore. Classical codes only protect along one axis per qubit, and local unitary operations can push them off that axis.

(I'm not sure if that meets your criteria or not... classical ECCs also break in other ways in the presence of quantum operations. An I-vs-X between two Hs is an I-vs-Z, and so won't be corrected.)