Close
About
FAQ
Home
Collections
Login
USC Login
Register
0
Selected
Invert selection
Deselect all
Deselect all
Click here to refresh results
Click here to refresh results
USC
/
Digital Library
/
University of Southern California Dissertations and Theses
/
Quantum coding with entanglement
(USC Thesis Other)
Quantum coding with entanglement
PDF
Download
Share
Open document
Flip pages
Contact Us
Contact Us
Copy asset link
Request this asset
Transcript (if available)
Content
QUANTUM CODING WITH ENTANGLEMENT
by
Mark McMahon Wilde
A Dissertation Presented to the
FACULTY OF THE GRADUATE SCHOOL
UNIVERSITY OF SOUTHERN CALIFORNIA
In Partial Fulllment of the
Requirements of the Degree
DOCTOR OF PHILOSOPHY
(ELECTRICAL ENGINEERING)
August 2008
Copyright 2008 Mark McMahon Wilde
Dedication
To my parents
Gregory and Sharon Wilde
And to my grandparents
Joseph and Rose McMahon
Norbert Jay and Mary Wilde
ii
Acknowledgements
The completion of this Ph.D. has been a long and dicult road with many wonderful memories
along the way. I can truly say that there is no way I could have completed it without the help
and encouragement from many people.
I rst thank my advisor Todd Brun. His help and deep knowledge have been indispensable
throughout and I am grateful that he took me on as his student. Our many research meetings have
been valuable and I am thankful that Todd gave his time for me. I cannot imagine what a better
advisor would be like. I can recall visiting USC in March 2004 for a Ph.D. recruitment trip. I saw
a posting on the wall that said there would be a seminar on quantum computing and that Todd
Brun was the host. It was from this point that I became fascinated by quantum information, had
a desire to contribute original research to the eld, and thought it would be great if Todd Brun
were my advisor. I look back now and am pleased that all of these dreams have come to fruition.
I next thank Igor Devetak. He was the rst to teach me quantum information theory and I
am grateful for the many times that he met with me. I met with Igor about one hour per week
in the academic semesters of 2005-2006 and these formative meetings helped shape and rene my
knowledge of quantum information theory. I am also grateful that Igor invited me to join Todd
and Igor's research group meetings.
I thank Jonathan Dowling for accepting me into his research group at LSU during the summers
of 2005-2006. I learned so much about quantum optics by conversing with him and the other
members of his lab. The research environment that Jon creates by having so many seminars and
bringing in visitors is a great one to be involved in.
I am grateful to Daniel Lidar for his collaboration and for teaching his course on quantum
error correction at USC. After this class, I can say that my research really took o because I was
able to solidify my knowledge of quantum error correction.
I am in debt to Bart Kosko for working with me during the initial period of my Ph.D. He
gave valuable advice for how to be a good teacher and researcher and taught me how to have the
iii
discipline required of a good researcher. When I was a teaching assistant, I simply tried to teach
like he does and I think I won the Best Teaching Assistant Award for this reason.
I thank Diane Demetras for being a great grad student \mom" away from home. I owe thanks to
Antonio Ortega for initially giving me advice. I also thank the fth
oor sta|Milly Montenegro,
Mayumi Thrasher, and Gerrielyn Ramos|for providing a pleasant working environment and for
ling all those technical reports that I asked to le. I hope our softball team wins! Shock 'em,
Volts!
I thank my collaborators Hari Krovi and Austin Lund for helping me along the way. Austin
was invaluable during the rst summer at LSU when he answered my questions. Hari was a big
help in all of our collaborations and especially when we were rst trying to gure out what Todd,
Igor, and Min-Hsiu had done with entanglement-assisted quantum codes. I also thank everyone
else in the group, Min-Hsiu Hsieh, Zhicheng Luo, Ognyan Oreshkov, Shesha Raghunathan, Bilal
Shaw, Martin Varbanov, for being a good group of guys to work with. I learned a lot from our
debates and conversations.
I nally thank my family for their support. I especially thank my dad \Jack" for the many
long Ph.D. conversations that we have had on the phone and for being excited about my research.
I thank all of the wonderful friends I have made while in the City of Angels, especially Ali, Ben,
Mary L., and Mary B., and I thank Fr. Lawrence for our spiritual conversations. I lastly give a
\shout out" to Santa Monica power yoga studios for providing a great environment for destressing
and to Pete Carroll for having an awesome Trojan football team! Fight on!
iv
Table of Contents
Dedication ii
Acknowledgements iii
List of Tables viii
List of Figures ix
Abstract xii
Chapter 1: Introduction 1
1.1 Quantum Error Correction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.1.1 Stabilizer Quantum Coding . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.1.2 Entanglement-Assisted Stabilizer Quantum Coding . . . . . . . . . . . . . . 3
1.1.3 Convolutional Stabilizer Quantum Coding . . . . . . . . . . . . . . . . . . . 4
1.2 Connections to Quantum Shannon Theory . . . . . . . . . . . . . . . . . . . . . . . 6
1.2.1 Communication Protocols . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
1.2.2 Distillation Protocols . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9
1.3 Organization of this Thesis . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
Chapter 2: Stabilizer Quantum Codes 11
2.1 Review of the Stabilizer Formalism . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
2.2 Cliord Encoding Unitary . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
2.3 The Logical Operators and the Information Qubits . . . . . . . . . . . . . . . . . . 16
2.4 The Pauli-to-Binary Isomorphism . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
2.5 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
2.6 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Chapter 3: Entanglement-Assisted Stabilizer Quantum Codes 21
3.1 Review of the Entanglement-Assisted Stabilizer Formalism . . . . . . . . . . . . . . 22
3.2 The Symplectic Product Matrix . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25
3.3 The Rate of an Entanglement-Assisted Quantum Code . . . . . . . . . . . . . . . . 26
3.4 Example of an Entanglement-Assisted Code . . . . . . . . . . . . . . . . . . . . . . 27
3.5 Encoding Algorithm . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
3.6 Optimal Entanglement Formulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.7 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
Chapter 4: Quantum Convolutional Codes 41
4.1 Review of the Convolutional Stabilizer Formalism . . . . . . . . . . . . . . . . . . . 42
v
4.1.1 Quantum Convolutional Code Denition . . . . . . . . . . . . . . . . . . . . 43
4.1.2 Quantum Convolutional Code Operation . . . . . . . . . . . . . . . . . . . 45
4.2 The Pauli-to-Binary Isomorphism for Quantum Convolutional Codes . . . . . . . . 46
4.3 The Shifted Symplectic Product . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
4.4 Row and Column Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
4.5 Finite-Depth Cliord Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . . 56
4.6 Innite-Depth Cliord Operations . . . . . . . . . . . . . . . . . . . . . . . . . . . 57
4.6.1 Examples of Innite-Depth Operations . . . . . . . . . . . . . . . . . . . . . 58
4.6.2 General Innite-Depth Operations . . . . . . . . . . . . . . . . . . . . . . . 63
4.6.3 Innite-Depth Operations in Practice . . . . . . . . . . . . . . . . . . . . . 67
4.7 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Chapter 5: Entanglement-Assisted Quantum Convolutional Coding: The CSS
Case 69
5.1 Operation of an Entanglement-Assisted Quantum Convolutional Code . . . . . . . 70
5.2 The CSS Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72
5.3 Codes with Finite-Depth Encoding and Decoding Circuits . . . . . . . . . . . . . . 77
5.4 Codes with Innite-Depth Encoding and Finite-Depth Decoding Circuits . . . . . . 83
5.4.1 Special Case with Coherent Teleportation Decoding . . . . . . . . . . . . . 88
5.4.2 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
5.5 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
Chapter 6: Entanglement-Assisted Quantum Convolutional Coding: The Gen-
eral Case 99
6.1 The Expansion of Quantum Convolutional Generators . . . . . . . . . . . . . . . . 101
6.1.1 Example of the Expansion . . . . . . . . . . . . . . . . . . . . . . . . . . . . 101
6.1.2 General Technique for Expansion . . . . . . . . . . . . . . . . . . . . . . . . 104
6.2 Polynomial Symplectic Gram-Schmidt Orthogonalization Procedure . . . . . . . . 105
6.2.1 Example of the Procedure . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105
6.2.2 The Procedure for General Codes . . . . . . . . . . . . . . . . . . . . . . . . 109
6.3 Encoding and Decoding Circuits . . . . . . . . . . . . . . . . . . . . . . . . . . . . 114
6.3.1 Discussion . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121
6.3.2 Importing Classical Convolutional Codes over GF (4) . . . . . . . . . . . . 121
6.4 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 122
6.5 Optimal Entanglement Formulas . . . . . . . . . . . . . . . . . . . . . . . . . . . . 126
6.6 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 127
Chapter 7: Entanglement-Assisted Quantum Convolutional Coding: Free En-
tanglement 129
7.1 Construction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 130
7.2 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 137
7.3 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 140
Chapter 8: Unied Quantum Convolutional Coding 141
8.1 Grandfather Quantum Convolutional Codes . . . . . . . . . . . . . . . . . . . . . . 142
8.2 Example . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 145
8.3 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 150
Chapter 9: Convolutional Entanglement Distillation 151
vi
9.1 Stabilizer Entanglement Distillation without Entanglement Assistance . . . . . . . 153
9.2 Stabilizer Entanglement Distillation with Entanglement Assistance . . . . . . . . . 155
9.3 Convolutional Entanglement Distillation without Entanglement Assistance . . . . . 156
9.4 Convolutional Entanglement Distillation with Entanglement Assistance . . . . . . 159
9.4.1 Yield (n-1)/n Convolutional Entanglement Distillation . . . . . . . . . . . . 159
9.4.2 Yield (n-m)/n Convolutional Entanglement Distillation . . . . . . . . . . . 164
9.4.3 CSS-Like Construction for Convolutional Entanglement Distillation . . . . 168
9.5 Closing Remarks . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 172
Chapter 10: Conclusion 174
Bibliography 176
vii
List of Tables
8.1 A list of possible single-qubit errors in a particular frame and the corresponding
syndrome vector. The syndrome corresponding to any single-qubit error is unique.
The code therefore corrects an arbitrary single-qubit error in every other frame. . . 149
9.1 The convolutional entanglement distillation protocol for Example 9.4.1 corrects for
a single-qubit error in every fourth frame. Here we list the syndromes corresponding
to errors X
1
, Y
1
, and Z
1
on the rst qubit and to errors X
2
, Y
2
, and Z
2
on the
second qubit. The syndromes are unique so that the receiver can identify which
error occurs. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
viii
List of Figures
2.1 The operation of a stabilizer code. Thin lines denote quantum information and
thick lines denote classical information. Slanted bars denote multiple qubits. A
sender encodes a multi-qubit statej i with the help of some ancilla qubitsj0i.
She sends the encoded state over a noisy quantum channel. The receiver performs
multi-qubit measurements to extract information about the errors. He nally
performs a recovery operation R to reverse the channel error. . . . . . . . . . . . 13
3.1 The operation of an entanglement-assisted quantum error-correcting code. The
sender encodes quantum information in statej i with the help of local ancilla
qubitsj0i and her half of a set of shared ebitsj
+
i. She then sends her qubits
over a noisy quantum channel. The channel does not corrupt the receiver's half
of the set of shared ebits. The receiver performs multi-qubit measurements on all
of the qubits to diagnose the channel error. He performs a recovery unitary R to
reverse the estimated channel error. . . . . . . . . . . . . . . . . . . . . . . . . . . 24
3.2 Encoding circuit for the entanglement-assisted code in the example of Section 3.4.
The \H" gate is a Hadamard gate and the \P" gate is a phase gate. . . . . . . . 32
4.1 The operation of a quantum convolutional code. The sender applies the same uni-
tary successively to a stream of information qubits and ancilla qubits. The convo-
lutional structure implies that the unitary overlaps some of the same qubits. The
sender transmits her qubits as soon as the unitary nishes processing them. The
noisy quantum channel corrupts the transmitted qubits. The receiver performs
overlapping multi-qubit measurements to diagnose channel errors and corrects for
them. The receiver performs an online decoding circuit to recover the sender's
original stream of information qubits. . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.2 An example of an innite-depth operation. A sequence of CNOT gates acts on
the third qubit of every frame. This innite-depth operation eectively multiplies
the third column of the \X" side of the binary polynomial matrix by the rational
polynomial 1= (1 +D) and multiplies the third column of the \Z" side of the
binary polynomial matrix by 1 +D
1
. . . . . . . . . . . . . . . . . . . . . . . . . 61
4.3 Another example of an innite-depth operation. An innite-depth operation acts
on qubit i in every frame. This particular innite-depth operation multiplies
column i on the \X" side of the binary polynomial matrix by 1=
1 +D +D
3
and multiplies column i on the \Z" side of the binary polynomial matrix by
1 +D
1
+D
3
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
ix
5.1 (Color online) An entanglement-assisted quantum convolutional code operates on
a stream of qubits partitioned into a countable number of frames. The sender
encodes the frames of information qubits, ancilla qubits, and half of shared ebits
with a repeated, overlapping encoding circuit U. The noisy channel aects the
sender's encoded qubits but does not aect the receiver's half of the shared ebits.
The receiver performs overlapping measurements on both the encoded qubits and
his half of the shared ebits. These measurements produce an error syndrome
which the receiver can process to determine the most likely error. The receiver
reverses the errors on the noisy qubits from the sender. The nal decoding circuit
operates on all qubits in a frame and recovers the original stream of information
qubits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71
5.2 (Color online) The nite-depth encoding circuit for the entanglement-assisted
quantum convolutional code in Example 5.3.1. The above operations in reverse
order give a valid decoding circuit. . . . . . . . . . . . . . . . . . . . . . . . . . . 81
5.3 (Color online) The encoding and decoding circuits for the entanglement-assisted
quantum convolutional code in Example 5.4.1. The third series of gates in the
above encoding circuit is an innite-depth operation. The other operations in the
encoding circuit are nite-depth. The decoding circuit has nite-depth operations
only. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
7.1 (Color online) An online encoding circuit for an entanglement-assisted quantum
convolutional code. The receiver Bob possesses the rst two qubits in the two
ebits and the sender Alice possesses the second two qubits in the two ebits. The
sender encodes two information qubits per frame with the help of her half of the
two ebits. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 139
8.1 (Color online) The encoding circuit for the grandfather quantum convolutional
code in our example. Each frame i has an ebitj
+
i
BA
shared between Bob and
Alice, a fresh ancilla qubitj0i
A
, a gauge qubit
A
i
, an information classical bit
jx
i
i
A
, and an information qubitj
i
i
A
. Bob's qubits are blue and Alice's qubits
are red. Including the ebit and an ancilla qubit implies that the code incorporates
active quantum error correction. Including the gauge qubit implies that the code
has passive quantum error correction. The code provides passive error correction
of phase errors on the classical bit. Alice encodes her classical bits and qubits using
the encoding circuit above. The decoding circuit consists of the above operations
in reverse order. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 146
9.1 An example of a block entanglement distillation protocol. A sender creates a set
of noisy ebits by sending half of a set of Bell states through a noisy quantum
channel. Both sender and receiver perform multi-qubit measurements to diagnose
channel error. The sender transmits her measurement results to the receiver over a
classical communication channel. Both perform recovery and decoding operations
to obtain a set of noiseless ebits. . . . . . . . . . . . . . . . . . . . . . . . . . . . 153
x
9.2 An example of a convolutional entanglement distillation protocol taken from the
quantum convolutional code in Ref. [29]. The code in Ref. [29] has rate 1/3
and can correct for single-qubit errors in every other frame. Alice and Bob rst
measure the operators in the stabilizer for the quantum convolutional code. Alice
performs conditional unitaries on her qubits to restore them to the +1 eigenspace
of the stabilizer code. Alice forwards her measurement results to Bob. Bob
performs a maximum-likelihood decoding procedure such as Viterbi decoding [75]
to determine the qubit errors. He corrects for these errors. He restores his qubits
to the +1 eigenspace of the stabilizer code. Alice and Bob both perform online
decoding to obtain ebits with yield 1/3. . . . . . . . . . . . . . . . . . . . . . . . 156
9.3 The above gure illustrates Bob's side of the convolutional entanglement distil-
lation protocol that uses entanglement assistance. The noise aects the rst and
second of every three ebits that Bob shares with Alice. Every third ebit that
Alice and Bob share are noiseless. The measurements correspond to those in
Example 9.4.1. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163
xi
Abstract
Quantum error-correcting codes will be the ultimate enabler of a future quantum computing or
quantum communication device. This theory forms the cornerstone of practical quantum informa-
tion theory. We provide several contributions to the theory of quantum error correction|mainly
to the theory of \entanglement-assisted" quantum error correction where the sender and receiver
share entanglement in the form of entangled bits (ebits) before quantum communication begins.
Our rst contribution is an algorithm for encoding and decoding an entanglement-assisted quan-
tum block code. We then give several formulas that determine the optimal number of ebits for an
entanglement-assisted code. The major contribution of this thesis is the development of the the-
ory of entanglement-assisted quantum convolutional coding. A convolutional code is one that has
memory and acts on an incoming stream of qubits. We explicitly show how to encode and decode a
stream of information qubits with the help of ancilla qubits and ebits. Our entanglement-assisted
convolutional codes include those with a Calderbank-Shor-Steane structure and those with a more
general structure. We then formulate convolutional protocols that correct errors in noisy entan-
glement. Our nal contribution is a unication of the theory of quantum error correction|these
unied convolutional codes exploit all of the known resources for quantum redundancy.
xii
Chapter 1
Introduction
If computers that you build are quantum,
Then spies of all factions will want 'em.
Our codes will all fail,
And they'll read our email,
Till we've crypto that's quantum, and daunt 'em.
|Jennifer and Peter Shor
Q
UANTUM computation and communication have enormous potential to revolutionize the
way we compute and communicate. From communicating by teleportation of quantum
information [5] to breaking RSA encryption [69, 71], quantum technological breakthroughs will
change society in a way that is dicult to predict.
One might say that the eld of quantum computation began when Richard Feynman and others
suggested that a computer operating according to the principles of quantum mechanics would have
advantages over a computer operating according to the laws of classical physics [28, 3, 58]. They
suggested that it might be able to simulate quantum-mechanical processes more eciently than a
classical computer could. Later work then showed that it was possible to achieve this simulation
speedup [54]. Other major advances in the theory of quantum computing followed|examples
are Shor's algorithm for breaking RSA encryption [69, 71] and Grover's algorithm for searching a
database [37, 38].
1
The eld of modern quantum communication began with the discovery of quantum key distri-
bution [4]. Major discoveries for quantum communication followed|examples are the ability to
send a quantum bit using two classical bits and a bit of entanglement (quantum teleportation [5])
and the ability to send two classical bits by sending a quantum bit and consuming a bit of entan-
glement (quantum superdense coding [10]). Quantum information theorists then began to think
more deeply about the ways in which we could combine the resources of classical communication,
quantum communication, and entanglement to formulate new communication protocols.
In spite of these spectacular advances for the theories of quantum computation and communi-
cation, a dark shadow lingered over them. A few authors disputed that reliable quantum compu-
tation or communication would be possible because small quantum errors would accumulate as the
computation proceeds or channel errors would destroy the quantum bits as we communicate them
[52]. Rolf Landauer even urged his colleagues to include the following disclaimer in their papers
on quantum computation: \This scheme, like all other schemes for quantum computation, relies
on speculative technology, does not in its current form take into account all possible sources of
noise, unreliability and manufacturing error, and probably will not work." Various other obstacles
such as the no-cloning theorem [84] and measurement destroying a quantum state seemed to pose
an insurmountable barrier to a protocol for quantum error correction.
Despite the aforementioned obstacles, Shor demonstrated the rst quantum error-correcting
code that reduces the negative eects of decoherence on a quantum bit [70]. Shor's code overcame
all of the above diculties and established the basic principles for constructing a general theory
of quantum error correction [33, 16, 17]. Shor's code exploits many of the signature principles of
quantum mechanics: superposition, entanglement, unitary evolution, and measurement. Mermin
proclaims it a \miracle" that quantum error correction is even possible [59].
1.1 Quantum Error Correction
Quantum error correction theory [70, 18, 74, 33, 17] now plays a prominent role in the practical
realization and engineering of quantum computing and communication devices. The rst quantum
error-correcting codes [70, 18, 74, 17] are strikingly similar to classical block codes [57] in their
operation and performance. Quantum error-correcting codes restore a noisy, decohered quantum
2
state to a pure quantum state. Any future quantum information processing device will operate
faithfully only if it employs an error correction scheme. This scheme can be an active scheme [33],
a passive scheme [86, 85, 53], or a combination of both techniques [49, 50, 64, 15, 44].
The eld of quantum error correction has rapidly expanded in recent years because there
are so many ways in which one can correct quantum error. We brie
y introduce three notable
developments in the theory|these three are by no means exhaustive. The developments include
the stabilizer formalism, the entanglement-assisted stabilizer formalism, and the convolutional
stabilizer formalism.
1.1.1 Stabilizer Quantum Coding
Gottesman formalized the theory of quantum block coding by establishing the stabilizer formalism
[33]. A stabilizer quantum error-correcting code appends ancilla qubits to information qubits that
we want to protect. A unitary encoding circuit rotates the Hilbert space of the information
qubits into a subspace of a larger Hilbert space. This highly entangled, encoded state corrects for
local noisy errors. A quantum error-correcting code makes quantum computation and quantum
communication practical by providing a way for a sender and receiver to simulate a noiseless qubit
channel given a noisy qubit channel that has a particular error model.
The stabilizer theory of quantum error correction allows one to import some classical binary or
quaternary codes for use as a quantum code [17]. The Calderbank-Shor-Steane (CSS) construction
is the name for the method for importing classical binary codes [60]. This idea of importing codes
is useful because quantum code designers can utilize classical block codes with high performance
to construct quantum codes with high performance. The only \catch" when importing is that the
classical code must satisfy the dual-containing or self-orthogonality constraint. Researchers have
found many examples of classical codes satisfying this constraint [17], but most classical codes do
not.
1.1.2 Entanglement-Assisted Stabilizer Quantum Coding
Bowen was the rst to extend the stabilizer formalism by providing an example of a code that
exploits entanglement shared between a sender and a receiver [12]. The underlying assumption
of Bowen's code is that the sender and receiver share a set of noiseless ebits (entangled qubits)
3
before quantum communication begins. Many quantum protocols such as teleportation [5] and
superdense coding [10] are \entanglement-assisted" protocols because they assume that noiseless
ebits are available.
Brun, Devetak, and Hsieh extended the standard stabilizer theory of quantum error correction
by developing the entanglement-assisted stabilizer formalism [14, 13]. They included entanglement
as a resource that a sender and receiver can exploit for a quantum error-correcting code. They
provided a \direct-coding" construction in which a sender and receiver can use ancilla qubits and
ebits in a quantum code. An ebit is a nonlocal bipartite Bell state
+
= (j00i +j11i)=
p
2:
Gottesman later showed that their construction is optimal [31]|it gives the minimum number of
ebits required for the entanglement-assisted quantum code.
The major benet of the entanglement-assisted stabilizer formalism is that we can construct
an entanglement-assisted quantum code from two arbitrary classical binary block codes or from an
arbitrary classical quaternary block code. The rate and error-correcting properties of the classical
codes translate to the resulting quantum codes. The entanglement-assisted stabilizer formalism
may be able to reduce the problem of nding high-performance quantum codes approaching the
quantum capacity [55, 72, 23, 8, 9] to the problem of nding good classical linear codes approaching
the classical capacity [21]. The entanglement-assisted stabilizer formalism thus is a signicant and
powerful extension of the stabilizer formalism.
1.1.3 Convolutional Stabilizer Quantum Coding
Another extension of the theory of quantum error correction protects a potentially-innite stream
of quantum information against the corruption induced by a noisy quantum communication chan-
nel [61, 62, 34, 35, 36, 30, 29, 1, 2, 82, 76, 80]. Quantum convolutional codes have numerous ben-
ets. The periodic structure of the encoding and decoding circuits for a quantum convolutional
code ensures a low complexity for encoding and decoding while also providing higher performance
than a block code with equivalent encoding complexity [29]. The encoding and decoding circuits
have the property that the sender Alice and the receiver Bob can respectively send and receive
4
qubits in an \online" fashion. Alice can encode an arbitrary number of information qubits without
worrying beforehand how many she may want to send over the quantum communication channel.
We believe that quantum convolutional coding theory is one step along the way to nding
quantum error-correcting codes that approach the capacity of a noisy quantum communication
channel for sending quantum information [55, 72, 23, 40, 47, 43, 41]. Poulin et al. have recently
incorporated some of this well-developed theory of quantum convolutional coding into a theory
of quantum serial-turbo coding [65] with the goal of designing quantum codes that come close to
achieving capacity.
The development of quantum convolutional codes has been brief but successful. Chau was the
rst to construct some quantum convolutional codes [19, 20], though some authors [29] argue that
his construction does not give a true quantum convolutional code. Several authors have established
a working theory of quantum convolutional coding based on the stabilizer formalism and classical
self-orthogonal codes over the nite eld GF (4) [61, 62, 30, 29]. Others have also provided a
practical way for realizing \online" encoding and decoding circuits for quantum convolutional
codes [61, 62, 35, 34].
Forney et al. have determined a method for importing an arbitrary classical self-orthogonal
quaternary code for use as a quantum convolutional code [30, 29]. The technique is similar to that
for importing a classical block code as a quantum block code [17]. Forney et al. showed how to
produce quantum convolutional codes from classical convolutional codes by extending the ideas
from the CSS construction to the convolutional setting [29]; but again, these imported classical
convolutional codes have to satisfy the restrictive dual-containing constraint in order to form valid
quantum codes. The dual-containing constraint is actually quite a bit more restrictive in the
convolutional case because each generator for the quantum convolutional code must commute not
only with the other generators, but it must commute also with any arbitrary shift of itself and any
arbitrary shift of the other generators. Forney et al. performed specialized searches to determine
classical quaternary codes that satisfy the restrictive self-orthogonality constraint [29].
5
1.2 Connections to Quantum Shannon Theory
Quantum error correction theory gives practical ways to build codes for protection of quantum
information against decoherence. A quantum code typically encodes some numberk of information
qubits into a larger numbern of physical qubits. We say that the rate of quantum communication
for this code is k=n.
One may ask the question: what is the maximum rate of quantum communication for a given
noisy quantum communication channel? This question is the fundamental question of quantum
Shannon theory and the answer to it is a quantity known as the capacity of the quantum channel
for quantum communication, or more simply, the quantum capacity [55, 72, 23, 24]. Quantum
Shannon theory has many other questions. What is the rate of classical communication for a
noisy quantum communication channel? What is the rate if the sender and receiver have access
to entanglement? What is the rate of simultaneous classical and quantum communication? The
list of questions goes on and on.
The goal of quantum Shannon theory is to quantify the amount of quantum communica-
tion, classical communication, and entanglement required for various information processing tasks
[55, 72, 23, 24]. Quantum teleportation and superdense coding provided the initial impetus for
quantum Shannon theory because these protocols demonstrate that we can combine entanglement,
noiseless quantum communication, and noiseless classical communication to transmit quantum or
classical information. In practice, the above resources are not noiseless because quantum systems
decohere by interacting with their surrounding environment. Quantum Shannon theory is a col-
lection of capacity theorems that determine the ultimate limits for noisy quantum communication
channels. Essentially all quantum protocols have been unied as special cases of a handful of
abstract protocols [24].
The techniques in quantum Shannon theory determine the asymptotic limits for communi-
cation, but these techniques do not produce practical ways of realizing these limits. This same
practical problem exists with classical Shannon theory because random coding techniques deter-
mine the limit of a noisy classical communication channel [67].
6
1.2.1 Communication Protocols
The fundamental theorem of quantum Shannon theory is the celebrated Lloyd-Shor-Devetak quan-
tum capacity theorem. It determines the capacity of a given noisy quantum communication chan-
nel for reliable quantum communication. Suppose that a noisy quantum channelN connects a
sender AliceA to a receiver BobB. Let [q!q] denote one qubit of noiseless quantum communi-
cation. We can state the coding theorem as a resource inequality:
hNiQ [q!q]; (1.1)
The above resource inequality states that n uses of the noisy quantum channelN are sucient
to communicate nQ noiseless qubits in the limit of a large number n of channel uses. The rate Q
is equal to a quantity known as the coherent information: I (AiB) [60]. The entropic quantity is
maximized with respect to any resource statej i
ABE
associated to the noisy channelN and shared
between Alice, Bob, and the environment E. The goal of the stabilizer codes and convolutional
stabilizer codes mentioned respectively in Sections 1.1.1 and 1.1.3 is for their rates to approach
the maximum capacity given above.
Another example of an important capacity theorem from quantum Shannon theory results from
the \father" protocol [24]. The father capacity theorem determines the optimal trade-o between
the rateE of ebits (entangled qubits in the statej
+
i
AB
(j00i
AB
+j11i
AB
)=
p
2) and the rateQ
of qubits in entanglement-assisted quantum communication. This protocol is the \father" protocol
because it generates many of the protocols in the family tree of quantum information theory [24].
The nickname \father" is a useful shorthand for classifying the protocol|there exists a mother,
grandmother, and grandfather protocol as well. Let [qq] denote one ebit of entanglement. The
following resource inequality is a statement of the capability of the father protocol:
hNi +E [qq]Q [q!q]: (1.2)
The above resource inequality states thatn uses of the noisy quantum channelN andnE noiseless
ebits are sucient to communicate nQ noiseless qubits in the limit of large n. The rates E and
Q are respectively equal to
1
2
I (A;E) and
1
2
I (A;B). The entropic quantities are maximized with
7
respect to any resource statej i
ABE
associated to the noisy channelN and shared between
Alice, Bob, and the environment E (the rate E is dierent from the environment E). The father
capacity theorem gives the optimal limits on the resources, but it does not provide a useful quantum
coding technique for approaching the above limits. The goal of the entanglement-assisted stabilizer
formalism mentioned in Section 1.1.2 is to develop quantum codes that approach the maximal rates
given in the father capacity theorem. We spend a signicant portion of this thesis (Chapters 5,
6, and 7) developing entanglement-assisted convolutional stabilizer codes. Future research might
be able to incorporate these convolutional codes into a framework for designing codes that come
close to achieving the maximal rates.
Another important capacity theorem determines the ability of a noisy quantum channel to send
\classical-quantum" states [26]. Let [c!c] denote one bit of noiseless classical communication.
The result of the classical-quantum capacity theorem is also a resource inequality:
hNiQ [q!q] +R [c!c]: (1.3)
The resource inequality states that n uses of the noisy quantum channel N are sucient to
communicate nQ noiseless qubits and nR noiseless classical bits in the limit of large n. The
ratesQ andR are respectively equal to I (X;B) andI (AiBX). The entropic quantities are with
respect to any state resulting from sending the A
0
system of the following classical-quantum state
X
x
p
x
jxihxj
X
j
x
ih
x
j
AA
0
(1.4)
through the quantum channelN
A
0
!B
. X andA are systems that the sender keeps. This theorem
proves that we can devise clever classical-quantum codes that perform better than time-sharing a
noisy quantum channelN between purely quantum codes and purely classical codes.
The \grandfather" capacity theorem determines the optimal triple trade-o between qubits,
ebits, and classical bits for simultaneous transmission of classical and quantum information using
an entanglement-assisted noisy quantum channelN [25]. The grandfather resource inequality is
as follows:
hNi +E [qq]Q [q!q] +R [c!c]: (1.5)
8
The above resource inequality is again an asymptotic statement and its meaning is similar to that in
(1.1), (1.2), and (1.3). The optimal rates in the above resource inequality coincide with the father
inequality (1.2) when R = 0, with the classical-quantum inequality (1.3) when E = 0, and with
the quantum capacity (1.1) when bothR = 0 andE = 0. The optimal strategy for the grandfather
protocol is not time-sharing the channel between father codes and entanglement-assisted classical
codes. It remains to be proven whether this optimal strategy outperforms time-sharing [25]. We
develop grandfather convolutional codes in Chapter 8. Again, future research might be able to
incorporate these grandfather convolutional codes into a framework for designing codes that come
close to achieving the maximal limits given in the grandfather capacity theorem.
1.2.2 Distillation Protocols
The aforementioned protocols employ a noisy quantum communication channel in their operation.
We now ask the question: given noisy entanglement, is it possible to produce noiseless entanglement
using classical communication? Indeed, it is possible, and this procedure is entanglement distilla-
tion [6, 7]. The following resource inequality summarizes the resources consumed and produced
in an entanglement distillation protocol:
AB
+R [c!c]Q [qq]:
The statement of the resource inequality is as follows: given a large number n of noisy bipartite
states
AB
shared between two parties, it is possible to generate nQ noiseless ebits by consuming
nR classical bits in the limit of a large number n of copies of the noisy state
AB
. The optimal
rates are R = I (A;E) and Q = I (AiB) where the entropic quantities are with respect to a
statej i
ABE
that puries the state
AB
. In Chapter 9, we develop convolutional entanglement
distillation protocols whose goal is to approach the optimal rates given in the above resource
inequality.
9
1.3 Organization of this Thesis
This thesis represents a signicant contribution to quantum error correction theory. In it, we
give several methods for designing quantum codes. These methods should be useful in the future
when coherent quantum encoding devices are available. The quantum code designer will have a
plethora of techniques to exploit for protecting quantum information and the techniques in this
thesis should be part of the arsenal.
A quick glance over the thesis reveals that much of the mathematics involves only linear algebra
over matrices of binary numbers or binary polynomials. It is a testament to the strength of the
theory that it reduces to this simple form. We show in detail especially in Chapters 2 and 4 how
to reduce the theory to have this simple form. This thesis has contributions from the following
publications [76, 77, 78, 79, 80, 82, 83].
We structure the thesis as follows. The next chapter introduces the stabilizer formalism for
quantum error correction. We show in this chapter how to represent quantum codes with bi-
nary matrices. Chapter 3 introduces the entanglement-assisted stabilizer formalism and shows
how to enhance the stabilizer formalism by assuming that the sender and receiver share entan-
glement. This chapter gives two contributions: a method for determining the encoding circuit for
a quantum block code and a method to determine the minimal amount of entanglement that an
entanglement-assisted code requires. Chapter 4 reviews the convolutional stabilizer formalism. In
particular, it details the operation of a quantum convolutional code and shows how to simplify
the mathematics with matrices whose entries are binary polynomials. Chapters 5, 6, and 7 form
the heart of this thesis. They show how to construct entanglement-assisted quantum codes that
have a convolutional structure. The techniques developed represent a signicant extension of the
entanglement-assisted stabilizer formalism. Chapter 8 presents a unifying structure for quantum
error correction under which most current schemes for quantum error correction fall. We present a
method for distilling entanglement in a convolutional manner in Chapter 9. The major benet of
all of the above convolutional methods is that we can import arbitrary high-performance classical
codes to construct high-performance quantum codes.
10
Chapter 2
Stabilizer Quantum Codes
\Fight entanglement with entanglement," you say,
'Cause entanglement keeps Eve away,
The hell that she raises,
She damps and dephases,
She's no match|like UCLA!
The stabilizer formalism is a mathematical framework for quantum error correction [32, 33]. This
framework has many similarities with classical coding theory, and it is even possible to import a
classical code for use in quantum error correction by employing the CSS construction [18, 74, 60].
We review the stabilizer theory for quantum block codes.
The stabilizer formalism is versatile because it appears not only in quantum error correction
but also in other subjects of quantum information theory such as stabilizer or graph states [42],
cluster-state quantum computation [66], and entanglement theory [27]. The stabilizer formalism
simplies the theory of quantum error correction by reducing the mathematics to linear algebra
over binary matrices.
11
2.1 Review of the Stabilizer Formalism
The stabilizer formalism exploits elements of the Pauli group . The set =fI;X;Y;Zg consists
of the Pauli operators:
I
2
4
1 0
0 1
3
5
; X
2
4
0 1
1 0
3
5
; Y
2
4
0 i
i 0
3
5
; Z
2
4
1 0
0 1
3
5
:
The above operators act on a single qubit|a vector in a two-dimensional Hilbert space|and
are the most important in formulating a quantum error-correcting code. Two crucial properties
of these matrices are useful: each matrix in has eigenvalues equal to +1 or1, and any two
matrices in either commute or anticommute.
In general, a quantum error-correcting code uses n physical qubits to protect a smaller set of
information qubits against decoherence or quantum noise. An n-qubit quantum error-correcting
code employs elements of the Pauli group
n
. The set
n
consists of n-fold tensor products of
Pauli operators:
n
=
e
i
A
1
A
n
:8j2f1;:::;ng; A
j
2 ; 2f0;=2;; 3=2g
: (2.1)
Matrices in
n
act on a 2
n
-dimensional complex vector, or equivalently, an n-qubit quantum
register. We omit tensor product symbols in what follows so that A
1
A
n
A
1
A
n
.
The above two crucial properties for the single-qubit Pauli group still hold for the Pauli group
n
(up to an irrelevant phase for the eigenvalue property). The n-fold Pauli group
n
plays
an important role in both the encoding circuit and the error-correction procedure of a quantum
stabilizer code over n qubits.
We can phrase the theory of quantum error correction in purely mathematical terms using
elements of
n
. Consider a matrix g
1
2
n
that is not equal toI. Matrix g
1
then has two
eigenspaces each of dimension 2
n1
. We can identify one eigenspace with the eigenvalue +1 and
the other eigenspace with eigenvalue1. Consider a matrix g
2
2
n
dierent from both g
1
and
the identity that commutes with g
1
. Matrix g
2
also has two eigenspaces each of size 2
n1
and
identied similarly by its eigenvalues1. Then g
1
and g
2
have simultaneous eigenspaces because
they commute. These matrices together have four dierent eigenspaces, each of size 2
n2
and
12
Figure 2.1: The operation of a stabilizer code. Thin lines denote quantum information and thick
lines denote classical information. Slanted bars denote multiple qubits. A sender encodes a multi-
qubit statej i with the help of some ancilla qubitsj0i. She sends the encoded state over a noisy
quantum channel. The receiver performs multi-qubit measurements to extract information about
the errors. He nally performs a recovery operation R to reverse the channel error.
identied by the eigenvalues1;1 of g
1
and g
2
respectively. We can continue this process of
adding more commuting and independent matrices to a setS. The matrices inS are independent
in the sense that no matrix inS is a product of two or more other matrices inS. Adding more
matrices from
n
toS continues to divide the eigenspaces of matrices inS. In general, supposeS
consists of nk independent and commuting matrices g
1
, . . . , g
nk
2
n
. These nk matrices
then have 2
nk
dierent eigenspaces each of size 2
k
and identied by the eigenvalues1, . . . ,
1 of g
1
, . . . , g
nk
respectively. Consider that the Hilbert space of k qubits has size 2
k
. A
dimension count immediately suggests that we can encode k qubits into one of the eigenspaces of
S. We typically encode these k qubits into the simultaneous +1-eigenspace of g
1
, . . . ,g
nk
. This
eigenspace is the codespace. The operatorsg
1
;:::;g
nk
function in the same way as a parity check
matrix does for a classical linear block code. An [n;k] quantum error-correcting code encodes k
information qubits into the simultaneous +1-eigenspace of nk matrices g
1
, . . . , g
nk
2
n
. Its
stabilizerS is an abelian subgroup of then-fold Pauli group
n
:S
n
. Note that it is possible
to multiply the generators in the stabilizer together and obtain an equivalent representation of
the stabilizer in much the same way that we can add vectors in a basis together and obtain an
equivalent basis.
13
The operation of an [n;k] quantum error-correcting code consists of four steps. Figure 2.1
highlights these steps.
(i). A unitary operation U encodes both k information qubits in a general statej i and nk
ancilla qubits in the statej0i
nk
into the simultaneous +1-eigenspace of the matrices g
1
,
. . . , g
nk
.
(ii). The sender transmits the n encoded qubits by using the noisy quantum communication
channel n times.
(iii). The receiver performs quantum measurements of the nk matrices g
1
, . . . , g
nk
in the
stabilizerS. These measurements learn only about errors that may occur and do not disturb
the encoded quantum information. Each measurement gives a bit result equal to +1 or1,
and the result of all the measurements is to project the n-qubit quantum register into one
of the 2
nk
dierent eigenspaces of g
1
, . . . , g
nk
. Suppose that no error occurs. Then
the measurements project the n qubits into the simultaneous +1-eigenspace and return a
bit vector consisting of nk ones. This \projection of the error concept" is one of the
fundamental notions in quantum error correction theory. It suces to correct a discrete
error set with support in the Pauli group
n
[70]. Now suppose that a quantum error in an
error setE
n
occurs. The error takes the encoded quantum state out of the codespace
and into one of the other 2
nk
1 orthogonal eigenspaces. The measurements can detect
that an error has occurred because the result of the measurements is a bit vector diering
from the all ones vector. The receiver can identify uniquely which error inE has occurred if
the setE satises the following quantum error correction conditions:
8E
a
;E
b
2E 9 g
i
2S :
g
i
;E
y
a
E
b
= 0 or E
y
a
E
b
2S: (2.2)
The rst condition corresponds to the active error-correcting capability of the code, and the
second condition corresponds to its passive error-correcting capability.
(iv). If the receiver can identify which error occurs, he can then apply a unitary operation R
that is the inverse of the error. He nally performs a decoding unitary that decodes the k
information qubits.
14
2.2 Cliord Encoding Unitary
We comment brie
y on the encoding operation U. The encoding operation U is a special type of
unitary matrix called a Cliord operation. A Cliord operation U is one that preserves elements
of the Pauli group under conjugation: A2
n
) UAU
y
2
n
. The CNOT gate, the Hadamard
gate H, and the phase gate P suce to implement any unitary matrix in the Cliord group [33].
A quantum code with the CSS structure needs only the CNOT and Hadamard gates for encoding
and decoding. The matrix for the CNOT gate acting on two qubits is
CNOT =
2
6
6
6
6
6
6
4
1 0 0 0
0 1 0 0
0 0 0 1
0 0 1 0
3
7
7
7
7
7
7
5
; (2.3)
the matrix for the Hadamard gate H acting on a single qubit is
H =
1
p
2
2
4
1 1
1 1
3
5
; (2.4)
and the matrix for the phase gate P acting on a single qubit is
P =
2
4
1 0
0 i
3
5
: (2.5)
The standard basis for
1
is X and Z because any element of
1
is a product of elements in
this generating set up to an irrelevant phase. The standard basis for elements of the two-qubit
Pauli group
2
is as follows
Z I
;
I Z
;
X I
;
I X
; (2.6)
for the same reasons.
15
The Hadamard gate H transforms the standard basis of
1
under conjugation as follows:
Z!X; X!Z (2.7)
and the phase gate P transforms the standard basis as follows:
Z!Z; X!Y: (2.8)
For the CNOT gate, the rst qubit is the \control" qubit and the second qubit is the \target"
qubit. The CNOT gate transforms the standard basis of
2
under conjugation as follows
Z I
!
Z I
;
I Z
!
Z Z
;
X I
!
X X
;
I X
!
I X
; (2.9)
where the rst qubit is the control and the second qubit is the target.
Section 3.5 of Chapter 3 details an algorithm that determines a Cliord encoding circuit for
any stabilizer code or any entanglement-assisted stabilizer code (we review entanglement-assisted
codes in the next chapter).
2.3 The Logical Operators and the Information Qubits
Another aspect of the theory of quantum error correction is later useful for our purposes in
quantum convolutional coding. This aspect concerns the information qubits and the operators
that change them. Consider that the initial unencoded state of a quantum error-correcting code
is a simultaneous +1-eigenstate of the matrices Z
k+1
;:::;Z
n
where Z
i
has a Z matrix operating
on qubit i and the identity I on all other qubits. Therefore, the matrices Z
k+1
;:::;Z
n
constitute
a stabilizer for the unencoded state. The initial unencoded logical operators for the k information
qubits areZ
1
;X
1
;:::;Z
k
;X
k
. The encoding operationU rotates the unencoded stabilizer matrices
Z
k+1
;:::;Z
n
and the unencoded logical operators Z
1
;X
1
;:::;Z
k
;X
k
to the encoded stabilizer
operators
Z
k+1
, . . . ,
Z
n
and the encoded logical operators
Z
1
;
X
1
;:::;
Z
k
;
X
k
respectively. The
encoded matrices
Z
k+1
;:::;
Z
n
are respectively equivalent to the matrices g
1
, . . . , g
nk
in the
discussion of the previous section.
16
The encoded operators obey the same commutation relations as their unencoded counterparts.
We would violate the uncertainty principle if this invariance did not hold. Therefore, each of the
encoded logical operators commutes with elements of the stabilizerS. Let A denote an arbitrary
logical operator from the above set and let
Z
i
denote an arbitrary element of the stabilizerS. The
operatorA
Z
i
(or equivalently
Z
i
A) is an equivalent logical operator because A
Z
i
andA have the
same eect on an encoded state
:
Z
i
A
=A
Z
i
=A
: (2.10)
We make extensive use of the above fact in our work.
The logical operators also provide a useful way to characterize the information qubits. Gottes-
man showed that the logical operators for the information qubits provide a straightforward way
to characterize the information qubits as they progress through a quantum circuit [33]. As an
example of this technique, he develops quantum teleportation in the stabilizer formalism. The
logical operators at the beginning of the protocol areX
1
andZ
1
and becomeX
3
andZ
3
at the end
of the protocol. This transformation implies that the quantum information in qubit one teleports
to qubit three because the logical operators act on only qubit three at the end of the protocol. We
use the same idea throughout this thesis to determine if our decoding circuits have truly decoded
the information qubits.
2.4 The Pauli-to-Binary Isomorphism
A simple but useful mapping exists between elements of and the binary vector space (Z
2
)
2
. This
mapping gives a simplication of quantum error correction theory. It represents quantum codes
with binary vectors and binary operations rather than with Pauli operators and matrix operations
respectively. We rst give the mapping for the one-qubit case. Suppose [A] is a set of equivalence
classes of an operator A that have the same phase:
[A] =fAj 2C; jj = 1g: (2.11)
17
Let [] be the set of phase-free Pauli operators where [] = f[A] j A2 g. Dene the map
N : (Z
2
)
2
! as
I X Y Z
(Z
2
)
2
00 01 11 10
: (2.12)
Suppose u;v2 (Z
2
)
2
. Let us employ the shorthand u = [zjx] and v = [z
0
jx
0
] where z, x, z
0
,
x
0
2Z
2
. For example, suppose u = [0j1]. Then N (u) =X. The map N induces an isomorphism
[N] : (Z
2
)
2
! [] because addition of vectors in (Z
2
)
2
is equivalent to multiplication of Paulis up
to a global phase:
[N (u +v)] = [N (u)] [N (v)]: (2.13)
We name this isomorphism the P2B isomorphism (for Pauli-to-binary isomorphism).
Let denote the symplectic product between two elements u;v2 (Z
2
)
2
:
uvzx
0
xz
0
: (2.14)
The symplectic product gives the commutation relations of elements of :
N (u)N (v) = (1)
(uv)
N (v)N (u):
The symplectic product and the P2B isomorphism [N] thus give a useful way to phrase Pauli
relations in terms of binary algebra.
The extension of the above denitions and the P2B isomorphism [N] to multiple qubits is
straightforward. Let A = A
1
A
n
denote an arbitrary element of
n
. We can similarly
dene the phase-free n-qubit Pauli group [
n
] =f[A] j A2
n
g where
[A] =fAj 2C; jj = 1g: (2.15)
The group operation for the above equivalence class is as follows:
[A] [B] [A
1
] [B
1
]
[A
n
] [B
n
] = [A
1
B
1
]
[A
n
B
n
] = [AB]: (2.16)
18
The equivalence class [
n
] forms a commutative group under operation . Consider the 2n-
dimensional vector space
(Z
2
)
2n
=f(z; x) : z; x2 (Z
2
)
n
g: (2.17)
It forms the commutative group ((Z
2
)
2n
; +) with operation + dened as binary vector addition.
We employ the notation u = [zjx] and v = [z
0
jx
0
] to represent any two vectors u; v2 (Z
2
)
2n
respectively. Each vector z and x has elements (z
1
;:::;z
n
) and (x
1
;:::;x
n
) respectively with
similar representations for z
0
and x
0
. The symplectic product of u and v is
u v
n
X
i=1
z
i
x
0
i
x
i
z
0
i
=
n
X
i=1
u
i
v
i
; (2.18)
where u
i
= [z
i
jx
i
] and v
i
= [z
0
i
jx
0
i
]. Let us dene a map N : (Z
2
)
2n
!
n
as follows:
N (u)N (u
1
)
N (u
n
): (2.19)
Let
X (x)X
x1
X
xn
; Z (z)Z
z1
Z
zn
; (2.20)
so that N (u) and Z (z) X (x) belong to the same equivalence class:
[N (u)] = [Z (z) X (x)]: (2.21)
The map [N] : (Z
2
)
2n
! [
n
] is an isomorphism for the same reason given in (2.13):
[N (u + v)] = [N (u)] [N (v)]; (2.22)
where u; v2 (Z
2
)
2n
. The symplectic product captures the commutation relations of any operators
N (u) and N (v):
N (u) N (v) = (1)
(uv)
N (v) N (u): (2.23)
The above P2B isomorphism and symplectic algebra are useful in making the relation between
classical linear error correction and quantum error correction more explicit.
19
2.5 Example
An example of a stabilizer code is the ve qubit [5; 1] stabilizer code [51, 7]. It encodes k = 1
logical qubit into n = 5 physical qubits and protects against an arbitrary single-qubit error. Its
stabilizer consists of nk = 4 Pauli operators:
g
1
= X Z Z X I
g
2
= I X Z Z X
g
3
= X I X Z Z
g
4
= Z X I X Z
(2.24)
The above operators commute. Therefore the codespace is the simultaneous +1-eigenspace of the
above operators. Suppose a single-qubit error occurs on the encoded quantum register. A single-
qubit error is in the setfX
i
;Y
i
;Z
i
g whereA
i
denotes a Pauli error on qubiti. It is straightforward
to verify that any arbitrary single-qubit error has a unique syndrome. The receiver corrects any
single-qubit error by identifying the syndrome and applying a corrective operation.
2.6 Closing Remarks
The mathematics developed in this chapter form the basis for the work in later chapters. In
particular, the binary representation of quantum codes is important. The role of the \twisted"
symplectic product plays an important role for the entanglement-assisted codes of the next chap-
ter because it helps in determining the commutation relations of an arbitrary (not necessarily
commuting) set of Pauli generators.
20
Chapter 3
Entanglement-Assisted Stabilizer Quantum Codes
Classical to quantum made dinero,
But the twisted strange product was zero,
Little did we know,
What Entanglement could show,
And again become quantum's good hero.
The entanglement-assisted stabilizer formalism is a signicant extension of the standard stabilizer
formalism that incorporates shared entanglement as a resource for protecting quantum information
[13, 14]. The advantage of entanglement-assisted stabilizer codes is that the sender can exploit
the error-correcting properties of an arbitrary set of Pauli operators. The sender's Pauli operators
do not necessarily have to form an abelian subgroup of
n
. The sender can make clever use of her
shared ebits so that the global stabilizer is abelian and thus forms a valid quantum error-correcting
code. Figure 3.1 demonstrates the operation of a generic entanglement-assisted stabilizer code.
Several references provide a review of this technique and generalizations of the basic theory
to block entanglement distillation [56], continuous-variable codes [83], and entanglement-assisted
operator codes for discrete-variable [15, 44] and continuous-variable systems [78]. Chapters 5, 6,
7, 8, and 9 of this thesis extend the entanglement-assisted stabilizer formalism to many dierent
\convolutional" coding scenarios. We explain what we mean by \convolutional" in the next
chapter.
21
For now, we provide a review of the basics of entanglement-assisted coding. This chapter also
gives two original contributions: a method to determine the encoding and decoding circuit for
an entanglement-assisted code and several formulas that determine the number of ebits that an
arbitrary entanglement-assisted block code requires.
3.1 Review of the Entanglement-Assisted Stabilizer For-
malism
The fundamental unit of bipartite entanglement is the ebit. We must rst understand the commu-
tativity properties of the ebit before developing the entanglement-assisted formalism. We express
the statej
+
i of an ebit shared between a sender Alice and a receiver Bob as follows:
+
j00i
AB
+j11i
AB
p
2
: (3.1)
The two operators that stabilize this ebit state are X
A
X
B
and Z
A
Z
B
. These two operators
commute,
X
A
X
B
;Z
A
Z
B
= 0;
but the local operators (operating only on either party) anticommute,
X
A
;Z
A
=
X
B
;Z
B
= 0:
The above commutation relations hint at a way that we can resolve anticommutativity in a
set of generators. Suppose that we have two generators that anticommute. We can use an ebit
of entanglement to resolve the anticommutativity in the two generators. We explain this idea in
more detail in what follows.
We review the general construction of an entanglement-assisted code. An [n;k;c] entanglement-
assisted code employs c ebits and a ancilla qubits to encode k information qubits. Suppose that
there is a nonabelian subgroupS
n
of size 2c +a. Application of the fundamental theorem of
22
symplectic geometry
[22] (Lemma 1 in [14]) states that there exists a minimal set of independent
generators
Z
1
;:::;
Z
a+c
;
X
a+1
;:::;
X
a+c
forS with the following commutation relations:
8i;j
Z
i
;
Z
j
= 0; 8i;j
X
i
;
X
j
= 0; (3.2)
8i6=j
X
i
;
Z
j
= 0; 8i
X
i
;
Z
i
= 0:
The decomposition ofS into the above minimal generating set determines that the code requires
a ancilla qubits and c ebits. The parameters a and c generally depend on the set of generators in
S.
There exists a symplectic Gram-Schmidt orthogonalization procedure that gives the decompo-
sition [13, 14, 82, 68]. Specically, the algorithm performs row operations (multiplication of the
Pauli generators) that do not aect the code's error-correcting properties and thus gives a set of
generators that form an equivalent code. The decomposition also minimizes the number of ebits
required for the code and we prove this optimality in Section 3.6.
We present a simple stabilizer version of the symplectic Gram-Schmidt algorithm. Suppose we
have a set of m generators g
1
, . . . , g
m
. Consider g
1
. It either commutes with all other generators
or it anticommutes with at least one other generator. Remove it from the set if it commutes with
all other generators. Now suppose that it does not, i.e., it anticommutes with one other generator
g
i
. Relabel g
2
as g
i
and vice versa. Recall that we can multiply generators without changing
the error-correcting properties of the set of generators. So we perform several multiplications
to change the commutation relations to have the standard commutation relations in (3.2). We
perform the following manipulations on the generators g
3
, . . . , g
m
:
g
j
=g
j
g
f(g2;gj)
1
g
f(g1;gj)
2
8 i2f3;:::;mg
where the function f is equal to zero if its two arguments commute and it is equal to one if its
two arguments anticommute. (This function is the symplectic product.) Remove the generators
g
1
and g
2
from the set. Repeat the algorithm on the remaining generators. When the algorithm
We loosely refer to this theorem as the fundamental theorem of symplectic geometry because of its importance
in symplectic geometry and in quantum coding theory.
23
Figure 3.1: The operation of an entanglement-assisted quantum error-correcting code. The sender
encodes quantum information in statej i with the help of local ancilla qubitsj0i and her half of
a set of shared ebitsj
+
i. She then sends her qubits over a noisy quantum channel. The channel
does not corrupt the receiver's half of the set of shared ebits. The receiver performs multi-qubit
measurements on all of the qubits to diagnose the channel error. He performs a recovery unitary
R to reverse the estimated channel error.
nishes, all the \removed' generators constitute the generators for the code and have the standard
commutation relations in (3.2).
We can partition the nonabelian group S into two subgroups: the isotropic subgroup S
I
and the entanglement subgroupS
E
. The isotropic subgroupS
I
is a commuting subgroup of
S and thus corresponds to ancilla qubits: S
I
=
Z
1
;:::;
Z
a
. The elements of the entan-
glement subgroup S
E
come in anticommuting pairs and thus correspond to halves of ebits:
S
E
=
Z
a+1
;:::;
Z
a+c
;
X
a+1
;:::;
X
a+c
. The two subgroupsS
I
andS
E
play a role in the error-
correcting conditions for the entanglement-assisted stabilizer formalism. An entanglement-assisted
code corrects errors in a setE
n
if
8E
1
;E
2
2E E
y
1
E
2
2S
I
or E
y
1
E
2
2
n
Z (hS
I
;S
E
i):
The conditions correspond to error pairsE
1
;E
2
in an error setE. The rst condition corresponds
to the passive error-correcting capability of the code, and the second condition corresponds to its
active error-correcting capability.
24
Figure 3.1 illustrates the operation of an entanglement-assisted stabilizer code. The following
four steps explain the operation of an [n;k;c] entanglement-assisted quantum code:
(i). The sender and receiver sharec ebits before quantum communication begins and the sender
has a ancilla qubits. The unencoded state is a simultaneous +1-eigenstate of the following
operators:
fZ
a+1
jZ
1
;:::;Z
a+c
jZ
c
;X
a+1
jX
1
;:::;X
a+c
jX
c
;Z
1
;:::;Z
a
g: (3.3)
The operators to the right of the vertical bars indicate the receiver's half of the shared ebits.
The sender encodes her k information qubits with the help of a ancilla qubits and her half
of the c ebits. The encoding operation is U in Figure 3.1. The encoding unitary transforms
the unencoded operators to the following encoded operators:
Z
a+1
jZ
1
;:::;
Z
a+c
jZ
c
;
X
a+1
jX
1
;:::;
X
a+c
jX
c
;
Z
1
;:::;
Z
a
: (3.4)
(ii). The sender sends her n qubits over a noisy quantum communication channel. The noisy
channel aects these n qubits only and does not aect the receiver's half of the c ebits.
(iii). The receiver combines his half of the c ebits with those he receives from the noisy quantum
channel. He performs measurements on alln +c qubits to diagnose an error that may occur
on the n qubits.
(iv). After estimating which error occurs, the receiver performs a recovery operation that reverses
the estimated error.
3.2 The Symplectic Product Matrix
Let us write the local operators X
A
and Z
A
on the sender Alice's side as respective symplectic
vectors h
1
and h
2
:
h
1
=
h
0
1
i
; h
2
=
h
1
0
i
:
25
The \symplectic product matrix"
of these two symplectic vectors is as follows:
=
2
4
0 1
1 0
3
5
: (3.5)
We call this matrix the symplectic product matrix because its entries enumerate the symplectic
products:
[
]
ij
=h
i
h
j
8i;j2f1; 2g: (3.6)
The symplectic product matrix in (3.5) is so special for the purposes of this thesis that we give it
the nameJ
. It means that two generators have commutation relations that are equivalent to
half of an ebit.
A general set of generators for a quantum block code can have complicated commutation
relations. For a given set of generators, the commutation relations for the generators resulting from
the symplectic Gram-Schmidt orthogonalization procedure have a special form. Their symplectic
product matrix
has the standard form:
=
c
M
i=1
J
a
M
j=1
[0] (3.7)
where the large and small correspond to the direct sum operation and [0] is the one-element null
matrix. The standard form above implies that the commutation relations of the 2c +a generators
are equivalent to those of c halves of ebits and a ancilla qubits|the commutation relations are
equivalent to those in (3.2).
3.3 The Rate of an Entanglement-Assisted Quantum Code
We can interpret the rate of an entanglement-assisted code in three dierent ways [14, 13, 82].
Suppose that an entanglement-assisted quantum code encodesk information qubits inton physical
qubits with the help of c ebits.
(i). The \entanglement-assisted" rate assumes that entanglement shared between sender and
receiver is free. Bennett et al. make this assumption when deriving the entanglement-assisted
26
capacity of a quantum channel for sending quantum information [8, 9]. The entanglement-
assisted rate is k=n for a code with the above parameters.
(ii). The \trade-o' rate assumes that entanglement is not free and a rate pair determines perfor-
mance. The rst number in the pair is the number of noiseless qubits generated per channel
use, and the second number in the pair is the number of ebits consumed per channel use. The
rate pair is (k=n;c=n) for a code with the above parameters. Quantum information theorists
have computed asymptotic trade-o curves that bound the rate region in which achievable
rate pairs lie [24]. Brun et al.'s construction for an entanglement-assisted quantum block
code minimizes the numberc of ebits given a xed numberk andn of respective information
qubits and physical qubits [13, 14].
(iii). The \catalytic rate" assumes that bits of entanglement are built up at the expense of trans-
mitted qubits [13, 14]. A noiseless quantum channel or the encoded use of noisy quantum
channel are two dierent ways to build up entanglement between a sender and receiver. The
catalytic rate of an [n;k;c] code is (kc)=n.
Which interpretation is most reasonable depends on the context in which we use the code. In
any case, the parametersn,k, andc ultimately govern performance, regardless of which denition
of the rate we use to interpret that performance.
3.4 Example of an Entanglement-Assisted Code
We present an example of an entanglement-assisted code that corrects an arbitrary single-qubit
error [14]. This example highlights the main features of the theory given above. Suppose the
sender wants to use the quantum error-correcting properties of the following nonabelian subgroup
of
4
:
Z X Z I
Z Z I Z
X Y X I
X X I X
(3.8)
27
The rst two generators anticommute. We obtain a modied third generator by multiplying the
third generator by the second. We then multiply the last generator by the rst, second, and
modied third generators. The error-correcting properties of the generators are invariant under
these operations. The modied generators are as follows:
g
1
= Z X Z I
g
2
= Z Z I Z
g
3
= Y X X Z
g
4
= Z Y Y X
(3.9)
The above set of generators have the commutation relations given by the fundamental theorem of
symplectic geometry:
fg
1
;g
2
g = [g
1
;g
3
] = [g
1
;g
4
] = [g
2
;g
3
] = [g
2
;g
4
] = [g
3
;g
4
] = 0:
The above set of generators is unitarily equivalent to the following canonical generators:
X I I I
Z I I I
I Z I I
I I Z I
(3.10)
We can add one ebit to resolve the anticommutativity of the rst two generators:
X I I I
Z I I I
I Z I I
I I Z I
X
Z
I
I
(3.11)
A +1-eigenstate of the above stabilizer is the following state
+
AB
j00i
A
j i
A
; (3.12)
28
wherej i
A
is a qubit that the sender wants to encode. A local encoding unitary then rotates the
generators in (3.11) to the following set of globally commuting generators:
Z X Z I
Z Z I Z
Y X X Z
Z Y Y X
X
Z
I
I
(3.13)
The receiver measures the above generators upon receipt of all qubits to detect and correct errors.
3.5 Encoding Algorithm
Suppose we have an arbitrary set of Pauli matrices in
n
whose error-correcting properties we
would like to exploit. The algorithm in this section (in Ref. [82]) determines the encoding and
decoding circuit for the set of Pauli generators.
It has two additional benets. We do not necessarily know beforehand how many ebits we
require for the Pauli matrices to form a commuting set. Several methods exist such as the Gram-
Schmidt algorithm outlined in Section 3.1 and the others in Refs. [13, 14, 15, 44, 82], but the
algorithm here also determines the optimal number of ebits and the measurements the receiver
performs to diagnose errors. It \kills three birds with one stone."
We continue with the example in Section 3.4. We detail an algorithm for determining an
encoding circuit and the optimal number of ebits for the entanglement-assisted code. The operators
in (3.8) have the following representation as a binary matrix according to the P2B isomorphism:
H =
2
6
6
6
6
6
6
4
1 0 1 0
1 1 0 1
0 1 0 0
0 0 0 0
0 1 0 0
0 0 0 0
1 1 1 0
1 1 0 1
3
7
7
7
7
7
7
5
: (3.14)
Call the matrix to the left of the vertical bar the \Z" matrix and the matrix to the right of the
vertical bar the \X" matrix.
29
The algorithm consists of row and column operations on the above matrix. Row operations
do not aect the error-correcting properties of the code but are crucial for arriving at the optimal
decomposition from the fundamental theorem of symplectic geometry. The operations available
for manipulating columns of the above matrix are Cliord operations (discussed at the end of
Section 2.2). The operations have the following eect on entries in the binary matrix:
(i). A CNOT gate from qubit i to qubitj adds columni to columnj in theX matrix and adds
column j to column i in the Z matrix.
(ii). A Hadamard gate on qubiti swaps columni in theZ matrix with columni in theX matrix
and vice versa.
(iii). A phase gate on qubit i adds column i in the X matrix to column i in the Z matrix.
(iv). Three CNOT gates implement a qubit swap operation [60]. The eect of a swap on qubits
i and j is to swap columns i and j in both the X and Z matrix.
The algorithm begins by computing the symplectic product between the rst row and all other
rows. Leave the matrix as it is if the rst row is not symplectically orthogonal to the second row
or if the rst row is symplectically orthogonal to all other rows. Otherwise, swap the second row
with the rst available row that is not symplectically orthogonal to the rst row. In our example,
the rst row is not symplectically orthogonal to the second so we leave all rows as they are.
Arrange the rst row so that the top left entry in the X matrix is one. A CNOT, swap,
Hadamard, or combinations of these operations can achieve this result. We can have this result
in our example by swapping qubits one and two. The matrix becomes
2
6
6
6
6
6
6
4
0 1 1 0
1 1 0 1
1 0 0 0
0 0 0 0
1 0 0 0
0 0 0 0
1 1 1 0
1 1 0 1
3
7
7
7
7
7
7
5
: (3.15)
Perform CNOTs to clear the entries in theX matrix in the top row to the right of the leftmost
entry. These entries are already zero in this example so we need not do anything. Proceed to the
clear the entries in the rst row of theZ matrix. Perform a phase gate to clear the leftmost entry
30
in the rst row of the Z matrix if it is equal to one. It is equal to zero in our example so we need
not do anything. We then use Hadamards and CNOTs to clear the other entries in the rst row
of the Z matrix.
For our example, perform a Hadamard on qubits two and three. The matrix becomes
2
6
6
6
6
6
6
4
0 0 0 0
1 0 0 1
1 1 1 0
0 1 0 0
1 1 1 0
0 1 0 0
1 0 0 0
1 0 0 1
3
7
7
7
7
7
7
5
: (3.16)
Perform a CNOT from qubit one to qubit two and from qubit one to qubit three. The matrix
becomes
2
6
6
6
6
6
6
4
0 0 0 0
1 0 0 1
1 1 1 0
1 1 0 0
1 0 0 0
0 1 0 0
1 1 1 0
1 1 1 1
3
7
7
7
7
7
7
5
: (3.17)
The rst row is complete. We now proceed to clear the entries in the second row. Perform a
Hadamard on qubits one and four. The matrix becomes
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
1 1 1 0
1 1 0 1
0 0 0 0
1 1 0 1
1 1 1 0
1 1 1 0
3
7
7
7
7
7
7
5
: (3.18)
Perform a CNOT from qubit one to qubit two and from qubit one to qubit four. The matrix
becomes
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 1 1 0
1 1 0 1
0 0 0 0
1 0 0 0
1 0 1 1
1 0 1 1
3
7
7
7
7
7
7
5
: (3.19)
The rst two rows are now complete. They need one ebit to compensate for their anticommuta-
tivity or their nonorthogonality with respect to the symplectic product.
31
8
<
:
j
+
i
BA
H
j0i
A
H P H
H
j0i
A
H
H
H
j i
A
H
H
Figure 3.2: Encoding circuit for the entanglement-assisted code in the example of Section 3.4.
The \H" gate is a Hadamard gate and the \P" gate is a phase gate.
Now we perform row operations that are similar to the \symplectic Gram-Schmidt orthogo-
nalization." Add row one to any other row that has one as the leftmost entry in itsZ matrix. Add
row two to any other row that has one as the leftmost entry in its X matrix. For our example, we
add row one to row four and we add row two to rows three and four. The matrix becomes
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 1 1 0
0 1 0 1
0 0 0 0
1 0 0 0
0 0 1 1
0 0 1 1
3
7
7
7
7
7
7
5
: (3.20)
The rst two rows are now symplectically orthogonal to all other rows per the fundamental theorem
of symplectic geometry.
We proceed with the same algorithm on the next two rows. We can deal with the next two
rows individually because they are symplectically orthogonal to each other. Perform a Hadamard
on qubit two. The matrix becomes
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 0 1 0
0 0 0 1
0 0 0 0
1 0 0 0
0 1 1 1
0 1 1 1
3
7
7
7
7
7
7
5
: (3.21)
32
Perform a CNOT from qubit two to qubit three and from qubit two to qubit four. The matrix
becomes
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 1 1 0
0 1 0 1
0 0 0 0
1 0 0 0
0 1 0 0
0 1 0 0
3
7
7
7
7
7
7
5
: (3.22)
Perform a phase gate on qubit two:
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 0 1 0
0 0 0 1
0 0 0 0
1 0 0 0
0 1 0 0
0 1 0 0
3
7
7
7
7
7
7
5
: (3.23)
Perform a Hadamard on qubit three followed by a CNOT from qubit two to qubit three:
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 0 0 0
0 0 0 1
0 0 0 0
1 0 0 0
0 1 0 0
0 1 1 0
3
7
7
7
7
7
7
5
: (3.24)
Add row three to row four and perform a Hadamard on qubit two:
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 1 0 0
0 0 0 1
0 0 0 0
1 0 0 0
0 0 0 0
0 0 1 0
3
7
7
7
7
7
7
5
: (3.25)
33
Perform a Hadamard on qubit four followed by a CNOT from qubit three to qubit four. End by
performing a Hadamard on qubit three:
2
6
6
6
6
6
6
4
1 0 0 0
0 0 0 0
0 1 0 0
0 0 1 0
0 0 0 0
1 0 0 0
0 0 0 0
0 0 0 0
3
7
7
7
7
7
7
5
: (3.26)
The above matrix now corresponds to the canonical Paulis in (3.10). Adding one half of an ebit
to the receiver's side gives the canonical stabilizer in (3.11) whose simultaneous +1-eigenstate is
the state in (3.12).
Figure 3.2 gives the encoding circuit corresponding to the above operations. The above oper-
ations in reverse order take the canonical stabilizer (3.11) to the encoded stabilizer (3.13).
3.6 Optimal Entanglement Formulas
Entanglement is a valuable resource, and we would like to minimize the amount that a sender and
receiver need to consume for entanglement-assisted quantum coding. Hsieh, Devetak, and Brun
rst addressed this issue by determining a useful formula that gives the optimal number of ebits
required by a Calderbank-Shor-Steane (CSS) entanglement-assisted code [44]. In particular, the
number c of ebits that a CSS entanglement-assisted code requires is
c = rank
HH
T
; (3.27)
where H corresponds to the parity check matrix of a classical binary block code that we import
to correct quantum bit and phase
ips. The same authors also determined an upper bound for
the number of ebits that an entanglement-assisted quantum LDPC code requires [45].
In this section, we present several generalizations of the above formula. Our rst theorem
gives a formula for the optimal number of ebits that an arbitrary (non-CSS) entanglement-assisted
quantum block code requires. We nd special cases of this formula that apply to an entanglement-
assisted quantum block code produced from two arbitrary classical binary block codes, and to
34
codes from a classical block code over GF (4). Our last formula applies to continuous-variable
entanglement-assisted codes [83].
Theorem 3.6.1. Suppose we want to build an entanglement-assisted quantum code from genera-
tors corresponding to the rows in a quantum check matrix
H =
h
H
Z
H
X
i
; (3.28)
whereH is an (nk)2n-dimensional binary matrix representing the quantum code, and bothH
Z
and H
X
are (nk)n-dimensional binary matrices. Then the resulting code is an [[n;k +c;c]]
entanglement-assisted code and requires c ebits, where
c = rank
H
X
H
T
Z
+H
Z
H
T
X
=2; (3.29)
and addition is binary.
Proof. Consider the symplectic product matrix
H
=H
X
H
T
Z
+H
Z
H
T
X
. Its entries are the sym-
plectic products between all rows of H so that
[
H
]
ij
=h
i
h
j
; (3.30)
where h
i
is the i
th
row of H. The matrix
H
is a (nk) (nk)-dimensional binary matrix.
Refs. [13, 14] and the algorithm in Section 3.1 outline a symplectic Gram-Schmidt orthogonal-
ization procedure (SGSOP) that uniquely determines the optimal (i.e., minimal) number of ebits
that the code requires, and Ref. [31] proves that the SGSOP gives the optimal number of ebits.
The code construction in Refs. [13, 14] shows that the resulting entanglement-assisted quantum
code requires at most c ebits. The essence of the argument in Ref. [31] is that the resulting
entanglement-assisted quantum code requires at least c ebits because any fewer ebits would not
be able to resolve the anticommutativity of the generators on Alice's side of the code.
The SGSOP performs row operations that do not change the error-correcting properties of the
quantum code (because the code is additive), but these row operations do change the symplectic
product relations. These row operations are either a row swap S (i;j), whereS (i;j) is a full-rank
(nk) (nk) matrix that swaps row i with j, or a row addition A (i;j), where A (i;j) is a
35
full-rank (nk) (nk) matrix that adds row i to row j. These row operations multiply the
matrix H from the left. The SGSOP then is equivalent to a full-rank (nk) (nk) matrix
G that contains all of the row operations and produces a new quantum check matrix H
0
= GH
with corresponding symplectic product matrix
H
0 =G
H
X
H
T
Z
+H
Z
H
T
X
G
T
. In particular, the
resulting symplectic product matrix
H
0 is in the standard form in (3.7) so that
H
0 =
c
M
i=1
J
nk2c
M
j=1
[0]: (3.31)
Each matrix J in the direct sum corresponds to half of an ebit as described in Section 3.2 and
has rank two. Each matrix [0] has rank zero and corresponds to an ancilla qubit. The optimal
number of ebits required for the code is rank (
H
0)=2:
rank (
H
0) = rank
0
@
c
M
i=1
J
nk2c
M
j=1
[0]
1
A
=
c
X
i=1
rank (J) +
nk2c
X
j=1
rank ([0]) = 2c: (3.32)
The second equality follows because the rank of a direct sum is the sum of the individual matrix
ranks, and the third equality follows from the individual matrix ranks given above. The number c
of ebits is also equal to rank (
H
)=2 because the matrixG is full rank. The code is an [[n;k +c;c]]
entanglement-assisted quantum block code by the construction in Refs. [13, 14].
Our formula (3.29) is equivalent to the formula at the top of page 14 in Ref. [13], but it provides
the quantum code designer with a quick method to determine how many ebits an entanglement-
assisted code requires, by simply \plugging in" the generators of the code.
The formula (3.29), like the CSS formula in (3.27), is a measure of how far a set of generators
is from being a commuting set, or equivalently, how far it is from giving a standard stabilizer code.
Corollary 3.6.1 below gives a formula for the optimal number of ebits required by a CSS
entanglement-assisted quantum code. It is generally a bit less dicult to compute than the above
formula in (3.29). This reduction in complexity occurs because of the special form of a CSS
quantum code and because the size of the matrices involved are generally smaller for a CSS code
than for a general code with the same number of generators and physical qubits.
36
Corollary 3.6.1. Suppose we import two classical [n;k
1
;d
1
] and [n;k
2
;d
2
] binary codes with
respective parity check matrices H
1
and H
2
to build an entanglement-assisted quantum code. The
resulting code is an [[n;k
1
+k
2
n +c; min (d
1
;d
2
) ;c]] entanglement-assisted code, and requires c
ebits where
c = rank
H
1
H
T
2
: (3.33)
Proof. The quantum check matrix has the following form:
H =
2
4
H
1
0
0
H
2
3
5
: (3.34)
The symplectic product matrix
H
is then
H
=
2
4
H
1
0
3
5
h
0 H
T
2
i
+
2
4
0
H
2
3
5
h
H
T
1
0
i
=
2
4
0 H
1
H
T
2
H
2
H
T
1
0
3
5
: (3.35)
The above matrix is equivalent by a full rank permutation matrix to the matrix H
1
H
T
2
H
2
H
T
1
,
so the rank of
H
is
rank (
H
) = rank
H
1
H
T
2
H
2
H
T
1
= rank
H
1
H
T
2
+ rank
H
2
H
T
1
= 2 rank
H
1
H
T
2
(3.36)
The second equality follows because the rank of a direct sum is equivalent to the sum of the
individual ranks, and the third equality follows because the rank is invariant under matrix trans-
position. The number of ebits required for the resulting entanglement-assisted quantum code is
rank
H
1
H
T
2
, using the result of the previous theorem. The construction in Refs. [13, 14] produces
an [[n;k
1
+k
2
n +c; min (d
1
;d
2
) ;c]] entanglement-assisted quantum block code.
Corollary 3.6.2. Suppose we import an [n;k;d]
4
classical code over GF (4) with parity check
matrix H for use as an entanglement-assisted quantum code according to the construction in
Refs. [13, 14]. Then the resulting quantum code is an [[n; 2kn +c;c]] entanglement-assisted
quantum code where c = rank
HH
y
andy denotes the conjugate transpose operation over ma-
trices in GF (4).
37
Proof. Ref. [14] shows how to produce an entanglement-assisted quantum code from the parity
check matrix H of a classical code over GF (4). The resulting quantum parity check matrix H
Q
in symplectic binary form is
H
Q
=
0
@
2
4
!H
!H
3
5
1
A
; (3.37)
where
denotes the isomorphism between elements of GF (4) and symplectic binary vectors that
represent Pauli matrices. We augment the table in (2.12) to include the entries from GF (4):
I X Y Z
(Z
2
)
2
00 01 11 10
GF (4) 0 ! 1 !
(3.38)
The isomorphism
is the mapping from the third row to the second row in the above table.
The symplectic product between binary vectors is equivalent to the trace product of their GF (4)
representations (see, e.g., Ref. [14]):
h
i
h
j
= tr
n
1
(h
i
)
1
(h
j
)
o
; (3.39)
where h
i
and h
j
are any two rows of H
Q
, denotes the inner product, the overbar denotes the
conjugate operation, and trfxg =x + x denotes the trace operation over elements of GF (4). We
exploit these correspondences to write the symplectic product matrix
H
Q
for the quantum check
matrix H
Q
as follows:
H
Q
= tr
8
>
<
>
:
2
4
!H
!H
3
5
2
4
!H
!H
3
5
y
9
>
=
>
;
= tr
8
<
:
2
4
!H
!H
3
5
h
!H
y
!H
y
i
9
=
;
(3.40)
= tr
8
<
:
2
4
HH
y
!HH
y
!HH
y
HH
y
3
5
9
=
;
= tr
8
<
:
2
4
1 !
! 1
3
5
HH
y
9
=
;
(3.41)
=
2
4
1 !
! 1
3
5
HH
y
+
2
4
1 !
! 1
3
5
HH
T
(3.42)
38
where the \tr" operation above is an element-wise trace operation overGF (4) (it is not the matrix
trace operation.) The matrix
H
Q
is over the eld GF (2), but we can consider it as being over
the eld GF (4) without changing its rank. Therefore, we can multiply it by matrices over the
eld GF (4). Consider the following full-rank GF (4) matrices:
A
1
=
2
4
1 !
0 1
3
5
I; A
2
=
2
4
1 0
1 1
3
5
I: (3.43)
We premultiply and postmultiply the matrix
H
Q
as follows and obtain a matrix with the same
rank as
H
Q
:
A
2
A
1
H
Q
A
y
1
A
y
2
=
2
4
0 0
0 1
3
5
HH
y
+
2
4
1 0
0 0
3
5
HH
T
=
2
4
HH
T
0
0 HH
y
3
5
=
HH
T
HH
y
(3.44)
Therefore, the rank of
H
Q
is
rank
H
Q
= rank
HH
T
HH
y
= rank
HH
T
+ rank
HH
y
= 2 rank
HH
y
: (3.45)
The second equality holds because the rank of a direct sum is the sum of the individual ranks and
the third holds because the rank is invariant under the matrix transpose operation. Therefore,
the resulting entanglement-assisted quantum code requires c = rank
HH
y
ebits by applying the
result of the original theorem. The construction in Refs. [13, 14] produces an [[n; 2kn +c;c]]
entanglement-assisted quantum code.
Corollary 3.6.3. We can construct a continuous-variable entanglement-assisted quantum code
from generators corresponding to the rows in quantum check matrix H =
h
H
Z
H
X
i
whereH
is (nk) 2n-dimensional, H is a real matrix representing the quantum code [83], and both H
Z
and H
X
are (nk)n-dimensional. The resulting code is an [[n;k +c;c]] continuous-variable
entanglement-assisted code and requires c entangled modes where
c = rank
H
X
H
T
Z
H
Z
H
T
X
=2: (3.46)
39
Proof. The proof is similar to the proof of the rst theorem but requires manipulations of real
vectors instead of binary vectors. See Ref. [83] for details of the symplectic geometry required for
continuous-variable entanglement-assisted codes.
Remark 3.6.1. A similar formula holds for entanglement-assisted qudit codes by replacing the
subtraction operation above with subtraction modulo d. Specically, we can construct a qudit
entanglement-assisted quantum code from generators corresponding to the rows in check matrix
H =
h
H
Z
H
X
i
whose matrix entries are elements of the nite eld Z
d
. The code requires c
edits (a d-dimensional state
P
d1
i=0
jiijii
=
p
d) where
c = rank
H
X
H
T
Z
d
H
Z
H
T
X
=2
and
d
is subtraction modulo d. We use subtraction modulo d because the symplectic form over
d-dimensional variables includes subtraction modulo d.
3.7 Closing Remarks
This chapter reviewed the theory of entanglement-assisted coding for block codes. We showed
how to manipulate these codes with both a Pauli representation and a binary one. Our con-
tributions included an algorithm for computing an encoding circuit and a method to determine
the optimal number of ebits for an entanglement-assisted code. Much of this thesis extends the
entanglement-assisted technique to the domain of quantum convolutional coding. We introduce
quantum convolutional coding in the next chapter.
40
Chapter 4
Quantum Convolutional Codes
Forney, Viterbi, and Elias,
To Andy the Trojans are pious,
Their methods, we want 'em,
Who'd think they'd go quantum?
So now they still stupefy us.
The block codes in the previous two chapters are useful in quantum computing and in quantum
communication. One of the drawbacks of the block-coding technique for quantum communication
is that, in general, the sender must have all her qubits ready before encoding takes place. For a
large block code, this preparation may be a heavy demand on the sender.
Quantum convolutional coding theory [61, 62, 30, 29] oers a dierent paradigm for coding
quantum information. The convolutional structure is useful in a quantum communication scenario
where a sender possesses a stream of qubits to send to a receiver. The encoding circuit for a
quantum convolutional code has a much lower complexity than an encoding circuit needed for a
large block code. It also has a repetitive pattern so that the same physical devices or the same
routines can encode the stream of quantum information in an online fashion as soon as information
qubits are available for encoding.
Quantum convolutional stabilizer codes borrow heavily from the structure of their classical
counterparts [61, 62, 30, 29]. Quantum convolutional codes are similar because some of the qubits
feed back into a repeated encoding unitary and give the code a memory structure like that of a
41
classical convolutional code. The quantum codes feature online encoding and decoding of qubits.
This feature gives quantum convolutional codes both their low encoding and decoding complexity.
Our techniques for encoding and decoding are an expansion of previous techniques from quan-
tum convolutional coding theory. Previous techniques for encoding and decoding include nite-
depth operations only. A nite-depth operation propagates errors to a nite number of neighboring
qubits in the qubit stream. We introduce an innite-depth operation to the set of shift-invariant
Cliord operations and explain it in detail in Section 4.6. We must be delicate when using innite-
depth operations because they can propagate errors to an innite number of neighboring qubits
in the qubit stream. We explain our assumptions in detail when we include innite-depth oper-
ations in entanglement-assisted quantum convolutional codes in Section 5.4 of the next chapter.
An innite-depth operation gives more
exibility when designing encoding circuits|similar to the
way in which an innite-impulse response lter gives more
exibility in the design of classical
convolutional circuits.
We structure this chapter as follows. In Section 4.1, we introduce the denition of a quantum
convolutional code and discuss how it operates. Section 4.2 introduces the Pauli-to-binary isomor-
phism. This mapping simplies the mathematics of a quantum convolutional code by showing how
to represent it with a matrix of binary polynomials. Section 4.3 discusses the important \shifted
symplectic product" that gives the commutation relations of a set of convolutional generators. We
discuss in Section 4.4 how to manipulate the binary polynomial matrix that represents a quantum
convolutional code. In Sections 4.5 and 4.6, we respectively review nite-depth and innite-depth
operations for encoding a quantum convolutional code.
4.1 Review of the Convolutional Stabilizer Formalism
We review the theory of convolutional stabilizer codes by considering a set of Pauli matrices that
stabilize a stream of encoded qubits. We rst give the mathematical denition of a quantum
convolutional code and follow by discussing the various steps involved in the operation of it.
42
4.1.1 Quantum Convolutional Code Denition
A quantum convolutional stabilizer code acts on a Hilbert spaceH that is a countably innite
tensor product of two-dimensional qubit Hilbert spacesfH
i
g
i2Z
+ where
H =
1
O
i=0
H
i
: (4.1)
andZ
+
f0; 1;:::g. A sequence A of Pauli matricesfA
i
g
i2Z
+ , where
A =
1
O
i=0
A
i
; (4.2)
can act on states inH. Let
Z
+
denote the set of all Pauli sequences. The support supp(A) of a
Pauli sequence A is the set of indices of the entries in A that are not equal to the identity. The
weight of a sequence A is the sizejsupp (A)j of its support. The delay del(A) of a sequence A is
the smallest index for an entry not equal to the identity. The degree deg(A) of a sequence A is
the largest index for an entry not equal to the identity. E.g., the following Pauli sequence
I X I Y Z I I
; (4.3)
has supportf1; 3; 4g, weight three, delay one, and degree four. A sequence has nite support if its
weight is nite. Let F (
Z
+
) denote the set of Pauli sequences with nite support. The following
denition for a quantum convolutional code utilizes the set F (
Z
+
) in its description.
Denition 4.1.1. A rate k=n-convolutional stabilizer code with 0 k n is specied by a
commuting setG of all n-qubit shifts of a basic generator setG
0
. The commutativity requirement
is necessary for the same reason that standard stabilizer codes require it [60]. The basic generator
setG
0
has nk Pauli sequences of nite support:
G
0
=
n
G
i
2F (
Z
+
) : 1ink
o
: (4.4)
43
The constraint length of the code is the maximum degree of the generators inG
0
. A frame of the
code consists of n qubits. The denition of a quantum convolutional code as n-qubit shifts of the
basic setG
0
is what gives the code its periodic structure.
A quantum convolutional code admits an equivalent denition in terms of the delay transform
or D-transform. The D-transform captures shifts of the basic generator setG
0
. Let us dene the
n-qubit delay operator D acting on any Pauli sequence A2
Z
+
as follows:
D (A) =I
n
A: (4.5)
We can write j repeated applications of D as a power of D:
D
j
(A) =I
jn
A: (4.6)
LetD
j
(G
0
) be the set of shifts of elements ofG
0
byj. Then the full stabilizerG for the convolutional
stabilizer code is
G =
S
j2Z
+
D
j
(G
0
): (4.7)
Example 4.1.1. Forney et al. provided an example of a rate-1/3 quantum convolutional code
by importing a particular classical quaternary convolutional code [30, 29]. Grassl and R otteler
determined a noncatastrophic encoding circuit for Forney et al.'s rate-1/3 quantum convolutional
code [34]. The basic stabilizer and its rst shift are as follows:
III
III
III
III
XXX
ZZZ
III
III
XZY
ZYX
XXX
ZZZ
III
III
XZY
ZYX
III
III
III
III
(4.8)
The code consists of all three-qubit shifts of the above generators. The vertical bars are a visual
aid to illustrate the three-qubit shifts of the basic generators. The code can correct for an arbitrary
single-qubit error in every other frame.
44
Figure 4.1: The operation of a quantum convolutional code. The sender applies the same unitary
successively to a stream of information qubits and ancilla qubits. The convolutional structure
implies that the unitary overlaps some of the same qubits. The sender transmits her qubits as
soon as the unitary nishes processing them. The noisy quantum channel corrupts the transmitted
qubits. The receiver performs overlapping multi-qubit measurements to diagnose channel errors
and corrects for them. The receiver performs an online decoding circuit to recover the sender's
original stream of information qubits.
4.1.2 Quantum Convolutional Code Operation
Figure 4.1 illustrates the basic operation of a quantum convolutional code. The operation of a
rate-k=n quantum convolutional code consists of several steps:
(i). The protocol begins with the sender encoding a stream of information qubits with an online
encoding circuit. The sender encodesnk ancilla qubits andk information qubits per frame
[36, 34]. The encoding circuit is \online" if it acts on a few frames at a time.
(ii). The sender transmits a set of initial qubits as soon as the rst unitary nishes processing
them and continues to transmit later qubits after the next part of the online encoding circuit
nishes processing them.
(iii). The above basic setG
0
and all of its n-qubit shifts act like a parity check matrix for the
quantum convolutional code. The receiver measures the generators in the stabilizer to de-
termine an error syndrome. It is important that the generators inG
0
have nite weight so
that the receiver can perform the measurements and produce an error syndrome. It is also
important that the generators have a block-band form so that the receiver can perform the
measurements online as the noisy encoded qubits arrive.
(iv). The receiver processes the error syndromes with an online classical error estimation algorithm
such as the Viterbi algorithm [75] or any other decoding algorithm [46] to determine the
45
most likely error for each frame of quantum data. Syndrome-based versions of the Viterbi
algorithm that are appropriate for quantum coding are available in Refs. [61, 62, 63].
(v). The receiver performs unitary recovery operations that reverse the estimated errors.
(vi). He nally processes the encoded qubits with a decoding circuit to recover the original stream
of information qubits. The qubits decoded from this convolutional procedure should be error
free and ready for quantum computation at the receiving end.
In the above description, each step is online|the sender and receiver do not have to employ
the above procedure sequentially. Processing of one step can begin once the previous step has
nished some amount of processing. All steps above are always active during processing once the
initial rounds have been completed.
4.2 The Pauli-to-Binary Isomorphism for Quantum Convo-
lutional Codes
This section contains the most important part of this quantum convolutional coding review|the
isomorphism from the set of Pauli sequences to the module over the ring of binary polynomials
[62, 34, 29]. We also name it the Pauli-to-binary (P2B) isomorphism (whether we are considering
the P2B isomorphism for block codes or convolutional codes should be clear from the context).
The P2B isomorphism is important because it is easier to perform manipulations with vectors of
binary polynomials than with Pauli sequences.
We rst dene the phase-free Pauli group
Z
on a sequence of qubits. Recall that the delay
transformD in (4.5) shifts a Pauli sequence to the right by n. Let us assume for now that n = 1.
Let
Z
denote the set of all countably innite Pauli sequences. The set
Z
is equivalent to the
set of all one-qubit shifts of arbitrary Pauli operators:
Z
=
Q
i2Z
D
i
(A
i
) :A
i
2
: (4.9)
46
We remark thatD
i
(A
i
) =D
i
(A
i
I
1
). We make this same abuse of notation in what follows.
We can dene the equivalence class
Z
of phase-free Pauli sequences:
Z
=
Aj A2
Z
;2C;jj = 1
: (4.10)
We develop the Pauli-to-binary (P2B) isomorphism between binary polynomials and Pauli
sequences. The P2B isomorphism is useful for representing the shifting nature of quantum convo-
lutional codes. Suppose z (D) and x (D) are arbitrary nite-degree and nite-delay polynomials
in D overZ
2
:
z (D) =
X
i
z
i
D
i
; x (D) =
X
i
x
i
D
i
; z
i
;x
i
2Z
2
8i2Z; (4.11)
where del(z (D)), del(x (D)), deg(z (D)), deg(x (D))<1. Suppose
u (D) = (z (D);x (D))2 (Z
2
(D))
2
; (4.12)
where (Z
2
(D))
2
indicates the Cartesian product Z
2
(D)Z
2
(D). Let us employ the following
shorthand:
u (D) = [z (D)jx (D)]: (4.13)
Let N be a map from the binary polynomials to the Pauli sequences, N : (Z
2
(D))
2
!
Z
, where
N (u (D)) =
Q
i
D
i
(Z
zi
X
xi
): (4.14)
Let v (D) = [z
0
(D)jx
0
(D)] where v (D)2 (Z
2
(D))
2
. The map N induces an isomorphism
[N] : (Z
2
(D))
2
!
Z
; (4.15)
because addition of binary polynomials is equivalent to multiplication of Pauli elements up to a
global phase:
[N (u (D) +v (D))] = [N (u (D))] [N (v (D))]: (4.16)
47
The above isomorphism is a powerful way to capture the inniteness and shifting nature of con-
volutional codes with nite-degree and nite-delay polynomials over the binary eld Z
2
.
A quantum convolutional code in general consists of generators with n qubits per frame.
Therefore, we consider then-qubit extension of the denitions and isomorphism given above. Let
the delay transform D now shift a Pauli sequence to the right by an arbitrary positive integer n.
Consider a 2n-dimensional vector u (D) of binary polynomials where u (D)2 (Z
2
(D))
2n
. Let us
write u (D) as follows
u (D) = [z (D)jx (D)] =
h
z
1
(D) z
n
(D)
j
x
1
(D) x
n
(D)
i
;
where z (D); x (D)2 (Z
2
(D))
n
. Suppose
z
i
(D) =
X
j
z
i;j
D
j
; x
i
(D) =
X
j
x
i;j
D
j
:
Dene a map N : (Z
2
(D))
2n
!
Z
:
N (u (D)) =
Q
j
D
j
(Z
z1;j
X
x1;j
)D
j
(I
Z
z2;j
X
x2;j
)D
j
I
n1
Z
zn;j
X
xn;j
:
N is equivalent to the following map (up to a global phase)
N (u (D)) =N (u
1
(D)) (I
N (u
2
(D)))
I
n1
N (u
n
(D))
;
where
u
i
(D) = [z
i
(D)jx
i
(D)]: (4.17)
Suppose
v (D) = [z
0
(D)jx
0
(D)]; (4.18)
where v (D)2 (Z
2
(D))
2n
. The map N induces an isomorphism [N] : (Z
2
(D))
2n
!
Z
for the
same reasons given in (4.16):
[N (u (D) + v (D))] = [N (u (D))] [N (v (D))]: (4.19)
48
The P2B isomorphism [N] is again useful because it allows us to perform binary calculations
instead of Pauli calculations.
4.3 The Shifted Symplectic Product
We consider the commutative properties of quantum convolutional codes in this section. We
develop some mathematics for the important \shifted symplectic product." The shifted symplectic
product reveals the commutation relations of an arbitrary number of shifts of a set of Pauli
sequences.
Recall from Denition 4.1.1 that a commuting set comprising a basic set of Paulis and all their
shifts species a quantum convolutional code. How can we capture the commutation relations of
a Pauli sequence and all of its shifts? The shifted symplectic product, where
: (Z
2
(D))
2
(Z
2
(D))
2
!Z
2
(D); (4.20)
is an elegant way to do so. The shifted symplectic product maps two vectorsu (D) = [z (D)jx (D)]
and v (D) = [z
0
(D)jx
0
(D)] to a binary polynomial with nite delay and nite degree:
(uv) (D) =z (D)x
0
D
1
x (D)z
0
D
1
: (4.21)
The shifted symplectic product is not a proper symplectic product because it fails to be alternating
[22]. The alternating property requires that
(uv) (D) = (vu) (D); (4.22)
but we nd instead that the following holds:
(uv) (D) = (vu)
D
1
: (4.23)
Every vector u (D)2Z
2
(D)
2
is self time-reversal antisymmetric with respect to:
(uu) (D) = (uu)
D
1
8u (D)2Z
2
(D)
2
: (4.24)
49
Every binary vector is also self time-reversal symmetric with respect to because addition and
subtraction are the same overZ
2
. We employ the addition convention from now on and drop the
minus signs. The shifted symplectic product is a binary polynomial inD. We write its coecients
as follows:
(uv) (D) =
X
i2Z
(uv)
i
D
i
: (4.25)
The coecient (uv)
i
captures the commutation relations of two Pauli sequences fori one-qubit
shifts of one of the sequences:
N (u (D))D
i
(N (v (D))) = (1)
(uv)
i
D
i
(N (v (D)))N (u (D)): (4.26)
Thus two Pauli sequencesN (u (D)) andN (v (D)) commute for all shifts if and only if the shifted
symplectic product (uv) (D) vanishes.
The next example highlights the main features of the shifted symplectic product and further
emphasizes the relationship between Pauli commutation and orthogonality of the shifted symplec-
tic product.
Example 4.3.1. Consider two vectors of binary polynomials:
u (D) =
h
D
j
1 +D
3
i
; v (D) =
h
1 +D
j
D
3
i
:
The P2B isomorphism maps the above polynomials to the following Pauli sequences:
N (u (D)) = (jIjXjZjIjXjIj ); N (v (D)) = (jIjZjZjIjXjIj ): (4.27)
The vertical bars between every Pauli in the sequence indicate that we are considering one-qubit
shifts. We determine the commutation relations of the above sequences by inspection. N (u (D))
anticommutes with a shift of itself by one or two to the left or right and commutes with all other
shifts of itself. N (v (D)) anticommutes with a shift of itself by two or three to the left or right
and commutes with all other shifts of itself. N (u (D)) anticommutes with N (v (D)) shifted to
50
the left by one or two, with the zero-shifted N (v (D)), and withN (v (D)) shifted to the right by
two or three. The following shifted symplectic products give us the same information:
(uu) (D) =D
2
+D
1
+D +D
2
; (vv) (D) =D
3
+D
2
+D
2
+D
3
;
(vu) (D) =D
3
+D
2
+ 1 +D +D
2
: (4.28)
The nonzero coecients indicate the commutation relations just as (4.26) claims.
We can again dene a shifted symplectic product for the case of n-qubits per frame. Let
denote the shifted symplectic product between vectors of binary polynomials:
: (Z
2
(D))
2n
(Z
2
(D))
2n
!Z
2
(D): (4.29)
It maps 2n-dimensional vectors u (D) and v (D) of binary polynomials to a nite-degree and
nite-delay binary polynomial
(u v) (D) =
n
X
i=1
(u
i
v
i
) (D); (4.30)
where
u
i
(D) = [z
i
(D)jx
i
(D)]; v
i
(D) = [z
0
i
(D)jx
0
i
(D)]:
The standard inner product gives an alternative way to dene the shifted symplectic product:
(u v) (D) = z (D) x
0
D
1
x (D) z
0
D
1
: (4.31)
Every vector u (D)2Z
2
(D)
2n
is self time-reversal symmetric with respect to:
(u u) (D) = (u u)
D
1
8u (D)2Z
2
(D)
2n
: (4.32)
The shifted symplectic product for vectors of binary polynomials is a binary polynomial in D. We
write its coecients as follows:
(u v) (D) =
X
i2Z
(u v)
i
D
i
: (4.33)
51
The coecient (u v)
i
captures the commutation relations of two Pauli sequences for i n-qubit
shifts of one of the sequences:
N (u (D))D
i
(N (v (D))) = (1)
(uv)
i
D
i
(N (v (D))) N (u (D)):
The shifted symplectic product between two vectors of binary polynomials vanishes if and only if
their corresponding Pauli sequences commute.
Example 4.3.2. We consider the case where the frame size n = 4. Consider the following vectors
of polynomials:
2
4
u (D)
v (D)
3
5
=
2
4
1 +D D 1 D
0 1 0 0
0 1 0 0
1 +D 1 +D 1 D
3
5
: (4.34)
The P2B isomorphism maps u (D) and v (D) to the following Pauli sequences:
N (u (D)) = (jIIIIjZXZIjZZIZjIIIIj );
N (v (D)) = (jIIIIjXYXIjXXIXjIIIIj ): (4.35)
We can determine the commutation relations by inspection of the above Pauli sequences. N (u (D))
anticommutes with itself shifted by one to the left or right, N (v (D)) anticommutes with itself
shifted by one to the left or right, and N (u (D)) anticommutes with N (v (D)) shifted by one to
the left. The following shifted symplectic products conrm the above commutation relations:
(u u) (D) =D
1
+D; (v v) (D) =D
1
+D; (u v) (D) =D
1
:
We note two useful properties of the shifted symplectic product. Suppose f (D)2Z
2
(D)
with deg (f) 0. Let us denote scalar polynomial multiplication as follows:
(f u) (D) =
h
f (D)u
1
(D) f (D)u
n
(D)
i
: (4.36)
52
The following identities hold.
((f u) v) (D) =f (D) (u v) (D); (4.37)
(u (f v)) (D) =f
D
1
(u v) (D): (4.38)
We also remark that
(u v) (D) = (v u) (D);
i
(u v) (D) = (u v)
D
1
:
The shifted symplectic product vanishes for all generators in a quantum convolutional code
because of the commutativity requirement in Denition 4.1.1. The cases where the shifted sym-
plectic product does not vanish (where the two Pauli sequences anticommute for one or more
shifts) are important for constructing entanglement-assisted quantum convolutional codes.
In general, we represent a rate-k=n quantum convolutional code with an (nk)2n-dimensional
quantum check matrixH (D) according to the P2B isomorphism. The entries ofH (D) are binary
polynomials where
H (D) =
h
Z (D)
X (D)
i
;
andZ (D) andX (D) are both (nk)n-dimensional binary polynomial matrices. The following
matrix
(D) captures the commutation relations of the generators in H (D):
(D) =Z (D)X
T
D
1
+X (D)Z
T
D
1
:
The reader can verify that the matrix elements [
(D)]
ij
of
(D) are the shifted symplectic
products between the i
th
and j
th
respective rows h
i
(D) and h
j
(D) of H (D):
[
(D)]
ij
= (h
i
h
j
) (D):
We call the matrix
(D) the shifted symplectic product matrix because it encodes all of the shifted
symplectic products or the commutation relations of the code. This matrix is equal to the null
53
matrix for a valid quantum convolutional code because all generators commute with themselves
and with all n-qubit shifts of themselves and each other. For a general set of generators,
(D) is
not equal to the null matrix and obeys the symmetry:
(D) =
T
D
1
.
4.4 Row and Column Operations
We can perform row operations on binary polynomial matrices for quantum convolutional codes.
A row operation is merely a \mental" operation that has no eect on the states in the codespace
or on the error-correcting properties of the code. It just changes the rows of the check matrix for
a code. We have three types of row operations:
(i). An elementary row operation multiplies a row times an arbitrary binary polynomial and
adds the result to another row. This additive invariance holds for any code that admits a
description within the stabilizer formalism. Additive codes are invariant under multiplication
of the stabilizer generators in the \Pauli picture" or under row addition in the \binary-
polynomial picture."
(ii). Another type of row operation is to multiply a row by an arbitrary power of D. Ollivier
and Tillich discuss such row operations as \multiplication of a line by D" and use them to
nd encoding operations for their quantum convolutional codes [62]. Grassl and R otteler
use this type of operation to nd a subcode of a given quantum convolutional code with an
equivalent asymptotic rate and equivalent error-correcting properties [34].
(iii). We also employ row operations that multiply a row by an arbitrary polynomial (not nec-
essarily a power of D). This type of row operation occurs when we have generators with
innite weight that we would like to reduce to nite weight so that the receiver can perform
measurements in an online fashion as qubits arrive from the noisy channel.
We can encode all of the above types of row operations in a full-rank matrixR (D) with rational
polynomial entries. Let H
0
(D) denote the resulting check matrix after performing a set of row
operations in the matrix R (D) where H
0
(D) =R (D)H (D). The resulting eect on the shifted
54
symplectic product matrix
(D) is to change it to another shifted symplectic product matrix
0
(D) related to
(D) by
0
(D) =R (D)
(D)R
T
D
1
: (4.39)
Row operations do not change the commutation relations of a valid quantum convolutional code
because its shifted symplectic product matrix is equal to the null matrix. But row operations do
change the commutation relations of a set of generators whose corresponding shifted symplectic
product matrix is not equal to the null matrix. This ability to change the commutation relations
through row operations is crucial for constructing entanglement-assisted quantum convolutional
codes from an arbitrary set of generators. We use entanglement to resolve any anticommutativity
in the generators.
We can also perform column operations on binary polynomial matrices for quantum convolu-
tional codes. Column operations do change the error-correcting properties of the code and are
important for realizing a periodic encoding circuit for the code. We have two types of column
operations:
(i). An elementary column operation multiplies one column by an arbitrary binary polynomial
and adds the result to another column. We implement elementary column operations with
gates from the shift-invariant Cliord group [36, 34].
(ii). Another column operation is to multiply column i in both the \X" and \Z" matrix by D
l
where l2Z. We perform this operation by delaying or advancing the processing of qubit i
by l frames relative to the original frame.
(iii). An innite-depth column operation multiplies one column in the \X" matrix by a rational
polynomial whose numerator is one and multiplies the corresponding column in the \Z"
matrix by a corresponding nite polynomial.
A column operation implemented on the \X" side of the binary polynomial matrix has a
corresponding eect on the \Z" side of the binary polynomial matrix. This corresponding eect
is a manifestation of the Heisenberg uncertainty principle because commutation relations remain
invariant with respect to the action of unitary quantum gates. The shifted symplectic product is
55
therefore invariant with respect to column operations from the shift-invariant Cliord group. The
next two sections describe possible column operations for implementing encoding circuits.
4.5 Finite-Depth Cliord Operations
One of the main advantages of a quantum convolutional code is that its encoding circuit has a
periodic form. We can encode a stream of quantum information with the same physical routines
or devices and therefore reduce encoding and decoding complexity.
Ollivier and Tillich were the rst to discuss encoding circuits for quantum convolutional codes
[61, 62]. They provided a set of necessary and sucient conditions to determine when an encoding
circuit is noncatastrophic. A noncatastrophic encoding circuit does not propagate uncorrected
errors innitely through the decoded information qubit stream. Classical convolutional coding
theory has a well developed theory of noncatastrophic encoding circuits [46].
Grassl and R otteler later showed that Ollivier and Tillich's conditions for a circuit to be
noncatastrophic are too restrictive [34, 35, 36]. They found subcodes of quantum convolutional
codes that admit noncatastrophic encoders. The noncatastrophic encoders are a sequence of
Cliord circuits with nite depth. They developed a formalism for encapsulating the periodic
structure of an encoding circuit by decomposing the encoding circuit as a set of elementary column
operations. Their decoding circuits are exact inverses of their encoding circuits because their
decoding circuits perform the encoding operations in reverse order.
Denition 4.5.1. A nite-depth operation transforms every nite-weight stabilizer generator to
one with nite weight.
This property is important because we do not want the decoding circuit to propagate uncor-
rected errors into the information qubit stream [46]. A nite-depth decoding circuit corresponding
to any stabilizer for a quantum convolutional code exists by the algorithm given in Ref. [34].
We review the nite-depth operations in the shift-invariant Cliord group [34, 35, 36]. The
shift-invariant Cliord group is an extension of the Cliord group operations mentioned in Sec-
tion 2.2. We describe how nite-depth operations in the shift-invariant Cliord group aect the
binary polynomial matrix for a code. Each of the following operations acts on every frame of a
quantum convolutional code.
56
(i). The sender performs a CNOT from qubit i to qubit j in every frame where qubit j is in a
frame delayed by k. The eect on the binary polynomial matrix is to multiply column i by
D
k
and add the result to columnj in the \X" matrix and to multiply columnj byD
k
and
add the result to column i in the \Z" matrix.
(ii). A Hadamard on qubiti swaps columni in the \X" matrix with columni in the \Z" matrix.
(iii). A phase gate on qubit i adds column i from the \X" matrix to column i in the \Z" matrix.
(iv). A controlled-phase gate from qubiti to qubitj in a frame delayed byk multiplies columni in
the \X" matrix byD
k
and adds the result to column j in the \Z" matrix. It also multiplies
column j in the \X" matrix by D
k
and adds the result to column i in the \Z" matrix.
(v). A controlled-phase gate from qubit i to qubit i in a frame delayed by k multiplies column i
in the \X" matrix by D
k
+D
k
and adds the result to column i in the \Z" matrix.
We use nite-depth operations extensively in the next few chapters. Figure 5.2 gives an ex-
ample of an entanglement-assisted quantum convolutional code that employs several nite-depth
operations. The circuit encodes a stream of information qubits with the help of ebits shared
between sender and receiver.
Multiple CNOT gates can realize an elementary column operation as described at the end of
the previous section. Suppose the elementary column operation multiplies column i in the \X"
matrix byf (D) and adds the result to columnj. Polynomialf (D) is a summation of some nite
setfl
1
;:::;l
n
g of powers of D:
f (D) =D
l1
+ +D
ln
:
We can realize f (D) by performing a CNOT gate from qubit i to qubit j in a frame delayed by
l
i
for each i2f1;:::;ng.
4.6 Innite-Depth Cliord Operations
We now introduce an innite-depth operation to the set of operations in the shift-invariant Cliord
group available for encoding and decoding quantum convolutional codes.
57
Denition 4.6.1. An innite-depth operation can transform a nite-weight stabilizer generator
to one with innite weight (but does not necessarily do so to every nite-weight generator).
A decoding circuit with innite-depth operations on qubits sent over the noisy channel is
undesirable because it spreads uncorrected errors innitely into the decoded information qubit
stream. But an encoding circuit with innite-depth operations is acceptable if we assume a
communication paradigm in which the only noisy process is the noisy quantum channel.
The next chapter shows several examples of circuits that include innite-depth operations.
Innite-depth operations expand the possibilities for quantum convolutional circuits in much the
same way that incorporating feedback expands the possibilities for classical convolutional circuits.
We illustrate the details of several innite-depth operations by rst providing some specic
examples of innite-depth operations and then show how to realize an arbitrary innite-depth
operation.
We consider both the stabilizer and the logical operators for the information qubits in our
analysis. Tracking both of these sets of generators is necessary for determining the proper decoding
circuit when including innite-depth operations.
4.6.1 Examples of Innite-Depth Operations
Our rst example of an innite-depth operation involves a stream of information qubits and ancilla
qubits. We divide the stream into frames of three qubits where each frame has two ancilla qubits
and one information qubit. The following two generators and each of their three-qubit shifts
stabilize the initial qubit stream:
I I I
I I I
Z I I
I Z I
I I I
I I I
(4.40)
The binary polynomial matrix corresponding to this stabilizer is as follows:
2
4
1 0 0
0 1 0
0 0 0
0 0 0
3
5
: (4.41)
58
We obtain any Pauli sequence in the stabilizer by multiplying the above rows by a power ofD and
applying the inverse of the P2B isomorphism. The logical operators for the information qubits
are as follows:
I I I
I I I
I I X
I I Z
I I I
I I I
They also admit a description with a binary polynomial matrix:
2
4
0 0 0
0 0 1
0 0 1
0 0 0
3
5
: (4.42)
We refer to the above matrix as the \information-qubit matrix."
Encoding
Suppose we would like to encode the above stream so that the following generators stabilize it:
I I I
I I I
X X X
Z Z I
X X I
I I I
;
or equivalently, the following binary polynomial matrix stabilizes it:
2
4
0 0 0
1 1 0
D + 1 D + 1 1
0 0 0
3
5
: (4.43)
We encode the above stabilizer using a combination of nite-depth operations and an innite-
depth operation. We perform a Hadamard on the rst qubit in each frame and follow with a CNOT
from the rst qubit to the second and third qubits in each frame. These operations transform the
matrix in (4.41) to the following matrix
2
4
0 0 0
1 1 0
1 1 1
0 0 0
3
5
;
59
or equivalently transform the generators in (4.40) to the following generators:
I I I
I I I
X X X
Z Z I
I I I
I I I
The information-qubit matrix becomes
2
4
0 0 0
1 0 1
0 0 1
0 0 0
3
5
:
We now perform an innite-depth operation: a CNOT from the third qubit in one frame to the
third qubit in a delayed frame and repeat this operation for all following frames. Figure 4.2 shows
this operation acting on our stream of qubits with three qubits per frame. The eect of this
operation is to translate the above stabilizer generators as follows:
I I I
I I I
X X X
Z Z I
I I X
I I I
I I X
I I I
The rst generator above and each of its three-qubits shifts is an innite-weight generator if the
above sequence of CNOT gates acts on the entire countably-innite qubit stream. We represent
the above stabilizer with the binary rational polynomial matrix
2
4
0 0 0
1 1 0
1 1 1= (1 +D)
0 0 0
3
5
; (4.44)
where 1= (1 +D) = 1 +D +D
2
+::: is a repeating fraction. The operation is innite-depth
because it translates the original nite-weight stabilizer generator to one with innite weight.
It is possible to perform a row operation that multiplies the rst row by D + 1. This operation
gives a stabilizer matrix that is equivalent to the desired stabilizer in (4.43). The receiver of
the encoded qubits measures the nite-weight stabilizer generators in (4.43) to diagnose errors.
These measurements do not disturb the information qubits because they also stabilize the encoded
stream.
60
Figure 4.2: An example of an innite-depth operation. A sequence of CNOT gates acts on the
third qubit of every frame. This innite-depth operation eectively multiplies the third column of
the \X" side of the binary polynomial matrix by the rational polynomial 1= (1 +D) and multiplies
the third column of the \Z" side of the binary polynomial matrix by 1 +D
1
.
61
The above encoding operations transform the information-qubit matrix as follows:
2
4
0 0 0
1 0 1 +D
1
0 0 1= (1 +D)
0 0 0
3
5
: (4.45)
The innite-depth operation on the third qubit has an eect on the \Z" or left side of the
information-qubit matrix as illustrated in the second row of the above matrix. The eect is
to multiply the third column of the \Z" matrix by f
D
1
if the operation multiplies the third
column of the \X" matrix by 1=f (D). This corresponding action on the \Z" side occurs because
the commutation relations of the Pauli operators remain invariant under quantum gates (due to
the Heisenberg uncertainty principle), or equivalently, the shifted symplectic product remains in-
variant under column operations. The original shifted symplectic product for the logical operators
is one, and it remains as one because f((D
1
)
1
)=f (D) = 1.
Decoding
We perform nite-depth operations to decode the stream of information qubits. Begin with the
stabilizer and information-qubit matrix in (4.44) and (4.45) respectively. Perform a CNOT from
the rst qubit to the second qubit. The stabilizer becomes
2
4
0 0 0
0 1 0
1 0 1= (1 +D)
0 0 0
3
5
;
and the information-qubit matrix does not change. Perform a CNOT from the third qubit to the
rst qubit in the same frame and in a delayed frame. These gates multiply column three in the
\X" matrix by 1 +D and add the result to column one. The gates also multiply column one in
the \Z" matrix by 1 +D
1
and add the result to column three. The eect is as follows on both
the stabilizer
2
4
0 0 0
0 1 0
0 0 1= (1 +D)
0 0 0
3
5
; (4.46)
62
and the information-qubit matrix
2
4
0 0 0
1 0 0
1 0 1= (1 +D)
0 0 0
3
5
: (4.47)
We can multiply the logical operators by any element of the stabilizer and obtain an equivalent
logical operator [33]. We perform this multiplication in the \binary-polynomial picture" by adding
the rst row of the stabilizer in (4.46) to the rst row of (4.47). The information-qubit matrix
becomes
2
4
0 0 0
1 0 0
1 0 0
0 0 0
3
5
; (4.48)
so that the resulting logical operators act only on the rst qubit of every frame. We have success-
fully decoded the information qubits with nite-depth operations. The information qubits teleport
coherently [39, 81] from being the third qubit of each frame as in (4.42) to being the rst qubit
of each frame as in (4.48). We exploit the above method of encoding with innite-depth oper-
ations and decoding with nite-depth operations for the class of entanglement-assisted quantum
convolutional codes in Section 5.4.1.
4.6.2 General Innite-Depth Operations
We discuss the action of a general innite-depth operation on two weight-one \X" and \Z" Pauli
sequences where each frame has one Pauli matrix. Our analysis then determines the eect of an
innite-depth operation on an arbitrary stabilizer or information-qubit matrix. The generators in
the \Pauli picture" are as follows:
I
I
X
Z
I
I
; (4.49)
or as follows in the \binary-polynomial picture":
2
4
0
1
1
0
3
5
:
63
An innite-depth 1=f (D) operation, wheref (D) is an arbitrary polynomial, transforms the above
matrix to the following one:
2
4
0
f
D
1
1=f (D)
0
3
5
:
A circuit that performs this transformation preserves the shifted symplectic product because
f
D
1
1=f
D
1
= 1. The circuit operates on a few qubits at a time and is shift-invariant|
the same device or physical routines implement it.
First perform the long division expansion of binary rational polynomial 1=f (D). This ex-
pansion has a particular repeating pattern with period l. For example, suppose that f (D) =
1 +D +D
3
. Its long-division expansion is 1 +D +D
2
+D
4
+D
7
+D
8
+D
9
+D
11
+::: and
exhibits a repeating pattern with period seven. We want a circuit that realizes the following Pauli
generators
I
Z
I
I
I
Z
X
Z
X
I
X
I
I
I
X
I
I
I
; (4.50)
where the pattern in theX matrices is the same as the repeating polynomial 1=f (D) and continues
innitely to the right, and the pattern on the Z matrices is the same as that in f
D
1
and
terminates at the left. The above Pauli sequence is equivalent to the following binary rational
polynomial matrix:
2
4
0
1 +D
1
+D
3
1=
1 +D +D
3
0
3
5
:
We now discuss a method that realizes an arbitrary rational polynomial 1=f (D) as an innite-
depth operation. Our method for encoding the generators in (4.50) from those in (4.49) consists
of a \sliding-window" technique that determines transformation rules for the circuit. The circuit
is an additive, shift-invariant ltering operation. It resembles an innite-impulse response lter
because the resulting sequence extends innitely. In general, the number N of qubits that the
encoding unitary operates on is as follows
N = deg (f (D)) del (f (D)) + 1;
64
where deg (f (D)) and del (f (D)) are the respective highest and lowest powers of polynomial
f (D). Therefore, our exemplary encoding unitary operates on four qubits at a time. We delay
the original sequence in (4.49) by three frames. These initial frames are \scratch" frames that
give the encoding unitary enough \room" to generate the desired Paulis in (4.50). The rst set of
transformation rules is as follows
I
I
I
I
I
I
X
Z
!
I
Z
I
I
I
Z
X
Z
; (4.51)
and generates the rst four elements of the pattern in (4.50). Now that the encoding unitary
has acted on the rst four frames, we need to shift our eyes to the right by one frame in the
sequence in (4.50) to determine the next set of rules. So we shift the above outputs by one frame
to the left (assuming that only identity matrices lie to the right) and determine the next set of
transformation rules that generate the next elements of the sequence in (4.50):
I
I
I
Z
X
Z
I
I
!
I
I
I
Z
X
Z
X
I
:
Shift the above outputs to the left by one frame to determine the next set of transformation rules:
I
Z
X
Z
X
I
I
I
!
I
Z
X
Z
X
I
X
I
:
We obtain the rest of the transformation rules by continuing this sliding process, and we stop
when the pattern in the sequence in (4.50) begins to repeat:
X
Z
X
X
I
X
X
I
X
I
X
I
X
I
I
X
I
I
I
I
I
I
I
I
!
X
Z
X
X
I
X
X
I
X
I
X
I
X
I
I
X
I
I
I
I
X
I
I
X
:
65
The above set of rules determines the encoding unitary and only a few of them are actually
necessary. We can multiply the rules together to form equivalent rules because the circuit obeys
additivity (in the \binary-polynomial picture"). The rules become as follows after rearranging
into a standard form:
Z
I
I
I
X
I
I
I
I
Z
I
I
I
X
I
I
I
I
Z
I
I
I
X
I
I
I
I
Z
I
I
I
X
!
Z
I
I
Z
X
I
I
I
I
Z
I
I
I
X
I
I
I
I
Z
Z
I
I
X
I
I
I
I
Z
X
I
X
X
:
A CNOT from qubit one to qubit four and a CNOT from qubit three to qubit four suce to
implement this circuit. We repeatedly apply these operations shifting by one frame at a time
to implement the innite-depth operation. We could have observed that these gates suce to
implement the \Z" transformation in the rst set of transformation rules in (4.51), but we wanted
to show how this method generates the full periodic \X" sequence in (4.50). Figure 4.3 shows how
the above encoding unitary acts on a stream of quantum information.
We can determine the encoding unitary for an arbitrary rational polynomial 1=f (D) using a
similar method. Suppose that del (f (D)) =n and supposen6= 0 as in the above case. First delay
or advance the frames ifn> 0 or ifn< 0 respectively. Determine the CNOT gates that transform
the \Z" Pauli sequence
h
1
0
i
to
h
D
n
f
D
1
0
i
:
These CNOT gates form the encoding circuit that transform both the \X" and \Z" Pauli sequences.
We perform the encoding unitary, shift by one frame, perform it again, and keep repeating. Our
method encodes any arbitrary polynomial 1=f (D) on the \X" side and f
D
1
on the \Z" side.
66
Figure 4.3: Another example of an innite-depth operation. An innite-depth operation acts on
qubit i in every frame. This particular innite-depth operation multiplies column i on the \X"
side of the binary polynomial matrix by 1=
1 +D +D
3
and multiplies columni on the \Z" side
of the binary polynomial matrix by 1 +D
1
+D
3
.
We can implement the \time-reversed" polynomial 1=f
D
1
on the \X" side by rst delaying
the frames by m = deg (f (D)) del (f (D)) frames and performing the circuit corresponding to
1=D
m
f
D
1
. These operations implement the circuit D
m
=D
m
f
D
1
= 1=f
D
1
.
4.6.3 Innite-Depth Operations in Practice
We assume above that each of the innite-depth operations acts on the entire countably-innite
stream of qubits. In practice, each innite-depth operation acts on a nite number of qubits at a
time so that the encoding and decoding circuits operate in an \online" manner. Therefore, each
innite-depth operation approximates its corresponding rational polynomial. This approximation
does not pose a barrier to implementation. We can implement each of the above innite-depth
operations by padding the initial qubits of the information qubit stream with some \scratch"
qubits. We rst transmit these \scratch" qubits that contain no useful quantum information so
that the later information qubits enjoy the full protection of the code. These scratch qubits do
not aect the asymptotic rate of the code and merely serve as a convenience for implementing the
67
innite-depth operations. From now on, we adhere to describing innite-depth operations with
binary rational polynomials because it is more convenient to do so mathematically.
4.7 Closing Remarks
This chapter reviewed in detail the method of quantum convolutional coding. We discussed how
to represent a quantum convolutional code with a matrix of binary polynomials. The shifted
symplectic product is crucial in several of the forthcoming chapters because it determines the
commutation relations for an arbitrary set of convolutional generators. In general, a set of genera-
tors do not form a commuting set and we can use entanglement to resolve their anticommutativity.
In this chapter, we also developed many of the operations that manipulate quantum convolutional
codes. We repeatedly use these operations in the next few chapters.
68
Chapter 5
Entanglement-Assisted Quantum Convolutional
Coding: The CSS Case
O Calderbank, good Shor, and bright Steane,
Methinks your construction is keen,
But it makes me tense,
this Pauli sequence,
I just want our quantum bits clean.
In this chapter, we develop a theory of entanglement-assisted quantum convolutional coding for a
broad class of codes. Our major result is that we can produce an entanglement-assisted quantum
convolutional code from two arbitrary classical binary convolutional codes. The resulting quantum
convolutional codes admit a Calderbank-Shor-Steane (CSS) structure [18, 74, 60]. The rates and
error-correcting properties of the two binary classical convolutional codes directly determine the
corresponding properties of the entanglement-assisted quantum convolutional code.
Our CSS entanglement-assisted quantum convolutional codes divide into two classes based on
certain properties of the classical codes from which we produce them. These properties of the
classical codes determine the structure of the encoding and decoding circuit for the code, and the
structure of the encoding and decoding circuit in turn determines the class of the entanglement-
assisted quantum convolutional code.
(i). Codes in the rst class admit both a nite-depth encoding and decoding circuit.
69
(ii). Codes in the second class have an encoding circuit that employs both nite-depth and
innite-depth operations. Their decoding circuits have nite-depth operations only.
We structure this chapter as follows. We outline the operation of an entanglement-assisted
quantum convolutional code and present our main theorem in Section 5.1. This theorem shows
how to produce a CSS entanglement-assisted quantum convolutional code from two arbitrary
classical binary convolutional codes. The theorem gives the rate and error-correcting properties
of a CSS entanglement-assisted quantum convolutional code as a function of the parameters of
the classical convolutional codes. Section 5.3 completes the proof of the theorem for our rst class
of entanglement-assisted quantum convolutional codes. Section 5.4 completes the proof of our
theorem for the second class of entanglement-assisted quantum convolutional codes. We discuss
the implications of the assumptions for the dierent classes of entanglement-assisted quantum
convolutional codes while developing the constructions. Our theory produces high-performance
quantum convolutional codes by importing high-performance classical convolutional codes.
5.1 Operation of an Entanglement-Assisted Quantum Con-
volutional Code
An entanglement-assisted quantum convolutional code operates similarly to a standard quantum
convolutional code. The main dierence is that the sender and receiver share entanglement in the
form of ebits before quantum communication begins. An [[n;k;c]] entanglement-assisted quan-
tum convolutional code encodes k information qubits per frame with the help of c ebits and
nkc ancilla qubits per frame. Figure 5.1 highlights the main features of the operation of an
entanglement-assisted quantum convolutional code. An entanglement-assisted quantum convolu-
tional code operates as follows:
(i). The sender encodes a stream of quantum information using both additional ancillas and
ebits. The sender performs the encoding operations on her qubits only (i.e., not including
the halves of the ebits in possession of the receiver). The encoding operations have a periodic
structure so that the same operations act on qubits in dierent frames and give the code a
70
Figure 5.1: (Color online) An entanglement-assisted quantum convolutional code operates on a
stream of qubits partitioned into a countable number of frames. The sender encodes the frames of
information qubits, ancilla qubits, and half of shared ebits with a repeated, overlapping encoding
circuitU. The noisy channel aects the sender's encoded qubits but does not aect the receiver's
half of the shared ebits. The receiver performs overlapping measurements on both the encoded
qubits and his half of the shared ebits. These measurements produce an error syndrome which
the receiver can process to determine the most likely error. The receiver reverses the errors on
the noisy qubits from the sender. The nal decoding circuit operates on all qubits in a frame and
recovers the original stream of information qubits.
71
memory structure. The sender can perform these encoding operations in an online manner
as she places more qubits in the unencoded qubit stream.
(ii). The sender transmits her encoded qubits over the noisy quantum communication channel.
The noisy channel does not aect the receiver's half of the shared ebits.
(iii). The receiver combines the received noisy qubits with his half of the ebits and performs
measurements to diagnose errors that may occur. These measurements may overlap on
some of the same qubits.
(iv). The receiver then diagnoses errors using a classical error estimation algorithm such as Viterbi
error estimation [75] and reverses the estimates of the errors.
(v). The receiver nally performs an online decoding circuit that outputs the original information
qubit stream.
5.2 The CSS Construction
Our main theorem below allows us to import two arbitrary classical convolutional codes for use
as a CSS entanglement-assisted quantum convolutional code. Grassl and R otteler were the rst
to construct CSS quantum convolutional codes from two classical binary convolutional codes that
satisfy an orthogonality constraint|the polynomial parity check matrices H
1
(D) and H
2
(D) of
the two classical codes are orthogonal with respect to the shifted symplectic product:
H
1
(D)H
T
2
D
1
= 0: (5.1)
The resulting symplectic code has a self-orthogonal parity-check matrix when we join them to-
gether using the CSS construction. Our theorem generalizes the work of Grassl and R otteler
because we can import two arbitrary classical binary convolutional codes|the codes do not nec-
essarily have to obey the self-orthogonality constraint.
The theorem gives a direct way to compute the amount of entanglement that the code requires.
The number of ebits required is equal to the rank of a particular matrix derived from the check
matrices of the two classical codes. It generalizes the earlier theorems discussed in Section 3.6
72
that determine the amount of entanglement required for an entanglement-assisted quantum block
code.
Theorem 5.2.1 also provides a formula to compute the performance parameters of the entanglement-
assisted quantum convolutional code from the performance parameters of the two classical codes.
This formula ensures that high-rate classical convolutional codes produce high-rate entanglement-
assisted quantum convolutional codes. Our constructions also ensure high performance for the
\trade-o" and \catalytic" rates by minimizing the number of ebits that the codes require.
We begin the proof of the theorem in this section and complete it in dierent ways for each
of our two classes of entanglement-assisted quantum convolutional codes in Sections 5.3 and 5.4.
The proofs detail how to encode a stream of information qubits, ancilla qubits, and shared ebits
into a code that has the CSS structure.
Theorem 5.2.1. Let H
1
(D) and H
2
(D) be the respective check matrices corresponding to non-
catastrophic, delay-free encoders for classical binary convolutional codes C
1
and C
2
. Suppose that
classical code C
i
encodes k
i
information bits with n bits per frame where i = 1; 2. The respective
dimensions of H
1
(D) and H
2
(D) are thus (nk
1
)n and (nk
2
)n. Then the resulting
entanglement-assisted quantum convolutional code encodes k
1
+k
2
n +c information qubits per
frame and is an [[n;k
1
+k
2
n +c;c]] entanglement-assisted quantum convolutional code. The
code requires c ebits per frame where c is equal to the rank of H
1
(D)H
T
2
D
1
.
Let us begin the proof of the above theorem by constructing an entanglement-assisted quantum
convolutional code. Consider the following quantum check matrix in CSS form:
2
4
H
1
(D)
0
0
H
2
(D)
3
5
: (5.2)
We label the above matrix as a \quantum check matrix" for now because it does not necessar-
ily correspond to a commuting stabilizer. The quantum check matrix corresponds to a set of
Pauli sequences whose error-correcting properties are desirable. The Pauli sequences inherit these
desirable properties from the classical codes C
1
and C
2
.
73
The following lemma begins the proof of the above theorem. It details an initial decomposition
of the above quantum check matrix for each of our two classes of entanglement-assisted quantum
convolutional codes.
Lemma 5.2.1. Elementary row and column operations relate the quantum check matrix in (5.2)
to the following matrix
2
4
E (D) F (D)
0 0
0 0
I 0
3
5
:
where E (D) is dimension (nk
1
) (nk
2
), F (D) is (nk
1
) k
2
, the identity matrix is
(nk
2
) (nk
2
), and the null matrix on the right is (nk
2
)k
2
. We give a denition of
E (D) and F (D) in the following proof.
Proof. The Smith form [46] of H
i
(D) for each i = 1; 2 is
H
i
(D) =A
i
(D)
h
I 0
i
B
i
(D); (5.3)
whereA
i
(D) is (nk
i
)(nk
i
), the matrix in brackets is (nk
i
)n, andB
i
(D) isnn. The
Smith decomposition is somewhat analogous to the SVD decomposition of a matrix over the reals.
The binary polynomials along the diagonal of the center matrix of the Smith decomposition are
the invariant factors. The matrices A
i
(D) and B
i
(D) are a product of a sequence of elementary
row and column operations respectively [46]. Let B
ia
(D) be the rst nk
i
rows of B
i
(D) and
let B
ib
(D) be the last k
i
rows of B
i
(D):
B
i
(D) =
2
4
B
ia
(D)
B
ib
(D)
3
5
:
The (nk
i
) (nk
i
) identity matrix in brackets in (5.3) indicates that the invariant factors of
H
i
(D) for eachi = 1; 2 are all equal to one [46]. The invariant factors are all unity for both check
matrices because the check matrices correspond to noncatastrophic, delay-free encoders [46].
Premultiplying H
i
(D) by A
1
i
(D) gives a check matrix H
0
i
(D) for each i = 1; 2. Matrix
H
0
i
(D) is a check matrix for codeC
i
with equivalent error-correcting properties asH
i
(D) because
74
row operations relate the two matrices. This new check matrix H
0
i
(D) is equal to the rst nk
i
rows of matrix B
i
(D):
H
0
i
(D) =B
ia
(D):
The invariant factors ofH
1
(D)H
T
2
D
1
are equivalent to those ofH
0
1
(D)H
0T
2
D
1
because
they are related by elementary row and column operations [46]:
H
1
(D)H
T
2
D
1
=A
1
(D)H
0
1
(D)H
0T
2
D
1
A
T
2
D
1
: (5.4)
We now decompose the above quantum check matrix into a basic form using elementary row
and column operations. The row operations have no eect on the error-correcting properties of
the code, and the column operations correspond to elements of an encoding circuit. We later show
how to incorporate ebits so that the quantum check matrix forms a valid commuting stabilizer.
Perform the row operations in matricesA
1
i
(D) for both check matricesH
i
(D). The quantum
check matrix becomes
2
4
B
1a
(D)
0
0
B
2a
(D)
3
5
: (5.5)
The error-correcting properties of the above generators are equivalent to those of the generators
in (5.2) because row operations relate the two sets of generators. The matrix B
2
(D) corresponds
to a sequencefB
2;i
(D)g
l
i=1
of elementary column operations:
B
2
(D) =B
2;1
(D)B
2;l
(D) =
l
Y
i=1
B
2;i
(D):
The inverse matrixB
1
2
(D) is therefore equal to the above sequence of operations in reverse order:
B
1
2
(D) =B
2;l
(D)B
2;1
(D) =
1
Y
i=l
B
2;i
(D):
Perform the elementary column operations in B
1
2
(D) with CNOT and SWAP gates [34]. The
eect of each elementary column operationB
2;i
(D) is to postmultiply the \X" matrix byB
2;i
(D)
75
and to postmultiply the \Z" matrix byB
T
2;i
D
1
. Therefore the eect of all elementary operations
is to postmultiply the \Z" matrix by B
T
2
D
1
because
1
Y
i=l
B
T
2;i
D
1
=
l
Y
i=1
B
2;i
D
1
!
T
=B
T
2
D
1
:
The quantum check matrix in (5.5) becomes
2
4
B
1a
(D)B
T
2
D
1
0
0 0
I 0
3
5
: (5.6)
Let E (D) be equal to the rst nk
1
rows and nk
2
columns of the \Z" matrix:
E (D)B
1;a
(D)B
T
2;a
D
1
;
and let F (D) be equal to the rst nk
1
rows and last k
2
columns of the \Z" matrix:
F (D)B
1;a
(D)B
T
2;b
D
1
:
The quantum check matrix in (5.6) is then equivalent to the following matrix
2
4
E (D) F (D)
0 0
0 0
I 0
3
5
; (5.7)
where each matrix above has the dimensions stated in the theorem above.
The above operations end the initial set of operations that each of our two classes of entanglement-
assisted quantum convolutional codes employs. We outline the remaining operations for each class
of codes in what follows.
76
5.3 Codes with Finite-Depth Encoding and Decoding Cir-
cuits
This section details entanglement-assisted quantum convolutional codes in our rst class. Codes
in the rst class admit an encoding and decoding circuit that employ nite-depth operations only.
The check matrices for codes in this class have a property that allows this type of encoding and
decoding. The following lemma gives the details of this property, and the proof outlines how to
encode and decode this class of entanglement-assisted quantum convolutional codes.
Lemma 5.3.1. Suppose the Smith form of H
1
(D)H
T
2
D
1
is
H
1
(D)H
T
2
D
1
=A (D)
2
4
(D) 0
0 0
3
5
B (D);
where A (D) is an (nk
1
) (nk
1
) matrix, B (D) is an (nk
2
) (nk
2
) matrix, (D) is a
diagonal cc matrix whose entries are powers of D, and the matrix in brackets has dimension
(nk
1
)(nk
2
). Then the resulting entanglement-assisted quantum convolutional code has both
a nite-depth encoding and decoding circuit.
Proof. We begin the proof of this lemma by continuing where the proof of Lemma 5.2.1 ends. The
crucial assumption for the above lemma is that the invariant factors of H
1
(D)H
T
2
D
1
are all
powers of D. The Smith form of E (D) in (5.7) therefore becomes
A
1
1
(D)A (D)
2
4
(D) 0
0 0
3
5
B (D)A
1
2
(D);
by employing the hypothesis of Lemma 5.3.1 and (5.4). The rank of both H
1
(D)H
T
2
D
1
and
E (D) is equal to c.
Perform the inverse of the row operations inA
1
1
(D)A (D) on the rstnk
1
rows of the quan-
tum check matrix in (5.7). Perform the inverse of the column operations in matrix B (D)A
1
2
(D)
on the rstnk
2
columns of the quantum check matrix in (5.7). We execute these column oper-
ations with Hadamard, CNOT, and SWAP gates. These column operations have a corresponding
eect on columns in the \X" matrix, but we can exploit the identity matrix in the last nk
2
rows
77
of the \X" matrix to counteract this eect. We perform row operations on the last nk
2
rows
of the matrix that act as the inverse of the column operations, and therefore the quantum check
matrix in (5.7) becomes
2
6
6
6
6
6
6
4
(D) 0 F
1
(D)
0 0 F
2
(D)
0 0 0
0 0 0
0 0 0
0 0 0
I 0 0
0 I 0
3
7
7
7
7
7
7
5
;
where F
1
(D) and F
2
(D) are the rst c and nk
1
c respective rows of A
1
(D)A
1
(D)F (D).
We perform Hadamard and CNOT gates to clear the entries in F
1
(D) in the \Z" matrix above.
The quantum check matrix becomes
2
6
6
6
6
6
6
4
(D) 0 0
0 0 F
2
(D)
0 0 0
0 I 0
0 0 0
0 0 0
I 0 0
0 0 0
3
7
7
7
7
7
7
5
: (5.8)
The Smith form of F
2
(D) is
F
2
(D) =A
F
(D)
h
F
(D) 0
i
B
F
(D);
where
F
(D) is a diagonal matrix whose entries are powers of D, A
F
(D) is (nk
1
c)
(nk
1
c), and B
F
(D) is k
2
k
2
. The Smith form of F
2
(D) takes this particular form be-
cause the original check matrix H
2
(D) is noncatastrophic and column operations with Laurent
polynomials change the invariant factors only up to powers of D.
Perform row operations corresponding to A
1
F
(D) on the second set of nk
1
c rows with
F
2
(D) in (5.8). Perform column operations corresponding toB
1
F
(D) on columnsnk
2
+1;:::;n
78
with Hadamard, CNOT, and SWAP gates. The resulting quantum check matrix has the following
form:
2
6
6
6
6
6
6
4
(D) 0 0 0
0 0
F
(D) 0
0 0 0 0
0 I 0 0
0 0 0 0
0 0 0 0
I 0 0 0
0 0 0 0
3
7
7
7
7
7
7
5
: (5.9)
We have now completed the decomposition of the original quantum check matrix in (5.2) for
this class of entanglement-assisted quantum convolutional codes. It is not possible to perform
row or column operations to decompose the above matrix any further. The problem with the
above quantum check matrix is that it does not form a valid quantum convolutional code. The
rst set of rows with matrix (D) are not orthogonal under the shifted symplectic product to
the third set of rows with the identity matrix on the \X" side. Equivalently, the set of Pauli
sequences corresponding to the above quantum check matrix do not form a commuting stabilizer.
We can use entanglement shared between sender and receiver to solve this problem. Entanglement
adds columns to the above quantum check matrix to resolve the issue. The additional columns
correspond to qubits on the receiver's side. We next show in detail how to incorporate ancilla
qubits, ebits, and information qubits to obtain a valid stabilizer code. The result is that we can
exploit the error-correcting properties of the original code to protect the sender's qubits.
Consider the following check matrix corresponding to a commuting stabilizer:
2
6
6
6
6
6
6
4
I I 0 0 0
0 0 0 I 0
0 0 0 0 0
0 0 I 0 0
0 0 0 0 0
0 0 0 0 0
I I 0 0 0
0 0 0 0 0
3
7
7
7
7
7
7
5
; (5.10)
where the identity matrices in the rst and third sets of rows each have dimensioncc, the identity
matrix in the second set of rows has dimension (nk
1
c)(nk
1
c), and the identity matrix
in the fourth set of rows has dimension (nk
2
c) (nk
2
c). The rst and third sets of c
rows stabilize a set of c ebits shared between Alice and Bob. Bob possesses the \left" c qubits
and Alice possesses the \right" n qubits. The second and fourth sets of rows stabilize a set of
79
2 (nc)k
1
k
2
ancilla qubits that Alice possesses. The stabilizer therefore stabilizes a set of c
ebits, 2 (nc)k
1
k
2
ancilla qubits, and k
1
+k
2
n +c information qubits.
Observe that the last n columns of the \Z" and \X" matrices in the above stabilizer are
similar in their layout to the entries in (5.9). We can delay the rows of the above stabilizer by
an arbitrary amount to obtain the desired stabilizer. So the above stabilizer is a subcode of the
following stabilizer in the sense of Ref. [34]:
2
6
6
6
6
6
6
4
(D) (D) 0 0 0
0 0 0
F
(D) 0
0 0 0 0 0
0 0 I 0 0
0 0 0 0 0
0 0 0 0 0
I I 0 0 0
0 0 0 0 0
3
7
7
7
7
7
7
5
:
The stabilizer in (5.10) has equivalent error-correcting properties to and the same asymptotic rate
as the above desired stabilizer. The above stabilizer matrix is an augmented version of the quantum
check matrix in (5.9) that includes entanglement. The sender performs all of the encoding column
operations detailed in the proofs of this lemma and Lemma 5.2.1 in reverse order. The result of
these operations is an [[n;k
1
+k
2
n +c;c]] entanglement-assisted quantum convolutional code
with the same error-correcting properties as the quantum check matrix in (5.2). The receiver
decodes the original information-qubit stream by performing the column operations in the order
presented. The information qubits appear as the last k
1
+k
2
n +c in each frame of the stream
(corresponding to thek
1
+k
2
n+c columns of zeros in both the \Z" and \X" matrices above).
Example 5.3.1. Consider a classical convolutional code with the following check matrix:
H (D) =
h
1 +D
2
1 +D +D
2
i
:
We can use H (D) in an entanglement-assisted quantum convolutional code to correct for both
bit-
ip errors and phase-
ip errors. We form the following quantum check matrix:
2
4
1 +D
2
1 +D +D
2
0 0
0 0
1 +D
2
1 +D +D
2
3
5
: (5.11)
80
Figure 5.2: (Color online) The nite-depth encoding circuit for the entanglement-assisted quantum
convolutional code in Example 5.3.1. The above operations in reverse order give a valid decoding
circuit.
This code falls in the rst class of entanglement-assisted quantum convolutional codes because
H (D)H
T
D
1
= 1.
We do not show the decomposition of the above check matrix as outlined in Lemma 5.3.1, but
instead show how to encode it starting from a stream of information qubits and ebits. Each frame
has one ebit and one information qubit. Let us begin with a polynomial matrix that stabilizes the
unencoded state:
2
4
1 1 0
0 0 0
0 0 0
1 1 0
3
5
:
Alice possesses the two qubits on the \right" and Bob possesses the qubit on the \left." We label
the middle qubit as \qubit one" and the rightmost qubit as \qubit two." Alice performs a CNOT
81
from qubit one to qubit two in a delayed frame and a CNOT from qubit one to qubit two in a
frame delayed by two. The stabilizer becomes
2
4
1 1 0
0 0 0
0 0 0
1 1 D +D
2
3
5
:
Alice performs Hadamard gates on both of her qubits. The stabilizer becomes
2
4
1 0 0
0 1 D +D
2
0 1 0
1 0 0
3
5
:
Alice performs a CNOT from qubit one to qubit two in a delayed frame. The stabilizer becomes
2
4
1 0 0
0 D D +D
2
0 1 D
1 0 0
3
5
:
Alice performs a CNOT from qubit two to qubit one in a delayed frame. The stabilizer becomes
2
4
1 0 0
0 D 1 +D +D
2
0 1 +D
2
D
1 0 0
3
5
:
Alice performs a CNOT from qubit one to qubit two. The stabilizer becomes
2
4
1 0 0
0 1 +D
2
1 +D +D
2
0 1 +D
2
1 +D +D
2
1 0 0
3
5
:
A row operation that switches the rst row with the second row gives the following stabilizer:
2
4
0 1 +D
2
1 +D +D
2
1 0 0
1 0 0
0 1 +D
2
1 +D +D
2
3
5
:
The entries on Alice's side of the above stabilizer have equivalent error-correcting properties to
the quantum check matrix in (5.11). Figure 5.2 illustrates how the above operations encode a
stream of ebits and information qubits for our example.
82
Discussion
Codes in the rst class are more useful in practice than those in the second because their encoding
and decoding circuits are nite depth. An uncorrected error propagates only to a nite number of
information qubits in the decoded qubit stream. Codes in the rst class therefore do not require
any assumptions about noiseless encoding or decoding.
The assumption about the invariant factors in the Smith form of H
1
(D)H
T
2
D
1
holds only
for some classical check matrices. Only a subclass of classical codes satisfy this assumption, but it
still expands the set of available quantum codes beyond those whose check matrices H
1
(D) and
H
2
(D) are orthogonal. We need further techniques to handle the classical codes for which this
assumption does not hold. The following sections provide these further techniques to handle a
larger class of entanglement-assisted quantum convolutional codes.
5.4 Codes with Innite-Depth Encoding and Finite-Depth
Decoding Circuits
This section details codes whose encoding circuits have both innite-depth and nite-depth op-
erations. We therefore assume that encoding is noiseless to eliminate the possibility of encoding
errors spreading innitely into the encoded qubit stream. We later brie
y discuss the eects of
relaxing this assumption in a realistic system. Their decoding circuits require nite-depth opera-
tions only. Some of the decoding circuits are not the exact inverse of their corresponding encoding
circuits, but the decoding circuits invert the eect of the encoding circuits because they produce
the original stream of information qubits at their output.
Just as with the previous class, this class of codes is determined by the properties of their
corresponding classical check matrices, as described in the following lemma.
Lemma 5.4.1. Suppose the Smith form of E (D) does not admit the form from Lemma 5.3.1.
Then the entanglement-assisted quantum convolutional code has an encoding circuit with both
innite-depth and nite-depth operations. Its decoding circuit has nite-depth operations.
83
Proof. We perform all of the operations from Lemma 5.2.1. The Smith form ofE (D) is in general
as follows
A
E
(D)
2
6
6
6
4
1
(D) 0 0
0
2
(D) 0
0 0 0
3
7
7
7
5
B
E
(D);
where A
E
(D) is (nk
1
) (nk
1
),
1
(D) is an ss diagonal matrix whose entries are powers
of D,
2
(D) is a (cs) (cs) diagonal matrix whose entries are arbitrary polynomials, and
B
E
(D) is (nk
2
) (nk
2
). Perform the row operations inA
1
E
(D) and the column operations
inB
1
E
(D) on the quantum check matrix in (5.7). Counteract the eect of the column operations
on the identity matrix in the \X" matrix by performing row operations. The quantum check
matrix in (5.7) becomes
2
6
6
6
6
6
6
4
1
(D) 0 0 F
1
(D)
0
2
(D) 0 F
2
(D)
0 0 0 F
3
(D)
0 0 0 0
0 0
0 0
0 0
I 0
3
7
7
7
7
7
7
5
;
whereF
1
(D),F
2
(D), andF
3
(D) are the respectives,cs, andnk
1
c rows ofA
1
E
(D)F (D).
The Smith form of F
3
(D) is as follows
F
3
(D) =A
F3
(D)
h
F3
(D) 0
i
B
F3
(D);
where A
F3
(D) is (nk
1
c) (nk
1
c),
F3
(D) is an (nk
1
c) (nk
1
c) diagonal
matrix whose entries are powers of D, and B
F3
(D) is k
2
k
2
. The entries of
F3
(D) are powers
ofD because the original check matrixH
2
(D) is noncatastrophic and column and row operations
84
with Laurent polynomials change the invariant factors only by a power of D. Perform the row
operations inA
1
F3
(D) and the column operations inB
1
F3
(D). The quantum check matrix becomes
2
6
6
6
6
6
6
4
1
(D) 0 0 F
0
1a
(D) F
0
1b
(D)
0
2
(D) 0 F
0
2a
(D) F
0
2b
(D)
0 0 0
F3
(D) 0
0 0 0 0 0
0 0
0 0
0 0
I 0
3
7
7
7
7
7
7
5
;
where F
0
1a
(D), F
0
1b
(D), F
0
2a
(D), F
0
2b
(D) are the matrices resulting from the column operations
in B
1
F3
(D). Perform row operations from the entries in
F3
(D) to the rows above it to clear the
entries in F
0
1a
(D) and F
0
2a
(D). Use Hadamard and CNOT gates to clear the entries in F
0
1b
(D).
The quantum check matrix becomes
2
6
6
6
6
6
6
4
1
(D) 0 0 0 0
0
2
(D) 0 0 F
0
2b
(D)
0 0 0
F3
(D) 0
0 0 0 0 0
0 0
0 0
0 0
I 0
3
7
7
7
7
7
7
5
:
We can reduceF
0
2b
(D) to a lower triangular form with an algorithm consisting of column operations
only. The algorithm operates on the lastk
2
+k
1
n+c columns. It is similar to the Smith algorithm
but does not involve row operations. Consider the rst row ofF
0
2b
(D). Perform column operations
between the dierent elements of the row to reduce it to one non-zero entry. Swap this non-zero
entry to the leftmost position. Perform the same algorithm on elements 2;:::;k
2
+k
1
n +c of
the second row. Continue on for all rows of F
0
2b
(D) to reduce it to a matrix of the following form
F
0
2b
(D)!
h
cs
z}|{
L(D)
k1+k2n+s
z}|{
0
i
;
85
where L (D) is a lower triangular matrix. The above quantum check matrix becomes
2
6
6
6
6
6
6
4
1
(D) 0 0 0 0 0
0
2
(D) 0 0 L (D) 0
0 0 0
F3
(D) 0 0
0 0 0 0 0 0
0 0
0 0
0 0
I 0
3
7
7
7
7
7
7
5
:
We have completed decomposition of the rst set ofs rows with
1
(D), the third set ofnk
1
c
rows with
F3
(D), and rows nk
1
+ 1;:::;nk
1
+s with the identity matrix on the \X" side.
We now consider an algorithm with innite-depth operations to encode the following submatrix
of the above quantum check matrix:
2
4
2
(D) L (D)
0 0
0 0
I 0
3
5
: (5.12)
We begin with a set of cs ebits and cs information qubits. The following matrix stabilizes
the ebits
2
4
I I 0
0 0 0
0 0 0
I I 0
3
5
;
and the following matrix represents the information qubits
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
;
where all matrices have dimension (cs) (cs) and Bob possesses the cs qubits on the
\left" and Alice possesses the 2 (cs) qubits on the \right." We track both the stabilizer and
the information qubits as they progress through some encoding operations. Alice performs CNOT
and Hadamard gates on her 2 (cs) qubits. These gates multiply the middle cs columns of
the \Z" matrix by L (D) and add the result to the last cs columns and multiply the last cs
columns of the \X" matrix by L
T
D
1
and add the result to the middle cs columns. The
stabilizer becomes
2
4
I I L (D)
0 0 0
0 0 0
I I 0
3
5
;
86
and the information-qubit matrix becomes
2
4
0 0 I
0 0 0
0 0 0
0 L
T
D
1
I
3
5
:
Alice performs innite-depth operations on her rst cs qubits corresponding to the rational
polynomials
1
2;1
D
1
, :::,
1
2;cs
D
1
in
1
2
D
1
. The stabilizer matrix becomes
2
4
I
2
(D) L (D)
0 0 0
0 0 0
I
1
2
D
1
0
3
5
;
and the information-qubit matrix becomes
2
4
0 0 I
0 0 0
0 0 0
0 L
T
D
1
1
2
D
1
I
3
5
:
Alice's part of the above stabilizer matrix is equivalent to the quantum check matrix in (5.12)
by row operations (premultiplying the second set of rows in the stabilizer by
2
(D).) Bob can
therefore make stabilizer measurements that have nite weight and that are equivalent to the
desired stabilizer.
We now describe a method to decode the above encoded stabilizer and information-qubit
matrix so that the information qubits appear at the output of the decoding circuit. Bob performs
Hadamard gates on his rst and third sets of cs qubits, performs CNOT gates from the rst
set of qubits to the third set of qubits corresponding to the entries in L (D), and performs the
Hadamard gates again. The stabilizer becomes
2
4
I
2
(D) 0
0 0 0
0 0 0
I
1
2
D
1
0
3
5
; (5.13)
and the information-qubit matrix becomes
2
4
0 0 I
0 0 0
0 0 0
L
T
D
1
L
T
D
1
1
2
D
1
I
3
5
:
87
Bob nishes decoding at this point because we can equivalently express the information-qubit
matrix as follows
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
;
by multiplying the last cs rows of the stabilizer by L
T
D
1
and adding to the last cs rows
of the information-qubit matrix.
The overall procedure for encoding is to begin with a set of c ebits, 2 (nc)k
1
k
2
ancilla
qubits, andk
1
+k
2
n+c information qubits. Alice performs the innite-depth operations detailed
in the paragraph with (5.12) forcs of the ebits. Alice then performs the nite-depth operations
detailed in the proofs of this lemma and Lemma 5.2.1 in reverse order. The resulting stabilizer
has equivalent error-correcting properties to the quantum check matrix in (5.2).
The receiver decodes by rst performing all of the nite-depth operations in the encoding
circuit in reverse order. The receiver then decodes the innite-depth operations by the procedure
listed in the paragraph with (5.13) so that the original k
1
+k
2
n +c information qubits per
frame are available for processing at the receiving end.
5.4.1 Special Case with Coherent Teleportation Decoding
We now detail a special case of the above codes in this nal section. These codes are interesting
because the information qubits teleport coherently to other physical qubits when encoding and
decoding is complete.
Lemma 5.4.2. Suppose that the Smith form of F (D) in (5.7) is
F (D) =A
F
(D)
h
F
(D) 0
i
B
F
(D);
whereA
F
(D) is (nk
1
)(nk
1
),
F
(D) is an (nk
1
)(nk
1
) diagonal matrix whose entries
are powers of D, and B
F
(D) is k
2
k
2
. Then the resulting entanglement-assisted code admits an
encoding circuit with both innite-depth and nite-depth operations and admits a decoding circuit
with nite-depth operations only. The information qubits also teleport coherently to other physical
qubits for this special case of codes.
88
Proof. We perform all the operations in Lemma 5.2.1 to obtain the quantum check matrix in
(5.7). Then perform the row operations in A
1
F
(D) and the column operations in B
1
F
(D). The
quantum check matrix becomes
2
4
E
0
(D)
F
(D) 0
0 0 0
0 0 0
I 0 0
3
5
;
where E
0
(D) =A
1
F
(D)E (D). The Smith form of E
0
(D) is
E
0
(D) =A
E
0 (D)
2
6
6
6
4
1
(D) 0 0
0
2
(D) 0
0 0 0
3
7
7
7
5
B
E
0 (D);
whereA
E
0 (D) is (nk
1
) (nk
1
),
1
(D) is anss diagonal matrix whose entries are powers
of D,
2
(D) is a (cs) (cs) diagonal matrix whose entries are arbitrary polynomials, and
B
E
0 (D) is (nk
2
) (nk
2
).
Now perform the row operations in A
1
E
0 (D) and the column operations in B
1
E
0 (D). It is
possible to counteract the eect of the row operations on
F
(D) by performing column operations,
and it is possible to counteract the eect of the column operations on the identity matrix in the
\X" matrix by performing row operations. The quantum check matrix becomes
2
6
6
6
6
6
6
4
1
(D) 0 0
0
1
(D) 0 0 0
0
2
(D) 0 0
0
2
(D) 0 0
0 0 0 0 0
0
3
(D) 0
0 0 0 0 0 0 0
0 0 0
0 0 0
0 0 0
I 0 0
3
7
7
7
7
7
7
5
;
where
0
1
(D),
0
2
(D), and
0
3
(D) represent the respectivess, (cs)(cs), and (nk
1
c)
(nk
1
c) diagonal matrices resulting from counteracting the eect of row operations A
1
E
0 (D)
89
on
F
(D). We use Hadamard and CNOT gates to clear the entries in
0
1
(D). The quantum check
matrix becomes
2
6
6
6
6
6
6
4
1
(D) 0 0 0 0 0 0
0
2
(D) 0 0
0
2
(D) 0 0
0 0 0 0 0
0
3
(D) 0
0 0 0 0 0 0 0
0 0 0
0 0 0
0 0 0
I 0 0
3
7
7
7
7
7
7
5
:
The rst s rows with
1
(D) and rows nk
1
c + 1;:::;nk
1
c +s with the identity matrix
on the \X" side stabilize a set of s ebits. The nk
1
c rows with
0
3
(D) and the nk
2
c
rows with identity in the \X" matrix stabilize a set of 2 (nc)k
1
k
2
ancilla qubits (up to
Hadamard gates). The s and k
2
n +k
1
columns with zeros in both the \Z" and \X" matrices
correspond to information qubits. The decomposition of these rows is now complete.
We need to nish processing the cs rows with
2
(D) and
0
2
(D) as entries and the cs
rows of the identity in the \X" matrix. We construct a submatrix of the above quantum check
matrix:
2
4
2
(D)
0
2
(D)
0 0
0 0
I 0
3
5
: (5.14)
We describe a procedure to encode the above entries with cs ebits and cs information
qubits using innite-depth operations. Consider the following stabilizer matrix
2
4
I I 0
0 0 0
0 0 0
I I 0
3
5
; (5.15)
where all identity and null matrices are (cs)(cs). The above matrix stabilizes a set ofcs
ebits andcs information qubits. Bob's half of the ebits are thecs columns on the left in both
the \Z" and \X" matrices and Alice's half are the next cs columns. We also track the logical
operators for the information qubits to verify that the circuit encodes and decodes properly. The
information-qubit matrix is as follows
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
; (5.16)
90
where all matrices are again (cs) (cs). Alice performs Hadamard gates on her rst cs
qubits and then performs CNOT gates from her rst cs qubits to her last cs qubits to
transform (5.15) to the following stabilizer
2
4
I 0 0
0 I 0
0 I
0
2
(D)
I 0 0
3
5
:
The information-qubit matrix in (5.16) becomes
2
4
0
0
2
D
1
I
0 0 0
0 0 0
0 0 I
3
5
:
Alice then performs innite-depth operations on her last cs qubits. These innite-depth opera-
tions correspond to the elements of
1
2
(D). She nally performs Hadamard gates on her 2 (cs)
qubits. The stabilizer becomes
2
4
I I
1
2
(D)
0
2
(D)
0 0 0
0 0 0
I I 0
3
5
; (5.17)
and the information-qubit matrix becomes
2
4
0 0 0
0 0
1
2
(D)
0
0
2
D
1
2
D
1
0 0 0
3
5
: (5.18)
The stabilizer in (5.17) is equivalent to the following stabilizer by row operations (premultiplying
the rst cs rows by
2
(D)):
2
4
2
(D)
2
(D)
0
2
(D)
0 0 0
0 0 0
I I 0
3
5
: (5.19)
The measurements that Bob performs have nite weight because the row operations are multipli-
cations of the rows by the arbitrary polynomials in
2
(D). Alice thus encodes a code equivalent
to the desired quantum check matrix in (5.14) using cs ebits and cs information qubits.
91
We now discuss decoding the stabilizer in (5.17) and information qubits. Bob performs CNOTs
from the rst cs qubits to the next cs qubits. The stabilizer becomes
2
4
0 I
1
2
(D)
0
2
(D)
0 0 0
0 0 0
I 0 0
3
5
; (5.20)
and the information-qubit matrix does not change. Bob uses Hadamard and nite-depth CNOT
gates to multiply the last cs columns in the \Z" matrix by
0
2
D
1
2
(D) and add the result
to the middle cs columns. It is possible to use nite-depth operations because the entries of
0
2
(D) are all powers of D so that
0
2
D
1
=
0
1
2
(D). The stabilizer in (5.20) becomes
2
4
0 0
1
2
(D)
0
2
(D)
0 0 0
0 0 0
I 0 0
3
5
;
and the information-qubit matrix in (5.18) becomes
2
4
0 0 0
0
0
2
D
1
1
2
(D)
0
0
2
D
1
0
0 0 0
3
5
:
We premultiply the rstcs rows of the stabilizer by
0
2
D
1
and add the result to the second
cs rows of the information-qubit matrix. These row operations from the stabilizer to the
information-qubit matrix result in the information-qubit matrix having pure logical operators for
the middlecs qubits. Perform Hadamard gates on the second set of cs qubits. The resulting
information-qubit matrix is as follows
2
4
0
0
2
D
1
0
0 0 0
0 0 0
0
0
2
D
1
0
3
5
; (5.21)
so that the information qubits are available at the end of decoding. Processing may delay or
advance them with respect to their initial locations because the matrix
0
2
D
1
is diagonal with
powers of D. We can determine that the information qubits teleport coherently from the last set
of cs qubits to the second set of cs qubits in every frame by comparing (5.21) to (5.16).
92
The overall procedure for encoding is to begin with a set of c ebits, 2 (nc)k
1
k
2
ancilla
qubits, andk
1
+k
2
n+c information qubits. Alice performs the innite-depth operations detailed
in (5.14-5.19) forcs of the ebits. Alice then performs the nite-depth operations detailed in the
proofs of this lemma and Lemma 5.2.1 in reverse order. The resulting stabilizer has equivalent
error-correcting properties to the quantum check matrix in (5.2).
The receiver decodes by rst performing all of the nite-depth operations in reverse order.
The receiver then decodes the innite-depth operations by the procedure listed in (5.20-5.21) so
that the original k
1
+k
2
n +c information qubits per frame are available for processing at the
receiving end.
Example 5.4.1. Consider a classical convolutional code with the following check matrix:
H (D) =
h
1 1 +D
i
:
We can use the above check matrix in an entanglement-assisted quantum convolutional code to
correct for both bit
ips and phase
ips. We form the following quantum check matrix:
2
4
1 1 +D
0 0
0 0
1 1 +D
3
5
: (5.22)
We rst perform some manipulations to put the above quantum check matrix into a standard
form. Perform a CNOT from qubit one to qubit two in the same frame and in the next frame.
The above matrix becomes
2
4
D
1
+ 1 +D 1 +D
0 0
0 0
1 0
3
5
:
Perform a Hadamard gate on qubits one and two. The matrix becomes
2
4
0 0
1 0
D
1
+ 1 +D 1 +D
0 0
3
5
:
93
Perform a CNOT from qubit one to qubit two. The matrix becomes
2
4
0 0
1 0
D
1
+ 1 +D D
1
0 0
3
5
:
Perform a row operation that delays the rst row by D. Perform a Hadamard on both qubits.
The stabilizer becomes
2
4
1 +D +D
2
1
0 0
0 0
1 0
3
5
:
The above matrix is now in standard form. The matrix F (D) = 1 as in (5.7) so that its only
invariant factor is equal to one. The code falls into the second class of entanglement-assisted
quantum convolutional codes. We begin encoding with one ebit and one information qubit per
frame. The stabilizer matrix for the unencoded stream is as follows:
2
4
1 1 0
0 0 0
0 0 0
1 1 0
3
5
;
and the information-qubit matrix is as follows:
2
4
0 0 0
0 0 1
0 0 1
0 0 0
3
5
:
Perform a Hadamard on qubit two and a CNOT from qubit two to qubit three so that the above
stabilizer becomes
2
4
1 0 0
0 1 0
0 1 1
1 0 0
3
5
;
and the information-qubit matrix becomes
2
4
0 0 0
0 1 1
0 0 1
0 0 0
3
5
:
Perform an innite-depth operation corresponding to the rational polynomial 1=
1 +D +D
2
on
94
Figure 5.3: (Color online) The encoding and decoding circuits for the entanglement-assisted quan-
tum convolutional code in Example 5.4.1. The third series of gates in the above encoding circuit
is an innite-depth operation. The other operations in the encoding circuit are nite-depth. The
decoding circuit has nite-depth operations only.
95
qubit three. Follow with a Hadamard gate on qubits two and three. The stabilizer matrix becomes
2
4
1 1 1=
1 +D +D
2
0 0 0
0 0 0
1 1 0
3
5
; (5.23)
and the information-qubit matrix becomes
2
4
0 0 1=
1 +D +D
2
0 0 0
0 0 0
0 1 1 +D
1
+D
2
3
5
: (5.24)
Perform the nite-depth operations above in reverse order so that the stabilizer becomes
2
4
D
1 1
1+D+D
2
1+D
1+D+D
2
0 0 0
0 0 0
1 1 1 +D
3
5
;
and the information-qubit matrix becomes
2
4
0
D
1
+D
2
1+D+D
2
1
1+D+D
2
0 0 0
0 0 0
0 D
1
+D
2
D
1
3
5
:
The above stabilizer is equivalent to the desired quantum check matrix in (5.22) by a row opera-
tion that multiplies its rst row by 1 +D +D
2
.
The receiver decodes by performing the nite-depth encoding operations in reverse order and
gets the stabilizer in (5.23) and the information-qubit matrix in (5.24). The receiver performs a
CNOT from qubit one to qubit two and follows with a CNOT from qubit two to qubit three in the
same frame, in an advanced frame, and in a twice-advanced frame. Finally perform a Hadamard
gate on qubits two and three. The stabilizer becomes
2
4
0 0 0
0 0 0
0 0 1=
1 +D +D
2
0 0 0
3
5
;
96
and the information-qubit matrix becomes
2
4
0 0 0
0 1 0
0 1 1=
1 +D +D
2
0 0 0
3
5
:
The receiver decodes the information qubits successfully because a row operation from the rst row
of the stabilizer to the rst row of the information-qubit matrix gives the proper logical operators
for the information qubits. Figure 5.3 details the above encoding and decoding operations for this
entanglement-assisted quantum convolutional code.
5.4.2 Discussion
This second class of codes assumes that noiseless encoding is available. We require this assumption
because the encoding circuit employs innite-depth encoding operations.
If an error does occur during the encoding process, it can propagate innitely through the
encoded qubit stream. The result of a single encoding error can distort both the encoded quantum
information, the syndromes that result from measurements, and the nal recovery operations based
on the syndromes.
We may be able to relax the noiseless encoding assumption if nearly noiseless encoding is
available. The probability of an error would have to be negligible in order to ensure that the
probability for a catastrophic failure is negligible. One way to lower the probability of an encoding
error is to encode rst with a quantum block code and then further encode with our quantum
convolutional coding method. Many classical coding systems exploit this technique, the most
popular of which is a Reed-Solomon encoder followed by a convolutional encoder.
5.5 Closing Remarks
This chapter develops the theory of entanglement-assisted quantum convolutional coding for CSS
codes. We show several methods for importing two arbitrary classical binary convolutional codes
for use in an entanglement-assisted quantum convolutional code. Our methods outline dierent
ways for encoding and decoding our entanglement-assisted quantum convolutional codes.
97
Our rst class of codes employs only nite-depth operations in their encoding and decoding
procedures. These codes are the most useful in practice because they do not have the risk of
catastrophic error propagation. An error that occurs during encoding, measurement, recovery, or
decoding propagates only to a nite number of neighboring qubits.
Our second class of codes uses innite-depth operations during encoding. This assumption is
reasonable only if noiseless encoding is available. The method of concatenated coding is one way
to approach nearly noiseless encoding in practice.
We suggest several lines of inquiry from here. Our codes are not only useful for quantum
communication, but also should be useful for private classical communication because of the
well-known connection between a quantum channel and private classical channel [23]. It may
make sense from a practical standpoint to begin investigating the performance of our codes for
encoding secret classical messages. The commercial success of quantum key distribution [4] for
the generation of a private shared secret key motivates this investigation. It is also interesting to
determine which entanglement-assisted codes can correct for errors on the receiver's side. Codes
that possess this property will be more useful in practice.
We hope that our theory of entanglement-assisted quantum convolutional coding provides
a step in the direction of nding quantum codes that approach the ultimate capacity of an
entanglement-assisted quantum channel.
98
Chapter 6
Entanglement-Assisted Quantum Convolutional
Coding: The General Case
These patterns that anticommute,
They laugh and they think it's so cute,
Expand until t,
Then ole Gram and Schmidt,
They'll line up with a grand salute.
In this chapter, we show how to encode and decode an entanglement-assisted quantum convo-
lutional code that does not necessarily possess the CSS structure. The methods in this chapter
represent a signicant extension of our work on CSS entanglement-assisted quantum convolutional
codes in the previous chapter.
In particular, we develop a set of techniques that make the commutation relations for the
generators of a general code the same as those of entangled qubits (ebits) and ancilla qubits.
This procedure rst \expands" the check matrix for a quantum convolutional code and applies
an extended version of the symplectic Gram-Schmidt orthogonalization procedure [13] that incor-
porates the binary polynomials representing quantum convolutional codes. We then show how
to encode a stream of information qubits, ancilla qubits, and ebits to have the error-correcting
properties of the desired code. We follow by detailing the decoding circuit that Bob employs at
the receiving end of the channel. The algorithms for encoding and decoding use similar techniques
99
to those outlined in the previous chapter. The encoding circuits incorporate both nite-depth and
innite-depth operations as discussed in respective Sections 4.5 and 4.6 and the decoding circuits
incorporate nite-depth operations only.
One benet of the techniques developed in this chapter is that the quantum code designer
can produce an entanglement-assisted quantum convolutional code from a classical quaternary
convolutional code. More generally, quantum convolutional code designers now have the freedom
to design quantum convolutional codes to have desirable error-correcting properties without having
to search for codes that satisfy a restrictive commutativity constraint.
We structure this chapter as follows. In Section 6.1, we present an example that demonstrates
how to expand the check matrix of a set of quantum convolutional generators and then show
how to expand an arbitrary check matrix. We show in Section 6.2 how to compute the symplectic
Gram-Schmidt orthogonalization procedure for the example in Section 6.1 and then generalize this
procedure to work for an arbitrary set of quantum convolutional generators. The Gram-Schmidt
orthogonalization technique reduces the quantum check matrix to have the same commutation
relations as a set of ebits and ancilla qubits. This technique is essential for determining an encoding
circuit that encodes a stream of information qubits, ancilla qubits, and ebits. Section 6.3 gives
the algorithms for computing the encoding and decoding circuits for an arbitrary entanglement-
assisted quantum convolutional code. We present a detailed example in Section 6.4 that illustrates
all of the procedures in this chapter. We nish with a discussion of the practical issues involved
in using these entanglement-assisted quantum convolutional codes and present some concluding
remarks.
The focus of the next two sections is to elucidate techniques for reducing a set of quantum
convolutional generators to have the standard commutation relations in (3.2), or equivalently, the
standard symplectic relations in (3.7). The dierence between the current techniques and the
former techniques [13, 14, 82, 68] is that the current techniques operate on generators that have a
convolutional form rather than a block form. Section 6.1 shows how to expand a set of quantum
convolutional generators to simplify their commutation relations. Section 6.2 outlines a symplectic
Gram-Schmidt orthogonalization algorithm that uses binary polynomial operations to reduce the
commutation relations of the expanded generators to have the standard form in (3.7).
100
6.1 The Expansion of Quantum Convolutional Generators
We begin this section by demonstrating how to expand a particular generator that we eventually
incorporate in an entanglement-assisted quantum convolutional code. We later generalize this
example and the expansion technique to an arbitrary set of generators. This technique is important
for determining how to utilize entanglement in the form of ebits in a quantum convolutional code.
6.1.1 Example of the Expansion
Let us rst suppose that we have one convolutional generator:
I
X
Z
I
(6.1)
This generator does not yet represent a valid quantum convolutional code because it anticommutes
with a shift of itself to the left or to the right by one qubit. We are not concerned with the error-
correcting properties of this generator but merely want to illustrate the technique of expanding
it.
Let us for now consider a block version of this code that operates on eight physical qubits with
six total generators. The generators are as follows:
X
I
I
I
I
I
Z
X
I
I
I
I
I
Z
X
I
I
I
I
I
Z
X
I
I
I
I
I
Z
X
I
I
I
I
I
Z
X
I
I
I
I
I
Z
I
I
I
I
I
I
(6.2)
101
We still use the vertical bars in the above block code to denote that the frame size of the code
is one. Observe that we can view the frame size of the code as two without changing any of the
error-correcting properties of the block code:
X Z
I X
I I
I I
I I
I I
I I
Z I
X Z
I X
I I
I I
I I
I I
I I
Z I
X Z
I X
I I
I I
I I
I I
I I
Z I
: (6.3)
The frame is merely a way to organize our qubits so that we send one frame at a time over
the channel after the online encoding circuit has nished processing them. We can extend the
above block code with frame size two to have a convolutional structure with the following two
convolutional generators:
I I
I I
X Z
I X
I I
Z I
I I
I I
The above two generators with frame size two have equivalent error-correcting properties to the
original generator in (6.1) by the arguments above. We say that we have expanded the original
generator by a factor of two or that the above code is a two-expanded version of the original
generator. We can also extend the original generator in (6.1) to have a frame size of three and we
require three convolutional generators so that they have equivalent error-correcting properties to
the original generator:
I I I
I I I
I I I
X Z I
I X Z
I I X
I I I
I I I
Z I I
I I I
I I I
I I I
102
The representation of the original generator in (6.1) as a quantum check matrix in the poly-
nomial formalism is as follows:
g (D) =
h
D
1
i
: (6.4)
The two-expanded check matrix is as follows:
G
2
(D) =
2
4
0 1
D 0
1 0
0 1
3
5
; (6.5)
and the three-expanded check matrix is as follows:
G
3
(D) =
2
6
6
6
4
0 1 0
0 0 1
D 0 0
1 0 0
0 1 0
0 0 1
3
7
7
7
5
:
An alternative method for obtaining the polynomial representation of the two-expanded check
matrix consists of two steps. We rst multiply g (D) as follows:
G
0
2
(D) =
2
4
1
D
3
5
[g (D)]
2
4
1 D
1
0 0
0 0 1 D
1
3
5
:
We then \plug in" the fractional delay operator D
1=2
and apply the
ooring operationbc that
nulls the coecients of any fractional power of D:
G
2
(D) =
j
G
0
2
D
1=2
k
:
A similar technique applies to nd the check matrix of the three-expanded matrix. We rst
multiply g (D) as follows:
G
3
(D) =
2
6
6
6
4
1
D
D
2
3
7
7
7
5
[g (D)]
2
4
1
1
D
1
D
2
0 0 0
0 0 0 1
1
D
1
D
2
3
5
103
We then \plug in" the fractional delay operator D
1=3
and apply the
ooring operationbc:
G
3
(D) =
j
G
0
3
D
1=3
k
We discuss the general method for expanding an arbitrary check matrix in the next subsection.
6.1.2 General Technique for Expansion
We generalize the above example to determine how to expand an arbitrary quantum check matrix
by a factor of l. Suppose that we have an nk 2n quantum check matrix H (D) where
H (D) =
h
Z (D)
X (D)
i
:
Let D denote a diagonal matrix whose diagonal entries are the delay operator D. We take the
convention that D
0
is the identity matrix and D
m
is the matrix D multipliedm times so that its
diagonal entries are D
m
. Let R
l
(D) and C
l
(D) denote the following matrices:
R
l
(D)
h
D
0
D
1
D
l1
i
T
C
l
(D)
2
4
D
0
D
(l1)
0 0
0 0 D
0
D
(l1)
3
5
where the diagonal D matrices in R
l
(D) and C
l
(D) have respective dimensions nknk
and nn. We premultiply and postmultiply the matrix H (D) by respective matrices R
l
(D)
and C
l
(D), evaluate the resulting matrix at a fractional power 1=l of the delay operator D, and
perform the
ooring operationbc to null the coecients of any fractional power of D. The
l-expanded check matrix H
l
(D) is as follows:
H
l
(D) =
j
R
l
D
1=l
H
D
1=l
C
l
D
1=l
k
:
The l-expanded quantum check matrix H
l
(D) has equivalent error-correcting properties to the
original check matrix.
104
6.2 Polynomial Symplectic Gram-Schmidt Orthogonaliza-
tion Procedure
In general, a given set of generators may have complicated commutation relations. We have to
simplify the commutation relations so that we can encode information qubits with the help of
ancilla qubits and halves of ebits shared with the receiver. In this section, we begin with an
arbitrary set of convolutional generators. We show how to determine a set of generators with
equivalent error-correcting properties and commutation relations that are the same as those of
halves of ebits and ancilla qubits. We rst show an example of the technique by illustrating it for
Pauli sequences, for the quantum check matrix, and with the shifted symplectic product matrix.
We then state a polynomial symplectic Gram-Schmidt orthogonalization algorithm that performs
this action for an arbitrary set of quantum convolutional generators.
6.2.1 Example of the Procedure
Pauli Picture
Let us consider again our example from the previous section. Specically, consider the respective
expressions in (6.1) and (6.3) for the convolutional generator and the block code. Recall that we
can multiply the generators in a block code without changing the error-correcting properties of
the code [60]. Therefore, we can multiply the sixth generator in (6.3) to the fourth. We can then
multiply the modied fourth to the second to yield the following equivalent code:
X Z
I X
I I
I I
I I
I I
I I
Z X
X Z
I X
I I
I I
I I
Z X
I I
Z X
X Z
I X
I I
Z I
I I
Z I
I I
Z I
(6.6)
105
We have manipulated the two-expanded matrix rather than the code in (6.2) because the com-
mutation relations of the above code are equivalent to the commutation relations of the following
operators:
I Z
I X
I I
I I
I I
I I
I I
I I
I Z
I X
I I
I I
I I
I I
I I
I I
I Z
I X
I I
I I
I I
I I
I I
I I
:
We can use three ebits to encode the set of generators in (6.6) because they have the same
commutation relations as the above operators and the above operators correspond to halves of
three ebits. We resolve the anticommutation relations by using the following entanglement-assisted
code:
Z X Z
X I X
I I I
I I I
I I I
I I I
I I I
I Z X
Z X Z
X I X
I I I
I I I
I I I
I Z X
I I I
I Z X
Z X Z
X I X
I I I
I Z I
I I I
I Z I
I I I
I Z I
The convention above is that the rst qubit of each frame belongs to Bob and corresponds to
half of an ebit. The second two qubits of each frame belong to Alice. The overall code forms
a commuting stabilizer so that it corresponds to a valid quantum code. Bob could measure the
106
above operators to diagnose errors or he could measure the following operators that are equivalent
by row operations:
Z X Z
X I X
I I I
I I I
I I I
I I I
I I I
X Z I
Z X Z
X I X
I I I
I I I
I I I
I I I
I I I
I Z I
Z X Z
X I X
I I I
I I I
I I I
I I I
I I I
I Z I
One can check that the operators corresponding to the second two qubits of each frame are
equivalent to the desired generators in (6.3).
Polynomial Picture
Let us consider the convolutional generator in (6.1). We now use the polynomial formalism because
it is easier to perform the manipulations for general codes in this picture rather than in the Pauli
picture.
We extend the row operations from the above block code to the polynomial picture. Each row
operation multiplied the even-numbered generators by themselves shifted by two qubits. Extending
this operation to act on an innite Pauli sequence corresponds to multiplying the second generator
in (6.5) by the rational polynomial 1= (1 +D). Consider the two-expanded check matrix with the
operation described above applied to the second generator:
2
4
g
1
(D)
g
2
(D)
3
5
=
2
4
0 1
D
1+D
0
1 0
0
1
1+D
3
5
;
The shifted symplectic products (g
1
g
1
) (D) = 0, (g
1
g
2
) (D) = 1, and (g
2
g
2
) (D) = 0
capture the commutation relations of the resulting code for all frames. We can therefore resolve
this anticommutativity by prepending a column that corresponds to Bob possessing half of an
ebit:
2
4
1 0 1
0
D
1+D
0
0 1 0
1 0
1
1+D
3
5
:
107
Bob possesses the qubit corresponding to column one of both the \Z" and \X" matrix and Alice
possesses the two qubits corresponding to the second and third columns. The code above has
equivalent error-correcting properties to those of the desired generators.
The generators in the above polynomial setting correspond to Pauli sequences with innite
weight. Innite-weight generators are undesirable because Bob cannot measure an innite number
of qubits. There is a simple solution to this problem and it is similar to what we did at the end
of the previous subsection. We multiply the second row of the above check matrix by 1 +D to
obtain the following check matrix that has equivalent error-correcting properties to the above one:
2
4
1 0 1
0 D 0
0 1 0
1 +D 0 1
3
5
:
Bob can measure operators that have nite weight because the above check matrix corresponds
to Pauli sequences with nite weight.
Shifted Symplectic Product Matrix Picture
We can also determine the row operations that simplify the commutation relations by looking
only at the shifted symplectic product matrix. It is easier to determine the row operations that
resolve anticommutativity by considering the shifted symplectic product matrix. We would like to
perform row operations to reduce the shifted symplectic product matrix to the standard form in
(3.7) so that it has commutation relations equivalent to those of halves of ebits and ancilla qubits.
The shifted symplectic product matrix corresponding to the check matrix in (6.4) is a one-
element matrix
g
(D) where
g
(D) =
D
1
+D
:
It is clear that
g
(D) is not reducible by row operations to the 2 2 matrix J in (3.5) because
g
(D) is a one-element matrix. It is also not reducible to the one-element null matrix [0] because
there is no valid row operation that can zero out the term D
1
+D.
108
We therefore consider the two-expanded check matrix in (6.5) to determine if we can reduce it
with row operations to the standard form in (3.7). The shifted symplectic product matrix
G2
(D)
for the two-expanded check matrix G
2
(D) is as follows:
G2
(D) =
2
4
0 1 +D
1
1 +D 0
3
5
We can formulate the row operation of multiplying the second generator by 1= (1 +D) as a matrix
R (D) where
R (D) =
2
4
1 0
0 1= (1 +D)
3
5
:
The eect on the matrix
G2
(D) is to change it to
R (D)
G2
(D)R
T
D
1
=J
as described in (4.39). The above matrix J has equivalent commutation relations to half of an
ebit. We can therefore use one ebit per two qubits to encode this code.
In a later section, we show how to devise encoding circuits beginning from c ebits per frame
and a ancilla qubits per frame and also give the algorithm for their online decoding circuits. It
is important for us right now to devise a procedure to reduce the commutation relations of any
check matrix to those of ebits and ancilla qubits.
6.2.2 The Procedure for General Codes
We detail a polynomial version of the symplectic Gram-Schmidt orthogonalization procedure in
this section. It is a generalized version of the procedure we developed for the above example.
Before detailing the algorithm, we rst prove a lemma that shows how to determine the shifted
symplectic product matrix for anl-expanded version of the generators by starting from the shifted
symplectic product matrix of the original generators.
109
The Shifted Symplectic Product Matrix for an l-Expanded Code
Lemma 6.2.1. Suppose the shifted symplectic product matrix
(D) of a given check matrixH (D)
is as follows:
(D) =Z (D)X
T
D
1
+X (D)Z
T
D
1
:
The shifted symplectic product matrix
l
(D) of the l-expanded check matrix H
l
(D) is as follows:
l
(D) =
j
R
l
D
1=l
D
1=l
R
T
l
D
1=l
k
where the
ooring operationbc nulls the coecients of any fractional power of D.
Proof. Consider that the \X" matrix X
l
(D) of the l-expanded check matrix H
l
(D) is as follows:
X
l
(D) =
j
R
l
D
1=l
X
D
1=l
C
0
l
D
1=l
k
;
where
C
0
l
D
1=l
h
D
0
D
1
D
(l1)
i
;
and each diagonal D matrix is nn-dimensional. It is also then true that the \Z" matrix of
H
l
(D) is as follows:
Z
l
(D) =
j
R
l
D
1=l
Z
D
1=l
C
0
l
D
1=l
k
:
The matrix transpose operation, the time reversal operation (substitutingD
1
forD), and matrix
addition are all invariant under the
ooring operationbc for arbitrary matricesM (D) andN (D):
j
M
T
D
1=l
k
=
j
M
D
1=l
k
T
;
j
M
D
1=l
k
=
j
M
D
1=l
k
D=D
1
;
j
M
D
1=l
+N
D
1=l
k
=
j
M
D
1=l
k
+
j
N
D
1=l
k
:
Additionally, the following property holds for two arbitrary binary polynomials f (D) and g (D):
j
f
D
1=l
g
D
1=l
k
=
l1
X
i=0
j
D
i=l
f
D
1=l
kj
D
i=l
g
D
1=l
k
: (6.7)
110
Now consider the product X
l
(D)Z
T
l
D
1
:
X
l
(D)Z
T
l
D
1
=
j
R
l
D
1=l
X
D
1=l
C
0
l
D
1=l
kj
R
l
D
1=l
Z
D
1=l
C
0
l
D
1=l
k
T
D=D
1
=
j
R
l
D
1=l
X
D
1=l
C
0
l
D
1=l
kj
C
0T
l
D
1=l
Z
T
D
1=l
R
T
l
D
1=l
k
=
l1
X
i=0
j
D
i=l
R
l
D
1=l
X
D
1=l
kj
D
i=l
Z
T
D
1=l
R
T
l
D
1=l
k
=
j
R
l
D
1=l
X
D
1=l
Z
T
D
1=l
R
T
l
D
1=l
k
;
where the second line uses the invariance of the
ooring operation with respect to matrix transpo-
sition and time reversal, the third line expands the matrix multiplications using the matrix C
0
l
(D)
dened above, and the last line uses the matrix generalization of the multiplication property de-
ned in (6.7). Our nal step is to use the invariance of the
ooring operation with respect to
matrix addition:
l
(D) =X
l
(D)Z
T
l
D
1
+Z
l
(D)X
T
l
D
1
=
j
R
l
D
1
l
X
D
1
l
Z
T
D
1
l
R
T
l
D
1
l
k
+
j
R
l
D
1
l
Z
D
1
l
X
T
D
1
l
R
T
l
D
1
l
k
=
j
R
l
D
1
l
X
D
1
l
Z
T
D
1
l
R
T
l
D
1
l
+R
l
D
1
l
Z
D
1
l
X
T
D
1
l
R
T
l
D
1
l
k
=
j
R
l
D
1=l
D
1=l
R
T
l
D
1=l
k
:
The Gram-Schmidt Procedure
We now present the polynomial symplectic Gram-Schmidt orthogonalization procedure that re-
duces the commutation relations of a given set of convolutional generators to have the standard
form in (3.7).
Consider the following nk 2n-dimensional quantum check matrix H (D):
H (D) =
h
Z (D)
X (D)
i
:
Label each row as h
i
(D) =
h
z
i
(D)
x
i
(D)
i
for all i2f1;:::;nkg.
111
We state the Gram-Schmidt procedure in terms of its eect on the shifted symplectic product
matrix. It is easier to see how the algorithm proceeds by observing the shifted symplectic product
matrix rather than by tracking the generators in the check matrix.
Letl denote the amount by which we expand the check matrixH (D). Suppose rst thatl = 1
(we do not expand the check matrix). Let us say that the check matrix has r generators (we take
a number dierent from nk because the number of generators may not be equal to nk for
future iterations). There are the following possibilities:
(i). There is a generator h
i
(D) such that (h
i
h
j
) (D) = 0 for all j2f1;:::;rg. In this case,
the generator is already decoupled from all the others and corresponds to an ancilla qubit
because an ancilla and it share the same commutation relations. Swap h
i
(D) to be the rst
row of the matrix so that it is h
1
(D). The shifted symplectic product matrix then has the
form:
2
6
6
6
6
6
6
6
4
0 0 0
0 h
2;2
h
2;r
.
.
.
.
.
.
.
.
.
.
.
.
0 h
r;2
h
r;r
3
7
7
7
7
7
7
7
5
=
h
0
i
2
6
6
6
6
4
h
2;2
h
2;r
.
.
.
.
.
.
.
.
.
h
r;2
h
r;r
3
7
7
7
7
5
where [0] is the one-element zero matrix and we use the shorthand h
i;j
= (h
i
h
j
) (D). We
remove generator h
1
(D) from check matrix H (D) and continue to step two below for the
remaining generators in the matrix.
(ii). There are two generators h
i
(D) and h
j
(D) for which (h
i
h
j
) (D) =D
m
for some integer
m and (h
i
h
i
) (D) = (h
j
h
j
) (D) = 0. In this case these generators correspond exactly
to half of an ebit. Multiply generator h
j
(D) by D
m
. This row operation has the eect of
delaying (or advancing) the generator by an amount m and changes the shifted symplectic
product to be (h
i
h
j
) (D) = 1. These two generators considered by themselves now have
the commutation relations of half of an ebit. Swap the generators h
i
(D) and h
j
(D) to be
112
the rst and second respective rows of the check matrixH (D). Call themh
1
(D) andh
2
(D)
respectively. The shifted symplectic product matrix is then as follows:
2
6
6
6
6
6
6
6
6
6
6
4
0 1 h
1;3
h
1;r
1 0 h
2;3
h
2;r
h
3;1
h
3;2
h
3;3
h
3;r
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
h
r;2
h
r;2
h
r;3
h
r;r
3
7
7
7
7
7
7
7
7
7
7
5
:
We use the following row operations to decouple the other generators from these two gener-
ators:
h
0
i
(D)h
i
(D) + [(h
i
h
2
) (D)]h
1
(D) + [(h
i
h
1
) (D)]h
2
(D) for all i2f3;:::;rg:
The shifted symplectic product matrix becomes as follows under these row operations:
2
6
6
6
6
6
6
6
6
6
6
4
0 1 0 0
1 0 0 0
0 0 h
0
3;3
h
0
3;r
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
0 0 h
0
r;3
h
0
r;r
3
7
7
7
7
7
7
7
7
7
7
5
=
h
J
i
2
6
6
6
6
4
h
0
3;3
h
0
3;r
.
.
.
.
.
.
.
.
.
h
0
r;3
h
0
r;r
3
7
7
7
7
5
:
The rst two generators are now decoupled from the other generators and have the commu-
tation relations of half of an ebit. We remove the rst two generators from the check matrix
so that it now consists of generatorsh
0
3
(D),:::,h
0
r
(D). We check to see if the conditions at
the beginning of the previous step or this step hold for any other generators. If so, repeat
the previous step or this step on the remaining generators. If not, see if the conditions for
step three hold.
(iii). There are two generators h
i
(D) and h
j
(D) for which (h
i
h
i
) (D) = (h
j
h
j
) (D) = 0
but (h
i
h
j
) (D)6= D
m
for all m and (h
i
h
j
) (D)6= 0. Multiply generator h
j
(D) by
113
1= (h
j
h
i
) (D). Generator h
j
(D) becomes innite weight because (h
j
h
i
) (D) is a poly-
nomial with two or more powers ofD with non-zero coecients. Now the shifted symplectic
product relations are as follows: (h
i
h
i
) (D) = (h
j
h
j
) (D) = 0 and (h
i
h
j
) (D) = 1.
We handle this case as we did the previous case after the two generators there had the
commutation relations of half of an ebit.
(iv). None of these conditions hold. In this case, we stop this iteration of the algorithm and
expand the check matrix by the next factor l :=l + 1 and repeat the above steps.
We have not proven that this procedure converges on all codes; however, it does converge on
all the codes we have tried. We conjecture that this procedure converges for all codes, but even
if this is true, in principle it might require expansion to a large number of generators. A simple
and practical convergence condition is as follows. In practice, convolutional codes do not act on
an innite stream of qubits but instead act on a nite number of qubits. It may be that there
are codes for which this procedure either does not converge or must be expanded until the frame
size of the expanded code exceeds the number of qubits that the code acts on. In this case, we
would not employ this procedure, and instead would treat the code as a block code, where we
could employ the methods from Refs. [14, 13] for encoding and decoding. It is unclear if this
practical convergence condition will ever really be necessary. This procedure does converge for a
large number of useful codes, so that the frame size of the expanded code is much less than the
number of qubits that the code acts on, and we have not found an example where this procedure
fails.
6.3 Encoding and Decoding Circuits
This section proves the main theorem of this chapter. The theorem assumes that we have al-
ready processed an arbitrary check matrix with the Gram-Schmidt algorithm and that the shifted
symplectic product matrix corresponding to the processed check matrix has the standard form in
(3.7). The theorem shows how to encode a set of information qubits, ancilla qubits, and halves
of ebits into a code that has equivalent error-correcting properties to those of a desired set of
convolutional generators. The theorem uses both nite-depth and innite-depth operations in the
encoding circuit and nite-depth operations in the decoding circuit.
114
Theorem 6.3.1. Suppose we have a set of quantum convolutional generators in the nk 2n-
dimensional matrix H (D) where
H (D) =
h
Z (D)
X (D)
i
:
Its shifted symplectic product matrix
(D) is as follows:
(D) =Z (D)X
T
D
1
+X (D)Z
T
D
1
:
Suppose check matrixH (D) is the matrix resulting from processing with the polynomial symplectic
Gram-Schmidt orthogonalization procedure. Therefore,
(D) has the standard form in (3.7) with
parameters c and a = nk 2c. Then there exists an online encoding circuit for the code that
uses nite-depth and innite-depth operations in the shift-invariant Cliord group and there exists
an online decoding circuit for the code that uses nite-depth operations. The code encodes k +c
information qubits per frame with the help of c ebits and a =nk 2c ancilla qubits.
Proof. We prove the theorem by giving an algorithm to compute both the encoding circuit and
the decoding circuit. The shifted symplectic product matrix
(D) for check matrix H (D) is in
standard form so that the rst 2c rows have the commutation relations ofc halves of ebits and the
lasta rows have the commutation relations of a ancilla qubits. Perform the algorithm outlined in
Refs. [35, 34] on the last a generators that correspond to the ancilla qubits. The algorithm uses
nite-depth CNOT gates, Hadamard gates, and phase gates. The resulting check matrix has the
following form:
2
4
Z
00
(D) Z
0
(D)
(D) 0
0 X
0
(D)
0 0
3
5
; (6.8)
where the matrixZ
00
(D) and the null matrix at the top left of the \X" matrix each have dimension
2ca, the matricesZ
0
(D) andX
0
(D) each have dimension 2cna, and all matrices in the second
set of rows each have a rows. The matrix (D) may have entries that are rational polynomials.
If so, replace each of these entries with a \1" so that the resulting matrix has the following form:
2
4
Z
00
(D) Z
0
(D)
I 0
0 X
0
(D)
0 0
3
5
:
115
This replacement is equivalent to taking a subcode of the original that has equivalent error-
correcting properties and rate [34]. We can also think of the replacement merely as row operations
with rational polynomials. We then perform row operations from the last a rows to the rst 2c
rows to obtain the following check matrix:
2
4
0 Z
0
(D)
I 0
0 X
0
(D)
0 0
3
5
:
The shifted symplectic product matrix still has the standard form in (3.7) because these last row
operations do not change its entries. We now focus exclusively on the rst 2c rows because the
previous steps decoupled the lasta rows from the rst 2c rows. Consider the following submatrix:
H
0
(D) =
h
Z (D)
X (D)
i
;
where we have reset variable labels so that Z (D) = Z
0
(D) and X (D) = X
0
(D). Perform row
permutations on the above matrix so that the shifted symplectic product matrix forH
0
(D) changes
from
c
M
i=1
J;
to become
2
4
0 I
I 0
3
5
; (6.9)
where each identity and null matrix in the above matrix are cc-dimensional. We can employ
the algorithm from Ref. [35] on the rst c generators because the rst c rows of the resulting
check matrix form a commuting set (we do not use the row operations in that algorithm). The
algorithm employs nite-depth CNOT gates, Hadamard gates, and phase gates and reduces the
check matrix to have the following form:
2
4
0 0
U (D) Z
2
(D)
L (D) 0
X
1
(D) X
2
(D)
3
5
;
116
where L (D) is a cc lower triangular matrix and U (D) is a cc upper triangular matrix. The
i
th
diagonal entry u
ii
(D) of U (D) is equal to 1=l
ii
D
1
where l
ii
(D) is the i
th
diagonal entry
of L (D). This relationship holds because of the shifted symplectic relations in (6.9) and because
gates in the shift-invariant Cliord group do not aect the shifted symplectic relations. We now
employ several row operations whose net eect is to preserve the shifted symplectic relations
in (6.9)|we can therefore include them as a part of the original polynomial symplectic Gram-
Schmidt orthogonalization procedure. Multiply row i of the above check matrix by 1=l
ii
(D) and
multiply row i +c by 1=u
ii
(D) for all i2f1;:::;cg. Then use row operations to cancel all the
o-diagonal entries in both L (D) and U (D). The resulting check matrix has the following form:
2
4
0 0
I Z
0
2
(D)
I 0
X
0
1
(D) X
0
2
(D)
3
5
;
where the primed matrices result from all the row operations. One can check that the shifted
symplectic relations of the above matrix are equivalent to those in (6.9). Perform Hadamard gates
on the rst c qubits. The check matrix becomes
2
4
I 0
X
0
1
(D) Z
0
2
(D)
0 0
I X
0
2
(D)
3
5
: (6.10)
We show how to encode the above matrix starting from c ebits andk +c information qubits. The
following matrix stabilizes a set of c ebits:
2
4
I I 0
0 0 0
0 0 0
I I 0
3
5
; (6.11)
where each identity matrix iscc and the last column of zeros in each matrix is c (k +c). The
receiver Bob possesses the rstc qubits and the sender Alice possesses the lastk + 2c qubits. The
following matrix is the information-qubit:
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
117
where each identity matrix is (k +c) (k +c) and each column of zeros is (k +c)c. It is
important to track the information-qubit matrix throughout encoding and decoding so that we
can determine at the end of the process if we have truly decoded the information qubits. Perform
nite-depth CNOT operations from the rstc ebits to the lastk+c qubits to encode the numerators
of the entries in matrix Z
0
2
(D). Let Z
0
2;N
(D) denote this matrix of the numerators of the entries
in Z
0
2
(D). The stabilizer matrix becomes
2
4
I I 0
0 0 0
0 0 0
I I Z
0
2;N
(D)
3
5
;
and the information-qubit matrix becomes
2
4
0 Z
00
2;N
(D) I
0 0 0
0 0 0
0 0 I
3
5
;
where Z
00
2;N
(D) is the matrix that results on the \Z" side after performing the CNOT operations
corresponding to the entries in Z
0
2;N
(D). Perform Hadamard gates on the last k +c qubits. The
stabilizer matrix becomes
2
4
I I 0
0 0 Z
0
2;N
(D)
0 0 0
I I 0
3
5
;
and the information-qubit matrix becomes
2
4
0 Z
00
2;N
(D) 0
0 0 I
0 0 I
0 0 0
3
5
:
LetX
0
2;N
(D) denote the matrix whose entries are the numerators of the entries inX
0
2
(D). Perform
CNOT gates from the rstc qubits to the lastk+c qubits corresponding to the entries inX
0
2;N
(D).
The stabilizer matrix becomes
2
4
I I 0
0 A (D) Z
0
2;N
(D)
0 0 0
I I X
0
2;N
(D)
3
5
;
118
where A (D) = Z
0
2;N
(D)X
00
2;N
(D) and X
00
2;N
(D) is the matrix that results on the \Z" side after
performing the CNOT operations on the \X" side corresponding to the entries in X
0
2;N
(D). The
information-qubit matrix becomes
2
4
0 Z
00
2;N
(D) 0
0 X
00
2;N
(D) I
0 0 I
0 0 0
3
5
:
Let (D) be a diagonal matrix whose i
th
diagonal entry is the denominator of the i
th
row of
Z
0
2
(D) and X
0
2
(D). We perform innite-depth operations corresponding to the entries in (D).
The stabilizer matrix becomes
2
4
I
1
D
1
0
0 A (D) Z
0
2;N
(D)
0 0 0
I (D) X
0
2;N
(D)
3
5
;
and the information-qubit matrix becomes
2
4
0 Z
00
2;N
(D)
1
D
1
0
0 X
00
2;N
(D)
1
D
1
I
0 0 I
0 0 0
3
5
:
The above stabilizer matrix is equivalent to the desired one in (6.10) by several row operations.
We premultiply the rst set of rows by
D
1
and multiply the second set of rows by
1
(D).
We can also use the resulting identity matrix in the rst set of rows to perform row operations
from the rst set of rows to the second set of rows to realize the matrix X
0
1
(D). The operators
that Bob would really measure need to have nite weight so he would measure the operators
corresponding to the entries in the following stabilizer matrix:
2
4
D
1
I 0
0 A (D) Z
0
2;N
(D)
0 0 0
I (D) X
0
2;N
(D)
3
5
: (6.12)
We are done with the encoding algorithm. Alice begins with a set of ebits and performs the
encoding operations detailed in (6.11-6.12) and then performs the nite-depth operations detailed
in (6.8-6.10) in reverse order. We now detail the steps of the decoding algorithm. Perform CNOT
119
gates corresponding to the entries inX
0
2;N
(D) from the rst set ofc qubits to the last set ofk +c
qubits. The stabilizer matrix becomes
2
4
I
1
D
1
0
B (D) A (D) Z
0
2;N
(D)
0 0 0
I (D) 0
3
5
;
where B (D)Z
0
2;N
(D)X
00
2;N
(D). The information-qubit matrix becomes
2
4
0 Z
00
2;N
(D)
1
D
1
0
X
00
2;N
(D) X
00
2;N
(D)
1
D
1
I
0 0 I
0 0 0
3
5
:
Perform Hadamard gates on the last set of k +c qubits. The stabilizer matrix becomes
2
4
I
1
D
1
0
B (D) A (D) 0
0 0 0
I (D) Z
0
2;N
(D)
3
5
;
and the information-qubit matrix becomes
2
4
0 Z
00
2;N
(D)
1
D
1
I
X
00
2;N
(D) X
00
2;N
(D)
1
D
1
0
0 0 0
0 0 I
3
5
:
Perform CNOT gates from the rst set of c qubits to the last set of k +c qubits. These CNOT
gates correspond to the entries in Z
0
2;N
(D). The stabilizer matrix becomes
2
4
I
1
D
1
0
B (D) A (D) 0
0 0 0
I (D) 0
3
5
;
and the information-qubit matrix becomes
2
4
Z
00
2;N
(D) Z
00
2;N
(D)
1
D
1
I
X
00
2;N
(D) X
00
2;N
(D)
1
D
1
0
0 0 0
0 0 I
3
5
:
120
Row operations from the rst set of rows of the stabilizer to each of the two sets of rows in the
information-qubit matrix reduce the information-qubit matrix to the following form:
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
:
Then we perform the nite-depth operations detailed in (6.8-6.10). We have now nished the
algorithm for the decoding circuit because the logical operators for the information qubits appear
in their original form.
6.3.1 Discussion
Similar practical issues arise in these circuits as we discussed in the previous chapter. Encoding
circuits with innite-depth operations are acceptable if we assume that noiseless encoding is pos-
sible. Otherwise, innite-depth operations could lead to catastrophic propagation of uncorrected
errors. Noiseless encoding is dicult to achieve in practice but we may be able to come close to
it by concatenation of codes at the encoder.
There is a dichotomy of these codes similar to that in the previous chapter. Some of the codes
may have a simpler form in which the encoding circuit requires nite-depth operations only. These
codes fall within the rst class of codes discussed in the previous chapter and will be more useful
in practice because they propagate errors in the encoding circuit to a nite number of qubits only.
The remaining codes that do not have this structure fall within the second class of codes whose
encoding circuits have both nite-depth and innite-depth operations and whose decoding circuits
have nite-depth operations only.
6.3.2 Importing Classical Convolutional Codes over GF (4)
One benet of the new entanglement-assisted quantum convolutional codes is that we can produce
one from an arbitrary classical convolutional code over GF (4). The error-correcting properties of
the classical convolutional code translate to the resulting quantum convolutional code. It is less
clear how the rate translates because we use the expansion technique. We know that the term
(2kn)=n lower bounds the \entanglement-assisted" rate wheren andk are the parameters from
121
the imported classical code. The rate should get a signicant boost from entanglement|the rate
boosts by the number of ebits that the code requires.
The construction for importing an [n;k] classical convolutional code over GF (4) is as follows.
Suppose the check matrix for the classical code is an nkn-dimensional matrix H (D) whose
entries are polynomials overGF (4). We construct the quantum check matrix
~
H (D) according to
the following formula:
~
H (D) =
0
@
2
4
!H (D)
!H (D)
3
5
1
A
where
denotes the isomorphism between elements of GF (4) and symplectic binary vectors de-
tailed in (3.38). We use this construction for the example in the next section.
6.4 Example
We take the convolutional generators from Ref. [82] as our example. Ref. [14] originally used these
generators in a block code. We import the following classical convolutional code over GF (4):
(j0000j1 !10j1101j0000j ): (6.13)
We produce two quantum convolutional generators by multiplying the above generator by ! and
! and applying the map in (3.38). The resulting quantum convolutional generators are as follows:
(jIIIIjZXZIjZZIZjIIIIj ); (jIIIIjXYXIjXXIXjIIIIj ):
These generators have the following representation in the polynomial formalism:
2
4
1 +D D 1 D
0 1 0 0
0 1 0 0
1 +D 1 +D 1 D
3
5
:
The shifted symplectic product matrix
(D) for the above code is as follows:
(D) =
2
4
D +D
1
D
1
D D +D
1
3
5
:
122
The above matrix is not reducible to the standard form by any row operations. We therefore
expand the code by a factor of two to give four generators with a frame size of eight. The two-
expanded check matrix H (D) is as follows:
H (D) =
2
6
6
6
6
6
6
4
1 0 1 0 1 1 0 1
0 1 0 0 0 0 0 0
D D 0 D 1 0 1 0
0 0 0 0 0 1 0 0
0 1 0 0 0 0 0 0
1 1 1 0 1 1 0 1
0 0 0 0 0 1 0 0
D D 0 D 1 1 1 0
3
7
7
7
7
7
7
5
:
The shifted symplectic product matrix
2
(D) of the two-expanded check matrix is as follows:
2
(D) =
2
6
6
6
6
6
6
4
0 0 1 +D
1
D
1
0 0 1 1 +D
1
1 +D 1 0 0
D 1 +D 0 0
3
7
7
7
7
7
7
5
:
We proceed with the Gram-Schmidt procedure because this matrix satises its initial requirements.
We swap generators two and three to be the rst and second generators of the check matrix because
they have the commutation relations of half of an ebit. The shifted symplectic product matrix
becomes
2
6
6
6
6
6
6
4
0 1 0 1 +D
1
1 0 1 +D 0
0 1 +D
1
0 D
1
1 +D 0 D 0
3
7
7
7
7
7
7
5
:
Multiply generator two by 1 +D and add to generator four. Multiply generator one by 1 +D
1
and add to generator three. The shifted symplectic matrix becomes
2
6
6
6
6
6
6
4
0 1 0 0
1 0 0 0
0 0 0 1 +D
1
+D
2
0 0 1 +D +D
2
0
3
7
7
7
7
7
7
5
:
123
We nally divide generator four by 1 +D +D
2
and the shifted symplectic product matrix then
becomes
2
M
i=1
J,
so that it has the commutation relations of halves of two ebits. The check matrix resulting from
these operations is as follows:
H
2
(D) =
h
Z
2
(D)
X
2
(D)
i
; (6.14)
where
Z
2
(D) =
2
6
6
6
6
6
6
4
0 1 0 0 0 0 0 0
D D 0 D 1 0 1 0
1
1
D
+ 1 1 0 1 1 0 1
D
2
+D
D
2
+D+1
D
2
+D
D
2
+D+1
0
D
2
+D
D
2
+D+1
D+1
D
2
+D+1
1
D
2
+D+1
D+1
D
2
+D+1
0
3
7
7
7
7
7
7
5
;
X
2
(D) =
2
6
6
6
6
6
6
4
1 1 1 0 1 1 0 1
0 0 0 0 0 1 0 0
1
D
+ 1
1
D
1
D
+ 1 0
1
D
+ 1
1
D
+ 1 0
1
D
+ 1
D
D
2
+D+1
D
D
2
+D+1
0
D
D
2
+D+1
1
D
2
+D+1
D
D
2
+D+1
1
D
2
+D+1
0
3
7
7
7
7
7
7
5
:
The error-correcting properties of the above check matrix are equivalent to the error-correcting
properties of the original two generators.
This code sends six information qubits and consumes two ebits per eight channel uses. The
rate pair for this code is therefore (3=4; 1=4).
We can now apply the algorithm in Theorem 6.3.1 to determine the encoding and decoding
circuits for this code. The encoding circuit begins from a set of two ebits and eight information
qubits per frame with the following stabilizer matrix:
H
0
(D) =
2
6
6
6
6
6
6
4
1 0 1 0 0 0 0 0 0 0
0 1 0 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0
1 0 1 0 0 0 0 0 0 0
0 1 0 1 0 0 0 0 0 0
3
7
7
7
7
7
7
5
:
124
We label the eight qubits on the right side of each matrix above as 1;:::; 8. We label Bob's two
qubits on the left asB1 andB2. Perform the following nite-depth operations (in order from left
to right and then top to bottom):
C
1; 4;D +D
2
C
1; 5; 1 +D
2
C (1; 6; 1)C (1; 7; 1 +D)C (2; 4;D)C (2; 5; 1 +D)C (2; 6; 1)
H (3;:::; 8)C
1; 4;D +D
2
+D
4
C
1; 5;D
2
C (1; 6; 1 +D)C
1; 7;D
2
C
2; 4;D +D
2
C (2; 5; 1 +D)C (2; 6; 1)C (2; 7; 1 +D)
where we use the notationC (q
1
;q
2
;f (D)) to represent a nite-depth CNOT gate from qubit one
to qubit two that implements the polynomialf (D),H (q
i
;:::;q
j
) is a sequence of Hadamard gates
applied to qubits q
i
through q
j
in each frame, P (q) is a phase gate applied to qubit q in each
frame, and C (q; 1=f (D)) is an innite-depth CNOT gate implementing the rational polynomial
1=f (D) on qubit q. Alice performs the following innite-depth operations:
H (1; 2)C
1;
1
1 +D
1
+D
2
C
2;
1
1 +D
1
+D
2
H (1; 2):
She then nishes the encoding circuit with the following nite-depth operations:
H (1; 2)C (2; 3; 1)C (2; 5; 1)C (2; 6; 1)C (2; 8; 1)P (2)H (3;:::; 8)S (2; 3) (6.15)
C (1; 2; 1)C (1; 3; 1)C (1; 5; 1)C (1; 6; 1)C (1; 8; 1)P (2)
The code she encodes has equivalent error-correcting properties to the check matrix in (6.14).
Bob performs the following operations in the decoding circuit. He rst performs the operations
in (6.15) in reverse order. He then performs the following nite-depth operations:
C
B1; 4;D +D
2
+D
4
C
B1; 5;D
2
C (B1; 6; 1 +D)C
B1; 7;D
2
C
B2; 4;D +D
2
C (B2; 5; 1 +D)C (B2; 6; 1)C (B2; 7; 1 +D)H (3;:::; 8)
C
B1; 4;D +D
2
C
B1; 5; 1 +D
2
C (B1; 6; 1)C (B1; 7; 1 +D)C (B2; 4;D)
C (B2; 5; 1 +D)C (B2; 6; 1)
125
The information qubits then appear at the output of this online decoding circuit.
6.5 Optimal Entanglement Formulas
We conjecture two formulas for the optimal number of ebits that a general (non-CSS) entanglement-
assisted quantum convolutional code or one imported from a classical quaternary convolutional
code need to consume per frame of operation. We show that this conjecture holds for a particular
example.
Conjecture 6.5.1. The optimal number c of ebits necessary per frame for an entanglement-
assisted quantum convolutional code is
c = rank
H
X
(D)H
T
Z
(D
1
) +H
Z
(D)H
T
X
(D
1
)
=2 (6.16)
where H(D) =
h
H
Z
(D)
H
X
(D)
i
represents the parity check matrix for a set of quantum
convolutional generators that do not necessarily form a commuting set.
It is clear that the above formula holds after we have expanded an original set of generators
and their commutation relations are reducible by the polynomial symplectic Gram-Schmidt or-
thogonalization procedure to the standard form in (3.7). The proof technique follows from the
proof technique outlined in Section 3.6. But we are not sure how to apply this formula to an
initial set of unexpanded generators.
Conjecture 6.5.2. The optimal numberc of ebits required per frame for an entanglement-assisted
quantum convolutional code imported from a classical quaternary convolutional code with parity
check matrix H (D) is
c = rank
H(D)H
y
(D
1
)
: (6.17)
We know the number of ebits required for a CSS entanglement-assisted quantum convolutional
code is rank
H
1
(D)H
T
2
(D
1
)
where H
1
(D) and H
2
(D) correspond to the classical binary con-
volutional codes that we import to correct respective bit and phase
ips. Comparing the CSS
convolutional formula, the CSS block formula in Corollary 3.6.1, and the general block formula in
Theorem 3.6.1, the above conjecture seems natural.
126
We nally provide an example of the above conjecture. It is a slight modication of the code
presented in Ref. [80].
Example 6.5.1. Consider the quantum convolutional code with quantum check matrix as follows:
2
6
6
6
6
6
6
6
6
6
6
4
0 0 0 0 0
h (D) D 0 1 h (D)
0 0 D D D
0
1
D
1
1
D
0
0
1
D
0 0 0
h (D) 0 D 1 h (D)
0 0 0 0 0
0 1 0 1 1
0 0 0 0 0
0 0 1 0 0
3
7
7
7
7
7
7
7
7
7
7
5
;
whereh (D) = 1 +D. This code requires two ebits and one ancilla qubit for quantum redundancy
and encodes two information qubits. The shifted symplectic product matrix H
X
(D)H
T
Z
(D
1
) +
H
Z
(D)H
T
X
(D
1
) [82, 76] for this code is as follows:
2
6
6
6
6
6
6
6
6
6
6
4
0 1 0 0 0
1 0 0 0 0
0 0 0 0 0
0 0 0 0 1
0 0 0 1 0
3
7
7
7
7
7
7
7
7
7
7
5
(6.18)
The rank of the above matrix is four and the code requires two ebits. Therefore, the conjecture
holds for this example.
6.6 Closing Remarks
There are several dierences between the methods used for general, non-CSS codes discussed in
this chapter and the CSS codes used in the previous chapter. It was more straightforward to
determine how to use ebits eciently in CSS entanglement-assisted quantum convolutional codes,
but we have had to introduce the expansion technique in Section 6.1 in order to determine how to
use ebits eciently for codes in this chapter. There was also no need for an explicit Gram-Schmidt
orthogonalization procedure in the previous chapter. The Smith algorithm implicitly produced
the row operations necessary for symplectic orthogonalization.
127
We do have some methods in the next chapter that do not require expansion of a check
matrix or an explicit Gram-Schmidt procedure but these methods do not make ecient use of
entanglement and have a lower rate of quantum communication and higher rate of entanglement
consumption than the codes discussed in this chapter. Nonetheless, we have determined ways to
make these other codes more useful by encoding classical information in the extra entanglement
with a superdense-coding-like eect [10]. These other codes are grandfather codes in the sense of
Refs. [80, 48] because they consume entanglement to send both quantum and classical information.
We discuss these techniques in the next chapter.
One negative implication of the expansion of a code is that the expanded code requires more
qubits per frame. The expanded code then requires a larger buer at both the sender's and
receiver's local stations. The increased buer will be a concern right now because it is dicult to
build large quantum memories. This issue will become less of a concern as quantum technology
advances. The entanglement-inecient codes in the next chapter have the advantage that they
do not require expansion and thus require smaller buers. It therefore should be of interest
to nd solutions in between the entanglement-ecient codes discussed in this chapter and the
entanglement-inecient codes discussed in the previous paragraph.
Some outstanding issues remain. We have not proven the convergence of the polynomial sym-
plectic Gram-Schmidt orthogonalization procedure and have instead provided a practical stopping
condition. We have a conjecture for how to proceed with proving convergence. Suppose that we
would like to construct a code consisting of one generator that does not commute with shifts of
itself. We have found for many examples that the correct expansion factor for the generator is
equal to the period of the inverse polynomial of the generator's shifted symplectic product. We
do not have a proof that this factor is the correct one and we are not sure what the expansion
factor should be when we would like to construct a code starting from more than one generator.
The techniques developed in this chapter represent a useful way for encoding quantum infor-
mation. This framework will most likely lead to codes with reasonable performance but they will
most likely not come close to achieving the quantum capacity of an entanglement-assisted channel.
The next step should be to combine the theory in this chapter with Poulin et al.'s recent theory of
quantum serial-turbo coding [65]. This combination might lead to entanglement-assisted quantum
turbo codes that come close to achieving capacity.
128
Chapter 7
Entanglement-Assisted Quantum Convolutional
Coding: Free Entanglement
Sometimes we've a free cater,
Perhaps on the house we've a waiter,
But free entanglement you say?
Not a price to pay?
Oh assume it for now and pay later.
We mentioned in the previous chapter that the expansion of a set of quantum convolutional
generators increases the frame size of a code. This increase implies that each round of transmission
in the protocol sends a larger number of encoded qubits and requires a larger quantum memory
for its operation. Thus increasing the frame size is somewhat undesirable.
We oer the \free-entanglement" codes in this chapter as an alternative option to the codes
in the previous chapter. The free-entanglement codes have a basic generator set that includes
an arbitrary set of Pauli sequences. The free-entanglement codes consume more entanglement
than is necessary and have a lower quantum information rate, but the benet is that they do not
require a larger quantum memory for each round of transmission. It is up to the quantum coding
engineer to decide which option is more desirable for the particular coding application: using
less entanglement and having a higher rate of quantum transmission or using a smaller quantum
memory to send fewer qubits for each round of transmission.
129
We make the additional assumption that shared entanglement is freely available. Quantum
information theorists make the \free entanglement" assumption when deriving the entanglement-
assisted capacity of a quantum channel [8, 9]. This model makes sense when the sender and
receiver can use the noisy channel and entanglement distillation protocols [6, 7] during o-peak
times to generate a large amount of noiseless entanglement.
The \entanglement-assisted" rate (Section 3.3) of a quantum code is the ratio of the number
of encoded information qubits to the number of physical qubits assuming that entanglement is
available for free. The entanglement-assisted rate of our codes is at least k=n. Parameterk is the
number of information qubits that the code encodes and parametern is the number of qubits used
for encoding. A basic set of nk generators species all of our entanglement-assisted quantum
convolutional codes and yields the above entanglement-assisted rate.
We say that the entanglement-assisted rate is at least k=n because the example in Section 7.2
discusses a method to boost the rate. This method encodes some classical information into the
extra entanglement along the lines of the \grandfather" coding technique discussed in the next
chapter and in Ref. [48]. The sender can use this classical information and the entanglement to
teleport [5] additional information qubits and increase the rate of quantum transmission.
7.1 Construction
The proof of our main theorem below outlines how to encode a stream of information qubits,
ancilla qubits, and shared ebits so that the encoded qubits have the error-correcting properties of
an arbitrary set of Paulis. The receiver may employ an error estimation algorithm such as Viterbi
decoding [75] to determine the most likely errors that the noisy quantum communication channel
induces on the encoded stream. We then show how to decode the encoded qubit stream so that
the information qubits become available at the receiving end of the channel.
The encoding circuits in the proof of our theorem employ both nite-depth and innite-depth
operations. The decoding circuits employ nite-depth operations only. Innite-depth operations
can lead to catastrophic error propagation as discussed in previous chapters. In our proof below,
we restrict innite-depth operations to act on qubits before sending them over the noisy channel.
130
Catastrophic error propagation does not occur under the ideal circumstance when the operations
in the encoding circuit are noiseless.
Our theorem below begins with a \quantum check matrix" that consists of a set of Pauli
sequences with desirable error-correcting properties. This quantum check matrix does not neces-
sarily correspond to a commuting stabilizer. The proof of the theorem shows how to incorporate
ebits so that the sender realizes the same quantum check matrix for her qubits and the sender and
receiver's set of generators form a valid commuting stabilizer.
Theorem 7.1.1. Suppose the following quantum check matrix
S (D) =
h
Z (D)
X (D)
i
2F
2
[D]
(nk)2n
;
where S (D) is of full rank and does not necessarily form a commuting stabilizer and F
2
[D] is
the eld of binary polynomials. Then an entanglement-assisted quantum convolutional code exists
that has the same error-correcting properties as the above quantum check matrix S (D). The
entanglement-assisted rate of the code is at least k=n.
Proof. Suppose that the Smith form [46] of X (D) is as follows
X (D) =A (D)
2
6
6
6
4
1
(D) 0 0
0
2
(D) 0
0 0 0
3
7
7
7
5
B (D); (7.1)
whereA (D) is (nk) (nk),B (D) isnn,
1
(D) is anss diagonal matrix whose entries
are powers of D, and
2
(D) is a (cs) (cs) diagonal matrix whose entries are arbitrary
polynomials. Perform the row operations in A
1
(D) and the column operations in B
1
(D) on
S (D). The quantum check matrix S (D) becomes
2
6
6
6
4
E (D)
1
(D) 0 0
0
2
(D) 0
0 0 0
3
7
7
7
5
; (7.2)
131
where E (D) = A
1
(D)Z (D)B
T
D
1
. Suppose E
1
(D) is the rst c columns of E (D) and
E
2
(D) is the next nc columns of E (D) so that the quantum check matrix is as follows:
2
6
6
6
4
E
1
(D) E
2
(D)
1
(D) 0 0
0
2
(D) 0
0 0 0
3
7
7
7
5
: (7.3)
Perform Hadamard gates on the last nc qubits so that the quantum check matrix becomes
2
6
6
6
4
E
1
(D) 0
1
(D) 0 E
2;1
(D)
0
2
(D) E
2;2
(D)
0 0 E
2;3
(D)
3
7
7
7
5
; (7.4)
where
E
2
(D) =
2
6
6
6
4
E
2;1
(D)
E
2;2
(D)
E
2;3
(D)
3
7
7
7
5
: (7.5)
Perform CNOT operations from the rst s qubits to the last nc qubits to clear the entries in
E
2;1
(D). The quantum check matrix becomes
2
6
6
6
4
E
1
(D) 0
1
(D) 0 0
0
2
(D) E
2;2
(D)
0 0 E
2;3
(D)
3
7
7
7
5
: (7.6)
The Smith form of E
2;3
(D) is as follows
E
2;3
(D) =A
E
(D)
h
(D) 0
i
B
E
(D); (7.7)
whereA
E
(D) is (nkc)(nkc),B
E
(D) is (nc)(nc), and (D) is a (nkc)
(nkc) diagonal matrix whose entries are polynomials. The Smith form of E
2;3
(D) is full
132
rank because the original quantum check matrix S (D) is full rank. Perform the row operations
in A
1
E
(D) and the column operations in B
1
E
(D). The quantum check matrix becomes
2
6
6
6
4
E
0
1
(D) 0
1
(D) 0 0 0
0
2
(D) E
0
2;2a
(D) E
0
2;2b
(D)
0 0 (D) 0
3
7
7
7
5
; (7.8)
where
E
0
1
(D) =
2
4
I 0
0 A
1
E
(D)
3
5
E
1
(D); (7.9)
E
0
2;2
(D) =E
2;2
(D)B
1
E
(D) =
h
E
0
2;2a
(D) E
0
2;2b
(D)
i
: (7.10)
Perform a modied version of the Smith algorithm to reduce the (cs)(nc) matrixE
0
2;2b
(D)
to a lower triangular form (discussed in Chapter 5). This modied algorithm uses only column
operations to transform
E
0
2;2b
(D)!
h
L (D) 0
i
; (7.11)
whereL (D) is (cs) (cs) and the null matrix is (cs) (n +s 2c). The quantum check
matrix becomes
2
6
6
6
4
E
0
1
(D) 0
1
(D) 0 0 0 0
0
2
(D) E
0
2;2a
(D) L (D) 0
0 0 (D) 0 0
3
7
7
7
5
: (7.12)
We have now completed the decomposition of the quantum check matrix with column and row
operations.
We turn to showing how to encode and decode a certain quantum check matrix that proves
to be useful in encoding the above quantum check matrix. Consider the following quantum check
matrix
2
4
I 0
0 0
0 0
2
(D) L (D)
3
5
; (7.13)
133
where
2
(D) andL (D) are from the matrix in (7.12) and each of them, the identity matrix, and
the null matrices have dimension (cs) (cs). We use a method for encoding and decoding
the quantum check matrix in (7.13) similar to the method in Chapter 5 for the second class of
CSS entanglement-assisted quantum convolutional codes. We begin with a set of cs ebits and
cs information qubits. The following matrix stabilizes the ebits
2
4
I I 0
0 0 0
0 0 0
I I 0
3
5
; (7.14)
where Bob possesses the cs qubits on the \left," Alice possesses the 2 (cs) qubits on the
\right," and each matrix is (cs) (cs). The following matrix represents the information
qubits:
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
: (7.15)
The above information-qubit matrix represents the logical operators for the information qubits
and gives a useful way of tracking the information qubits while processing them. Tracking the
information-qubit matrix helps to conrm that the information qubits decode properly at the
receiver's end [76]. We track both the above stabilizer and the information-qubit matrix as they
progress through some encoding operations. Alice then performs CNOT gates from her rst cs
qubits to her next cs qubits. These gates multiply the middle cs columns of the \X" matrix
by L (D) and add the result to the last cs columns and multiply the last cs columns of the
\Z" matrix by L
T
D
1
and add the result to the last cs columns. The stabilizer becomes
2
4
I I 0
0 0 0
0 0 0
I I L (D)
3
5
; (7.16)
and the information-qubit matrix becomes
2
4
0 L
T
D
1
I
0 0 0
0 0 0
0 0 I
3
5
: (7.17)
134
Alice performs innite-depth operations on her rst cs qubits corresponding to the rational
polynomials
1
2;1
D
1
, :::,
1
2;cs
D
1
in
1
2
D
1
. These operations multiply the middle
cs columns of the \Z" matrix by
1
2
D
1
and multiply the middle cs columns of the \X"
matrix by
2
(D). The stabilizer matrix becomes
2
4
I
1
2
D
1
0
0 0 0
0 0 0
I
2
(D) L (D)
3
5
; (7.18)
and the information-qubit matrix becomes
2
4
0 L
T
D
1
1
2
D
1
I
0 0 0
0 0 0
0 0 I
3
5
: (7.19)
Alice's part of the above stabilizer matrix is equivalent to the quantum check matrix in (7.13) by
row operations (premultiplying the rst set of rows by
2
D
1
.)
We now illustrate a way to decode the encoded stabilizer in (7.18) and information-qubit
matrix in (7.19) so that the information qubits appear at the output of the decoding circuit. Bob
performs CNOT gates from the rst set of qubits to the third set of qubits corresponding to the
entries in L (D). The stabilizer becomes
2
4
I
1
2
D
1
0
0 0 0
0 0 0
I
2
(D) 0
3
5
; (7.20)
and the information-qubit matrix becomes
2
4
L
T
D
1
L
T
D
1
1
2
D
1
I
0 0 0
0 0 0
0 0 I
3
5
: (7.21)
Bob nishes decoding at this point because we can equivalently express the information-qubit
matrix as follows
2
4
0 0 I
0 0 0
0 0 0
0 0 I
3
5
; (7.22)
135
by multiplying the rstcs rows of the stabilizer byL
T
D
1
and adding to the rstcs rows
of the information-qubit matrix. The information qubits are available at the receiving end of the
channel because the above information-qubit matrix is equivalent to the original one in (7.15).
We show how to encode the quantum check matrix in (7.12) using ebits, ancilla qubits, and
information qubits. We employ the encoding technique for the submatrix listed above and use
some other techniques as well. Suppose that we have the following matrix that stabilizes a set of
c ebits per frame, nkc ancilla qubits per frame, and k information qubits per frame:
2
6
6
6
6
6
6
6
6
6
6
4
I 0 I 0 0 0 0
0 I 0 I 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
I 0 I 0 0 0 0
0 I 0 I 0 0 0
0 0 0 0 I 0 0
3
7
7
7
7
7
7
7
7
7
7
5
: (7.23)
The rst and third sets of rows have s rows and correspond to s ebits per frame, the second and
fourth sets of rows have cs rows and correspond to cs ebits per frame, and the last set of
nkc rows corresponds to nkc ancilla qubits per frame. The above matrix has n +c
columns on both the \Z" and \X" side so that the above matrix stabilizes k information qubits
per frame. Bob possesses the rst c qubits and Alice possesses the next n qubits. Alice performs
the encoding operations in (7.14-7.19) to get the following stabilizer:
2
6
6
6
6
6
6
6
6
6
6
4
I 0 I 0 0 0 0
0 I 0
1
2
D
1
0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
I 0 I 0 0 0 0
0 I 0
2
(D) 0 L (D) 0
0 0 0 0 I 0 0
3
7
7
7
7
7
7
7
7
7
7
5
: (7.24)
We perform several row operations to get the quantum check matrix in (7.12). Premultiply the
middle set of rows by
1
(D). Premultiply the last set of rows by E
0
2;2a
(D) and add the result to
the set of rows above the last set. Premultiply the last set of rows by (D). Finally, premultiply
136
the rst two sets of rows by E
00
1
(D) =E
0
1
(D)
I
2
D
1
and add the result to the last three
sets of rows. The quantum check matrix becomes
2
6
6
6
6
6
6
6
6
6
6
4
I 0 I 0 0 0 0
0 I 0
1
2
D
1
0 0 0
0 0 0
E
00
1
(D) E
0
1
(D) 0 0 0
0 0 0
0 0 0 0 0 0 0
0 0 0 0 0 0 0
1
(D) 0
1
(D) 0 0 0 0
0 I 0
2
(D) E
0
2;2a
(D) L (D) 0
0 0 0 0 (D) 0 0
3
7
7
7
7
7
7
7
7
7
7
5
:
(7.25)
Alice's part of the above quantum check matrix and the last three sets of rows are equivalent
to the quantum check matrix in (7.12). Alice then performs all nite-depth encoding operations
(column operations) in (7.1-7.12) in reverse order to obtain the desired quantum check matrix in
the statement of the theorem. Decoding consists of performing all the operations in (7.1-7.12) and
then applying the decoding operations in (7.20-7.22). The entanglement-assisted rate of the above
code is k=n because the code uses a noisy quantum communication channel n times per frame to
send k information qubits per frame.
7.2 Example
We now present an example that begins with the same generators as those in the example from
the previous chapter. We begin with the following two Pauli generators:
(jIIIIjZXZIjZZIZjIIIIj ); (jIIIIjXYXIjXXIXjIIIIj ):
We write the above two generators as a quantum check matrix:
2
4
1 +D D 1 D
0 1 0 0
0 1 0 0
1 +D 1 +D 1 D
3
5
(7.26)
137
We encode two information qubits per frame with the help of two ebits. The stabilizer matrix for
the unencoded qubit stream is as follows:
2
6
6
6
6
6
6
4
0 1 1 0 0 0
1 0 0 1 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 1 1 0 0 0
1 0 0 1 0 0
3
7
7
7
7
7
7
5
(7.27)
Rows one and three correspond to one ebit and rows two and four correspond to the other.
Multiply row one by D and add the result to row three, multiply row one by 1 +D
1
+D
2
and
add the result to row four, and multiply row two by 1+D
2
and add the result to row four. These
row operations give the following equivalent stabilizer:
2
6
6
6
6
6
6
4
0 1 1 0 0 0
1 0 0 1 0 0
0 D D 0 0 0
1 +D
2
1 +D
1
+D
2
1 +D
1
+D
2
1 +D
2
0 0
0 0 0 0 0 0
0 0 0 0 0 0
0 1 1 0 0 0
1 0 0 1 0 0
3
7
7
7
7
7
7
5
: (7.28)
Figure 7.1 illustrates the operations that transform the unencoded stabilizer to the encoded one
in an online encoding circuit. The nal stabilizer is as follows
2
6
6
6
6
6
6
4
0 1 0 1 0 0
1 0 0 0 0 0
0 D 1 +D D 1 D
1 +D
2
D
1
+ 1 +D 0 1 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 1 0 1 0 0
1 0 1 +D 1 +D 1 D
3
7
7
7
7
7
7
5
:
Compare Alice's Paulis in the last two rows of the above matrix to the quantum check matrix
in (7.26). We have constructed a code with the same error-correcting properties because these
two matrices are equivalent. The entanglement-assisted rate of the above code is 1/2 because it
encodes two information qubits for every four uses of the noisy quantum channel.
138
Figure 7.1: (Color online) An online encoding circuit for an entanglement-assisted quantum con-
volutional code. The receiver Bob possesses the rst two qubits in the two ebits and the sender
Alice possesses the second two qubits in the two ebits. The sender encodes two information qubits
per frame with the help of her half of the two ebits.
139
Consider the following two operators:
2
4
0 0 D
1
1 +D +D
2
0 0
0 0 0 1 +D
2
0 0
0 0 1 0 0 0
0 0 0 1 0 0
3
5
:
The rst row anticommutes with the rst row in (7.28) and commutes with all other rows in
(7.28). The second row anticommutes with the second row in (7.28) and commutes with all
other rows in (7.28). These commutation relations imply that the above operators are useful for
encoding classical information in a superdense-coding-like fashion. These operators encode two
classical bits into the code and make use of the rst two rows in (7.28) instead of just \wasting"
them. Measuring the rst two rows in (7.28) reveals the values of the two classical bits. We can
determine the encoded versions of these \classical-information-encoding" operators by tracing how
the operators change in the Heisenberg picture through the rest of the encoding circuit. We can
use these two classical bits and consume one ebit to teleport an additional information qubit. This
technique boosts the entanglement-assisted rate of this code from 1=2 to 3=4 because we can now
encode three information qubits for every four uses of the noisy quantum communication channel.
7.3 Closing Remarks
The \free entanglement" approach of this chapter uses entanglement less eciently than the
protocol in the previous chapter. It does not require expanding a set of generators and therefore
does not require a heuristic convergence argument as do the codes of the previous chapter. The
free entanglement method always works and results in encoding and decoding circuits that act on
smaller numbers of qubits than the circuits in the previous chapter.
140
Chapter 8
Unied Quantum Convolutional Coding
\Never chase after a bus, a girl, or a unifying theory.
There'll always be another one coming along."
|John Archibald Wheeler (1911{2008)
In this chapter, we design a framework for \grandfather" quantum convolutional codes. Our
grandfather codes are useful for the simultaneous transmission of classical and quantum informa-
tion. Rather than using block codes for this purpose, we design quantum convolutional codes.
Our technique incorporates many of the known techniques for quantum coding: subsystem codes
[49, 64], entanglement-assisted codes [14], convolutional codes [62, 34, 29], and classical-quantum
mixed coding [26, 11, 48]. The goal of our technique is to provide a formalism for designing codes
that approach the optimal triple trade-o rates in the grandfather resource inequality in (1.5).
We structure this chapter as follows. Section 8.1 details our \grandfather" quantum convolu-
tional codes. We explicitly show how to encode a stream of classical-quantum information using
nite-depth operations and discuss the error-correcting properties of our codes. We end with an
example of a grandfather quantum convolutional code. We discuss which errors the code corrects
actively and others that it corrects passively.
Kremsky, Hsieh, and Brun address the formulation of grandfather block codes in Ref. [48].
141
8.1 Grandfather Quantum Convolutional Codes
We detail the stabilizer formalism for our grandfather quantum convolutional codes and describe
how they operate. This formalism is a signicant extension of the entanglement-assisted formalism.
An [n;k;l;r;c] grandfather quantum convolutional code encodes k information qubits and l
information classical bits with the help of c ebits,a =nklcr ancilla qubits, andr gauge
qubits. Each input frame includes the following:
(i). Alice's half of c ebits in the statej
+
i.
(ii). a =nkclr ancilla qubits in the statej0i.
(iii). r gauge qubits (which can be in any arbitrary state ).
(iv). l classical information bits x
1
x
l
, given by a computational basis statejxi =X
x
1
X
x
l
j0i
l
.
(v). k information qubits in a statej i.
y
The left side of Figure 8.1 shows an example initial qubit stream before an encoding circuit
operates on it.
The stabilizer matrix S
0
(D) for the initial qubit stream is as follows:
S
0
(D) =
2
6
6
6
4
I I 0 0 0 0
0 0 0 0 0 0
0 0 I 0 0 0
0 0 0 0 0 0
I I 0 0 0 0
0 0 0 0 0 0
3
7
7
7
5
; (8.1)
where all identity matrices in the rst two sets of rows are cc, the identity matrix in the last
row is aa, the three columns of all zeros in both the \Z" and \X" matrices are respectively
(a + 2c)r, (a + 2c)l, and (a + 2c)k. The rst two sets of rows stabilize a set of c ebits and
the last set of rows stabilize a set ofa ancilla qubits. The rstc columns of both the \Z" and \X"
matrix correspond to halves of ebits that Bob possesses and the last n columns in both matrices
correspond to the qubits that Alice possesses.
y
This statement is not entirely true because the information qubits can be entangled across multiple frames, or
with an external system, but we use it to illustrate the idea.
142
Dierent generators for the grandfather code are important in active error correction, in passive
error correction, and for the identication of the l classical information bits. We rst write the
unencoded generators that act on the initial qubit stream. The rst subgroup of generators is the
entanglement subgroupS
E;0
with the following generators:
S
E;0
(D) =
2
4
I 0 0 0 0
0 0 0 0 0
0 0 0 0 0
I 0 0 0 0
3
5
: (8.2)
The above generators are equivalent to the rst two sets of rows in (8.1) acting on Alice'sn qubits.
The next subgroup is the isotropic subgroupS
I;0
with the following generators:
S
I;0
(D) =
h
0 I 0 0 0
0 0 0 0 0
i
: (8.3)
The above generators are equivalent to the last set of rows in (8.1) acting on Alice's n qubits.
The encoded versions of both of the above two matrices are important in the active correction of
errors. The next subgroup is the gauge subgroupS
G;0
whose generators are as follows:
S
G;0
(D) =
2
4
0 0 I 0 0
0 0 0 0 0
0 0 0 0 0
0 0 I 0 0
3
5
: (8.4)
The generators inS
G;0
correspond to quantum operations that have no eect on the encoded
quantum information and therefore represent a set of errors to which the code is immune. The
last subgroup is the classical subgroupS
C;0
with generators
S
C;0
(D) =
h
0 0 0 I 0
0 0 0 0 0
i
: (8.5)
The grandfather code passively corrects errors corresponding to the encoded version of the above
generators because the initial qubit stream is immune to the action of operators inS
C;0
(up to a
global phase). Alice could measure the generators inS
C;0
to determine the classical information in
each frame. Unlike quantum information, it is possible to measure classical information without
disturbing it.
143
Alice performs an encoding circuit with nite-depth operations to encode her stream of qubits
before sending them over the noisy quantum channel. The encoding circuit transforms the initial
stabilizer S
0
(D) to the encoded stabilizer S (D) as follows:
S (D) =
2
6
6
6
4
I Z
E1
(D)
0 Z
E2
(D)
0 Z
I
(D)
0 X
E1
(D)
I X
E2
(D)
0 X
I
(D)
3
7
7
7
5
; (8.6)
where Z
E1
(D), X
E1
(D), Z
E2
(D) and X
E2
(D) are cn-dimensional, Z
I
(D) and X
I
(D) are
an-dimensional. The encoding circuit aects only the rightmost n entries in both the \Z" and
\X" matrix of S
0
(D) because these are the qubits in Alice's possession. It transforms S
E;0
(D),
S
I;0
(D), S
G;0
(D), and S
C;0
(D) as follows:
S
E
(D) =
2
4
Z
E1
(D)
Z
E2
(D)
X
E1
(D)
X
E2
(D)
3
5
; S
I
(D) =
h
Z
I
(D)
X
I
(D)
i
; (8.7)
S
G
(D) =
2
4
Z
G1
(D)
Z
G2
(D)
X
G1
(D)
X
G2
(D)
3
5
; S
C
(D) =
h
Z
C
(D)
X
C
(D)
i
; (8.8)
where Z
G1
(D), X
G1
(D), Z
G2
(D) and X
G2
(D) are rn-dimensional and Z
C
(D) and X
C
(D)
are ln-dimensional. The above polynomial matrices have the same commutation relations
as their corresponding unencoded polynomial matrices in (8.2-8.5) and respectively generate the
entanglement subgroupS
E
, the isotropic subgroupS
I
, the gauge subgroupS
G
, and the classical
subgroupS
C
.
A grandfather quantum convolutional code operates as follows.
(i). Alice begins with an initial qubit stream as above. She performs the nite-depth encoding
operations corresponding to a specic grandfather quantum convolutional code.
(ii). She sends the encoded qubits online over the noisy quantum communication channel. The
code passively protects against errors inhS
I
;S
G
;S
C
i.
(iii). Bob combines the received qubits with his half of the ebits in each frame. He obtains the
error syndrome by measuring the generators in (8.6). He processes these syndrome bits with
144
a classical error estimation algorithm to diagnose errors and applies recovery operations to
reverse the errors.
(iv). He then performs the inverse of the encoding circuit to recover the initial qubit stream
with the information qubits and the classical information bits. He recovers the classical
information bits either by measuring the generators inS
C
before decoding or the generators
inS
C;0
after decoding.
A grandfather quantum convolutional code corrects errors in a Pauli error setE that obey one
of the following conditions8E
a
;E
b
2E:
9 g2hS
I
;S
E
i :
g;E
y
a
E
b
= 0 or E
y
a
E
b
2hS
I
;S
G
;S
C
i:
It corrects errors that anticommute with generators inhS
I
;S
E
i by employing a classical error
estimation algorithm. The code passively protects against errors in the grouphS
I
;S
G
;S
C
i.
Our scheme for quantum convolutional coding incorporates many of the known techniques for
quantum error correction. It can take full advantage of the benets of these dierent techniques.
8.2 Example
We present an example of a grandfather quantum convolutional code in this section. The code
protects one information qubit and classical bit with the help of an ebit, an ancilla qubit, and a
gauge qubit. The rst frame of input qubits has the state
0
=
+
+
j0ih0j
0
jx
0
ihx
0
j
j
0
ih
0
j; (8.9)
wherej
+
i is the ebit,j0i is the ancilla qubit,
0
is an arbitrary state for the gauge qubit,jx
0
i is a
classical bit represented by statej0i orj1i, andj
0
i is one information qubit equal to
0
j0i+
0
j1i.
The states of the other input frames have a similar form though recall that information qubits
can be entangled across multiple frames.
145
Figure 8.1: (Color online) The encoding circuit for the grandfather quantum convolutional code
in our example. Each frame i has an ebitj
+
i
BA
shared between Bob and Alice, a fresh ancilla
qubitj0i
A
, a gauge qubit
A
i
, an information classical bitjx
i
i
A
, and an information qubitj
i
i
A
.
Bob's qubits are blue and Alice's qubits are red. Including the ebit and an ancilla qubit implies
that the code incorporates active quantum error correction. Including the gauge qubit implies
that the code has passive quantum error correction. The code provides passive error correction
of phase errors on the classical bit. Alice encodes her classical bits and qubits using the encoding
circuit above. The decoding circuit consists of the above operations in reverse order.
146
The initial stabilizer for the code is as follows:
S
0
(D) =
2
6
6
6
4
1 1 0 0 0 0
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 0 0 0
1 1 0 0 0 0
0 0 0 0 0 0
3
7
7
7
5
:
The rst two rows stabilize the ebit shared between Alice and Bob. Bob possesses the half of the
ebit in column one and Alice possesses the half of the ebit in column two in both the left and right
matrix. The third row stabilizes the ancilla qubit. We name Alice's qubits one through ve (they
are actually two through six in the above matrix from the left to the right).
The generators for the initial entanglement subgroupS
E;0
, isotropic subgroupS
I;0
, gauge
subgroupS
G;0
, and classical subgroupS
C;0
are respectively as follows:
S
E;0
(D) =
2
4
1 0 0 0 0
0 0 0 0 0
0 0 0 0 0
1 0 0 0 0
3
5
;
S
I;0
(D) =
h
0 1 0 0 0
0 0 0 0 0
i
;
S
G;0
(D) =
2
4
0 0 1 0 0
0 0 0 0 0
0 0 0 0 0
0 0 1 0 0
3
5
;
S
C;0
(D) =
h
0 0 0 1 0
0 0 0 0 0
i
:
The sender performs the following nite-depth operations (order is from left to right and top to
bottom):
H (2) C (2; 3;D) C (2; 4; 1 +D) C (2; 5;D) H (3; 4; 5)
C (2; 3;D) C (2; 5;D) H (2) C (1; 2;D) C (1; 4; 1 +D)
C (1; 5; 1 +D) H (1; 2; 3; 4; 5) C (1; 3;D) C (1; 4; 1 +D)
C (1; 5; 1 +D) S (1; 4):
147
where the notation for the above encoding operations was established in Section 4.5. Figure 8.1
details these operations on the initial qubit stream. The initial stabilizer matrixS
0
(D) transforms
to S (D) under these encoding operations, where
S (D) =
2
6
6
6
4
1 0 0 0 0 0
0 1 +D D 0 1 1 +D
0 0 0 D D D
0 1 +D 0 D 1 1 +D
1 0 0 0 0 0
0 0 1 0 1 1
3
7
7
7
5
: (8.10)
The generators for the dierent subgroups transform respectively as follows:
S
E
(D) =
2
4
0 0 0 0 0
1 +D D 0 1 1 +D
1 +D 0 D 1 1 +D
0 0 0 0 0
3
5
;
S
I
(D) =
h
0 0 D D D
0 1 0 1 1
i
;
S
G
(D) =
2
4
0
1
D
1
1
D
0
0
1
D
0 0 0
0 0 0 0 0
0 0 1 0 0
3
5
;
S
C
(D) =
h
1 1 +D
1
0 1 +D
1
0
0 0 0 0 0
i
:
The code actively protects against an arbitrary single-qubit error in every other frame. One can
check that the syndromes of the stabilizer in S (D) satisfy this property. Consider the Pauli gen-
erators corresponding to the generators in the entanglement subgroup and the isotropic subgroup:
X I I X X
Z I I Z Z
I X I X X
X I X I X
Z Z I I Z
I I Z Z Z
; (8.11)
where all other entries in the left and right directions are tensor products of the identity. We
can use a table-lookup syndrome-based algorithm to determine the error-correcting capability of
the code. The method is similar to the technique originally outlined in detail in Ref. [29]. The
syndrome vector s consists of six bits where s = s
1
s
6
. The rst bit s
1
is one if the error
anticommutes with the operator XIIXX in the rst part of the rst generator above and zero
otherwise. The second bit s
2
is one if the error anticommutes with the operator XIXIX in the
148
Error Syndrome Error Syndrome Error Syndrome
X
1
001100 X
3
000001 X
5
001101
Y
1
111100 Y
3
010001 Y
5
111111
Z
1
110000 Z
3
010000 Z
5
110010
X
2
000100 X
4
001001
Y
2
000110 Y
4
101011
Z
2
000010 Z
4
100010
Table 8.1: A list of possible single-qubit errors in a particular frame and the corresponding syn-
drome vector. The syndrome corresponding to any single-qubit error is unique. The code therefore
corrects an arbitrary single-qubit error in every other frame.
delayed part of the rst generator above and zero otherwise. The third through sixth bits follow
a similar pattern for the second and third generators above. Table 8.1 lists all single-qubit errors
over ve qubits and their corresponding syndromes. The code corrects an arbitrary single-qubit
error in every other frame using this algorithm because the syndromes are all unique. A syndrome-
based Viterbi algorithm might achieve better performance than the simple syndrome table-lookup
algorithm outlined above.
This code also has passive protection against errors inhS
I
;S
G
;S
C
i. The Pauli form of the
errors in this group span over three frames and are as follows:
IIIII
IZIZI
IZIII
IZIZI
IXIXX
IIZII
IIXII
ZZIZI
IIZZZ
IIIII
IIIII
IIIII
(8.12)
The smallest weight errors in this group have weight two and three. The code passively corrects
the above errors or any product of them or any ve-qubit shift of them.
There is a trade-o between passive error correction and the ability to encode quantum in-
formation as discussed in Ref. [44]. One can encode more quantum information by dropping the
gauge group and instead encoding extra information qubits. The gauge generators then become
logical X and Z operators for the extra encoded qubits. One can also turn classical bits into
149
information qubits by dropping the generators in the classical subgroup. These generators then
become logicalZ operators for the extra encoded qubits. By making the above replacements, the
code loses some of its ability to correct passively, but we gain a higher quantum information rate.
On the other hand, if we replace a gauge qubit with an ancilla qubit or an ebit, we gain the ability
to correct extra errors. The trade-o now is that replacing gauge qubits with ebits or ancillas
enhances the active error-correcting capability of the code, but increases the overall complexity of
error correction.
8.3 Closing Remarks
We have presented a framework and a representative example for grandfather quantum convolu-
tional codes. We have explicitly shown how these codes operate, and how to encode and decode a
classical-quantum information stream by using ebits, ancilla qubits, and gauge qubits for quantum
redundancy. The ultimate goal for this theory is to nd quantum convolutional codes that might
play an integral part in larger quantum codes that approach the grandfather capacity [25]. One
useful line of investigation may be to combine this theory with the recent quantum turbo-coding
theory [65].
150
Chapter 9
Convolutional Entanglement Distillation
A chap at the \Entanglement Distillery,"
Was drunk so they gave him the pillory,
They'd foul dirty ebits,
He said, \Convolutional circuits!"
So they augmented the quantum artillery.
The goal of entanglement distillation resembles the goal of quantum error correction [6, 7]. An
entanglement distillation protocol extracts noiseless, maximally-entangled ebits from a larger set
of noisy ebits. A sender and receiver can use these noiseless ebits as a resource for several quantum
communication protocols [10, 5].
Bennett et al. showed that a strong connection exists between quantum error-correcting codes
and entanglement distillation and demonstrated a method for converting an arbitrary quantum
error-correcting code into a one-way entanglement distillation protocol [7]. A one-way entangle-
ment distillation protocol utilizes one-way classical communication between sender and receiver
to carry out the distillation procedure. Shor and Preskill improved upon Bennett et al.'s method
by avoiding the use of ancilla qubits and gave a simpler method for converting an arbitrary CSS
quantum error-correcting code into an entanglement distillation protocol [73]. Nielsen and Chuang
showed how to convert a stabilizer quantum error-correcting code into a stabilizer entanglement
distillation protocol [60]. Luo and Devetak then incorporated shared entanglement to demonstrate
151
how to convert an entanglement-assisted stabilizer code into an entanglement-assisted entangle-
ment distillation protocol [56]. All of the above constructions exploit the relationship between
quantum error correction and entanglement distillation|we further exploit the connection in this
chapter by forming a convolutional entanglement distillation protocol.
In this last chapter, our main contribution is a theory of convolutional entanglement distillation.
Our theory allows us to import the entirety of classical convolutional coding theory for use in
entanglement distillation. The task of nding a good convolutional entanglement distillation
protocol now becomes the well-established task of nding a good classical convolutional code.
We begin in Section 9.3 by showing how to construct a convolutional entanglement distillation
protocol from an arbitrary quantum convolutional code. We translate earlier protocols [73, 60] for
entanglement distillation of a block of noisy ebits to the convolutional setting. A convolutional
entanglement distillation protocol has the benet of distilling entanglement \online." This online
property is useful because the sender and receiver can distill entanglement \on the
y" as they
obtain more noisy ebits. This translation from a quantum convolutional code to an entanglement
distillation protocol is useful because it paves the way for our major contribution.
Our major advance is a method for constructing a convolutional entanglement distillation
protocol when the sender and receiver initially share some noiseless ebits. As stated previously,
prior quantum convolutional work requires the code to satisfy the restrictive self-orthogonality
constraint, and authors performed specialized searches for classical convolutional codes that meet
this constraint [61, 62, 30, 29]. We lift this constraint by allowing shared noiseless entanglement.
The benet of convolutional entanglement distillation with entanglement assistance is that we can
import an arbitrary classical binary or quaternary convolutional code for use in a convolutional
entanglement distillation protocol. The error-correcting properties for the convolutional entangle-
ment distillation protocol follow directly from the properties of the imported classical code. Thus
we can apply the decades of research on classical convolutional coding theory with many of the
benets of the convolutional structure carrying over to the quantum domain.
We organize this chapter as follows. We review stabilizer entanglement distillation in Section
9.1 and entanglement-assisted entanglement distillation in Section 9.2. In Section 9.3, we show how
to convert an arbitrary quantum convolutional code into a convolutional entanglement distillation
protocol. In Section 9.4, we provide several methods and examples for constructing convolutional
152
Figure 9.1: An example of a block entanglement distillation protocol. A sender creates a set of
noisy ebits by sending half of a set of Bell states through a noisy quantum channel. Both sender
and receiver perform multi-qubit measurements to diagnose channel error. The sender transmits
her measurement results to the receiver over a classical communication channel. Both perform
recovery and decoding operations to obtain a set of noiseless ebits.
entanglement distillation protocols where two parties possess a few initial noiseless ebits. These
initial noiseless ebits act as a catalyst for the convolutional distillation protocol. The constructions
in Section 9.4 make it possible to import an arbitrary classical binary or quaternary convolutional
code for use in convolutional entanglement distillation.
9.1 Stabilizer Entanglement Distillation without Entangle-
ment Assistance
The purpose of an [n;k] entanglement distillation protocol is to distill k pure ebits from n noisy
ebits where 0 k n [6, 7]. The yield of such a protocol is k=n. Two parties can then use
the noiseless ebits for quantum communication protocols. Figure 9.1 illustrates the operation of
a block entanglement distillation protocol.
The two parties establish a set of shared noisy ebits in the following way. The sender Alice
rst prepares n Bell statesj
+
i
n
locally. She sends the second qubit of each pair over a noisy
quantum channel to a receiver Bob. Letj
+
n
i be the statej
+
i
n
rearranged so that all of Alice's
qubits are on the left and all of Bob's qubits are on the right. The noisy channel applies a Pauli
153
error in the error setE
n
to the set ofn qubits sent over the channel. The sender and receiver
then share a set of n noisy ebits of the form (I
A)j
+
n
i where the identity I acts on Alice's
qubits and A is some Pauli operator inE acting on Bob's qubits.
A one-way stabilizer entanglement distillation protocol uses a stabilizer code for the distillation
procedure. Figure 9.1 highlights the main features of a stabilizer entanglement distillation protocol.
Suppose the stabilizerS for an [n;k] quantum error-correcting code has generators g
1
;:::;g
nk
.
The distillation procedure begins with Alice measuring the nk generators inS. LetfP
i
g be
the set of the 2
nk
projectors that project onto the 2
nk
orthogonal subspaces corresponding to
the generators inS. The measurement projectsj
+
n
i randomly onto one of thei subspaces. Each
P
i
commutes with the noisy operator A on Bob's side so that
(P
i
I) (I
A)
+
n
= (I
A) (P
i
I)
+
n
: (9.1)
The following important \Bell-state matrix identity" holds for an arbitrary matrix M:
(M
I)
+
n
=
I
M
T
+
n
: (9.2)
Then (9.1) is equal to the following:
(I
A) (P
i
I)
+
n
= (I
A)
P
2
i
I
+
n
= (I
A)
P
i
P
T
i
+
n
:
Therefore each of Alice's projectors P
i
projects Bob's qubits onto a subspace P
T
i
corresponding
to Alice's projected subspace P
i
. This operation is one of the \weird" properties of entanglement
because it projects the set of noisy ebits onto the codespace eectively \before" the noise acts on it.
Alice restores her qubits to the simultaneous +1-eigenspace of the generators inS. She sends her
measurement results to Bob. Bob measures the generators inS. Bob combines his measurements
with Alice's to determine a syndrome for the error. He performs a recovery operation on his qubits
to reverse the error. He restores his qubits to the simultaneous +1-eigenspace of the generators
inS. Alice and Bob both perform the decoding unitary corresponding to stabilizerS to convert
their k logical ebits to k physical ebits.
154
9.2 Stabilizer Entanglement Distillation with Entanglement
Assistance
Luo and Devetak provided a straightforward extension of the above protocol [56]. Their method
converts an entanglement-assisted stabilizer code into an entanglement-assisted entanglement dis-
tillation protocol.
Luo and Devetak form an entanglement distillation protocol that has entanglement assistance
from a few noiseless ebits. The crucial assumption for an entanglement-assisted entanglement
distillation protocol is that Alice and Bob possess c noiseless ebits in addition to their n noisy
ebits. The total state of the noisy and noiseless ebits is
(I
A
(A
I)
B
)
+
n+c
(9.3)
where I
A
is the 2
n+c
2
n+c
identity matrix acting on Alice's qubits and the noisy Pauli operator
(A
I)
B
aects Bob's rst n qubits only. Thus the last c ebits are noiseless, and Alice and Bob
have to correct for errors on the rst n ebits only.
The protocol proceeds exactly as outlined in the previous section. The only dierence is that
Alice and Bob measure the generators in an entanglement-assisted stabilizer code. Each generator
spans over n +c qubits where the last c qubits are noiseless.
We comment on the yield of this entanglement-assisted entanglement distillation protocol.
An entanglement-assisted code has nk generators that each have n +c Pauli entries. These
parameters imply that the entanglement distillation protocol producesk+c ebits. But the protocol
consumesc initial noiseless ebits as a catalyst for distillation. Therefore the yield of this protocol
is k=n.
In Section 9.4, we exploit this same idea of using a few noiseless ebits as a catalyst for distil-
lation. The idea is similar in spirit to that developed in this section, but the mathematics and
construction are dierent because we perform distillation in a convolutional manner.
155
Figure 9.2: An example of a convolutional entanglement distillation protocol taken from the
quantum convolutional code in Ref. [29]. The code in Ref. [29] has rate 1/3 and can correct
for single-qubit errors in every other frame. Alice and Bob rst measure the operators in the
stabilizer for the quantum convolutional code. Alice performs conditional unitaries on her qubits
to restore them to the +1 eigenspace of the stabilizer code. Alice forwards her measurement
results to Bob. Bob performs a maximum-likelihood decoding procedure such as Viterbi decoding
[75] to determine the qubit errors. He corrects for these errors. He restores his qubits to the +1
eigenspace of the stabilizer code. Alice and Bob both perform online decoding to obtain ebits with
yield 1/3.
9.3 Convolutional Entanglement Distillation without En-
tanglement Assistance
We now show how to convert an arbitrary quantum convolutional code into a convolutional en-
tanglement distillation protocol. Figure 9.2 illustrates an example of a yield-1/3 convolutional
entanglement distillation protocol. The protocol has the same benets as a quantum convolutional
code: an online decoder with less decoding complexity than a block protocol, good error-correcting
properties, and higher ebit yield than a block protocol. The protocol we develop in this section is
useful for our major contribution presented in the next section.
We can think of our protocol in two ways. Our protocol applies when a sender Alice and a
receiver Bob possess a countably innite number of noisy ebits. Our protocol also applies as an
online protocol when Alice and Bob begin with a nite number of noisy ebits and establish more
as time passes. The countably innite and online protocols are equivalent. We would actually
implement the entanglement distillation protocol in the online manner, but we formulate the
156
forthcoming mathematics with the countably innite description. Each step in the protocol does
not need to wait for the completion of its preceding step if Alice and Bob employ the protocol
online.
The protocol begins with Alice and Bob establishing a set of noisy ebits. Alice prepares a
countably innite number of Bell statesj
+
i locally. She sends one half of each Bell state through
a noisy quantum channel. Alice and Bob then possess a state
AB
that is a countably innite
number of noisy ebits
AB
i
where
AB
=
1
O
i=1
AB
i
: (9.4)
The state
AB
is equivalent to the following ensemble
n
p
i
;
+
AB
i
o
: (9.5)
In the above, p
i
is the probability that the state isj
+
i
AB
i
, where
+
AB
i
(I
A
i
)
+
1
AB
; (9.6)
andj
+
1
i
AB
is the state
j
+
i
AB
1
rearranged so that all of Alice's qubits are on the left and
all of Bob's are on the right. A
i
2
Z
+
is a Pauli sequence of errors acting on Bob's side. These
errors result from the noisy quantum channel. I is a sequence of identity matrices acting on Alice's
side indicating that the noisy channel does not aect her qubits. Alice and Bob need to correct
for a particular error set in order to distill noiseless ebits.
Alice and Bob employ the following strategy to distill noiseless ebits. Alice measures the
nk generators in the basic setG
0
. The measurement operation projects the rst n ( + 1) ebits
( is the constraint length) randomly onto one of 2
nk
orthogonal subspaces. Alice places the
measurement outcomes in an (nk)-dimensional classical bit vector a
0
. She restores her half of
the noisy ebits to the simultaneous +1-eigenspace of the generators inG
0
if a
0
diers from the
all-zero vector. She sends a
0
to Bob over a classical communication channel. Bob measures the
generators inG
0
and stores the measurement outcomes in a classical bit vector b
0
. Bob compares
b
0
to a
0
by calculating an error vector e
0
= a
0
b
0
. He corrects for any errors that e
0
can identify.
He may have to wait to receive later error vectors before determining the full error syndrome. He
157
restores his half of the noisy ebits to the simultaneous +1-eigenspace of the generators inG
0
if
the bit vector b
0
indicates that his logical ebits are not in the +1-space. Alice and Bob repeat
the above procedure for all shifts D (G
0
), D
2
(G
0
), . . . of the basic generators inG
0
. Bob obtains
a setE of classical error vectors e
i
:E =fe
i
:i2Z
+
g. Bob uses a maximum-likelihood decoding
technique such as Viterbi decoding [75] or a table-lookup on the error setE to determine which
errors occur. This error determination process is a purely classical computation. He reverses the
estimated errors after determining the syndrome.
The states that Alice and Bob possess after the above procedure are encoded logical ebits.
They can extract physical ebits from these logical ebits by each performing the online decoding
circuit for the codeG. The algorithm outlined in Ref. [34] gives a method for determining the
online decoding circuit.
Example 9.3.1. We use the rate-1/3 quantum convolutional code in Example 4.1.1 to produce
a yield-1/3 convolutional entanglement distillation protocol. Alice measures the generators in
the stabilizer in (4.8) for every noisy ebit she shares with Bob. Alice communicates the result
of her measurement of the rst two generators to Bob. Alice restores the qubits on her side to
be in the simultaneous +1-eigenspace of the rst two generators. Bob measures the same rst
two generators. Alice measures the next two generators, communicates her results, etc. Bob
compares his results to Alice's to determine the error bit vectors. Bob performs Viterbi decoding
on the measurement results and corrects for errors. He rotates his states to the simultaneous
+1-eigenspace of the generators. Alice and Bob perform the above procedure in an online manner
according to Figure 9.2. Alice and Bob can decode the rst six qubits after measuring the second
two generators. They can decode because there is no overlap between the rst two generators
and any two generators after the second two generators. They use the circuit from [34] in reverse
order to decode physical ebits from logical ebits. They distill ebits with yield 1/3 by using this
convolutional entanglement distillation protocol. The ebit yield of 1/3 follows directly from the
code rate of 1/3.
158
9.4 Convolutional Entanglement Distillation with Entan-
glement Assistance
The convolutional entanglement distillation protocol that we develop in this section operates iden-
tically to the one developed in the previous section. The measurements, classical communication,
and recovery and decoding operations proceed exactly as Figure 9.2 indicates.
The dierence between the protocol in this section and the previous one is that we now assume
the sender and receiver share a few initial noiseless ebits. They use these initial ebits as a catalyst
to get the protocol started. The sender and receiver require noiseless ebits for each round of the
convolutional entanglement distillation protocol. They can use the noiseless ebits generated by
earlier rounds for consumption in later rounds. It is possible to distill noiseless ebits in this way
by catalyzing the process with a few noiseless ebits. The protocol we develop in this section is a
more powerful generalization of the previous section's protocol.
The construction in this section allows sender and receiver to use an arbitrary set of Paulis for
the distillation protocol. The set does not necessarily have to be a commuting set of Paulis.
The implication of the construction in this section is that we can import an arbitrary binary
or quaternary classical convolutional code for use as a quantum convolutional code. We explicitly
give some examples to highlight the technique for importing. The error-correcting properties and
yield translate directly from the properties of the classical convolutional code. Thus the problem
of nding a good convolutional entanglement distillation protocol reduces to that of nding a good
classical convolutional code.
9.4.1 Yield (n-1)/n Convolutional Entanglement Distillation
We present our rst method for constructing a convolutional entanglement distillation protocol
that uses entanglement assistance. The shifted symplectic product from Section 4.3 is a crucial
component of our formulation.
Suppose Alice and Bob use one generator N (u (D)) for an entanglement distillation protocol
where
u (D) = [z (D)jx (D)] =
h
z
1
(D) z
n
(D)
j
x
1
(D) x
n
(D)
i
:
159
and where z
1
(D), . . . , z
n
(D), x
1
(D), . . . , x
n
(D) are binary polynomials. We do not impose a
commuting constraint on generator N (u (D)). Alice and Bob choose generator N (u (D)) solely
for its error-correcting capability.
The shifted symplectic product helps to produce a commuting generator from a noncommuting
one. The shifted symplectic product of u (D) is
(u u) (D) =
X
i2Z
(u u)
i
D
i
: (9.7)
The coecient (u u)
0
for zero shifts is equal to zero because every tensor product of Pauli
operators commutes with itself:
(u u)
0
= 0: (9.8)
Recall that u (D) is self-time-reversal symmetric (4.32). We adopt the following notation for a
polynomial that includes the positive-index or negative-index coecients of the shifted symplectic
product (u u) (D):
(u u) (D)
+
=
X
i2Z
+
(u u)
i
D
i
; (u u) (D)
=
X
i2Z
(u u)
i
D
i
: (9.9)
The following identity holds:
(u u) (D)
+
= (u u)
D
1
: (9.10)
Consider the following vector of polynomials:
a (D) =
h
(u u) (D)
+
j
1
i
: (9.11)
Its relations under the shifted symplectic product are the same as u (D):
(a a) (D) = (u u) (D)
+
+ (u u) (D)
= (u u) (D):
160
X
1
Z
1
Y
1
X
2
Z
2
Y
2
1 0 1 1 0 1
0 0 0 0 1 1
0 1 1 1 0 1
1 0 1 0 0 0
Table 9.1: The convolutional entanglement distillation protocol for Example 9.4.1 corrects for a
single-qubit error in every fourth frame. Here we list the syndromes corresponding to errors X
1
,
Y
1
, and Z
1
on the rst qubit and to errors X
2
, Y
2
, and Z
2
on the second qubit. The syndromes
are unique so that the receiver can identify which error occurs.
The vector a (D) provides a straightforward way to make N (u (D)) commute with all of its shifts.
We augment u (D) with a (D). The augmented generator u
0
(D) is as follows:
u
0
(D) =
h
z (D) (u u) (D)
+
j
x (D) 1
i
: (9.12)
The augmented generator u
0
(D) has vanishing symplectic product, (u
0
u
0
) (D) = 0, because the
shifted symplectic product of a (D) nulls the shifted symplectic product of u (D). The augmented
generator N (u
0
(D)) commutes with itself for every shift and is therefore useful for convolutional
entanglement distillation as outlined in Section 9.3.
We can construct an entanglement distillation protocol using an augmented generator of this
form. The rst n Pauli entries for every frame of generator N (u
0
(D)) correct errors. Entry
n + 1 for every frame of N (u
0
(D)) makes N (u
0
(D)) commute with every one of its shifts. The
error-correcting properties of the code do not include errors on the last (extra) ebit of each frame;
therefore, this ebit must be noiseless. It is necessary to catalyze the distillation procedure with
n noiseless ebits where n is the frame size and is the constraint length. The distillation
protocol requires this particular amount because it does not correct errors and generate noiseless
ebits until it has nished processing the rst basic set of generators and 1 of its shifts.
Later frames can use the noiseless ebits generated from previous frames. Therefore these initial
noiseless ebits are negligible when calculating the yield. This construction allows us to exploit the
error-correcting properties of an arbitrary set of Pauli matrices for a convolutional entanglement
distillation protocol.
161
We discuss the yield of such a protocol in more detail. Our construction employs one generator
withn + 1 qubits per frame. The protocol generates n noiseless ebits for every frame. But it also
consumes a noiseless ebit for every frame. Every frame thus produces a net ofn1 noiseless ebits,
and the yield of the protocol is (n 1)=n.
This yield of (n 1)=n is superior to the yield of an entanglement distillation protocol taken
from the quantum convolutional codes of Forney et al. [29]. Our construction should also give
entanglement distillation protocols with superior error-correcting properties because we have no
self-orthogonality constraint on the Paulis in the stabilizer.
It is possible to construct an online decoding circuit for the generator u
0
(D) by the methods
given in [34]. A circuit satises the noncatastrophic property if the polynomial entries of all of
the code generators have a greatest common divisor that is a power of the delay operator D [34].
The online decoding circuit for this construction obeys the noncatastrophicity property because
the augmented generator u
0
(D) contains 1 as one of its entries.
Example 9.4.1. Suppose we have the following generator
N (u (D)) = (jIIjZZjIXjXZjZIjIIj );
where
u (D) =
h
1 +D
3
1 +D
2
D
2
D
i
:
The above generator corrects for an arbitrary single-qubit error in every fourth frame. Table 9.4.1
lists the unique syndromes for errors in a single frame. The generator anticommutes with a shift of
itself by one or two to the left or right. The shifted symplectic product conrms these commutation
relations:
(u u) (D) =D +D
2
+D
1
+D
2
:
Let us follow the prescription in (9.12) for augmenting generator N (u (D)). The following poly-
nomial
a (D) =
h
(u u) (D)
+
1
i
=
h
D +D
2
1
i
;
162
Figure 9.3: The above gure illustrates Bob's side of the convolutional entanglement distillation
protocol that uses entanglement assistance. The noise aects the rst and second of every three
ebits that Bob shares with Alice. Every third ebit that Alice and Bob share are noiseless. The
measurements correspond to those in Example 9.4.1.
163
has the same commutation relations as u (D):
(a a) (D) = (u u) (D): (9.13)
We augment u (D) as follows:
u
0
(D) =
h
1 +D
3
1 +D
2
D +D
2
D
2
D 1
i
:
The overall generator now looks as follows in the Pauli representation:
N (u
0
(D)) = (jIIIjZZXjIXZjXZZjZIIjIIIj ):
The yield of a protocol using the above construction is 1/2. Figure 9.3 illustrates Bob's side of
the protocol. It shows which of Bob's half of the ebits are noisy and noiseless, and it gives the
measurements that Bob performs.
9.4.2 Yield (n-m)/n Convolutional Entanglement Distillation
The construction in the above section uses only one generator for distillation. We generalize the
above construction to a code with an arbitrary number of generators. We give an example that
illustrates how to convert an arbitrary classical quaternary convolutional code into a convolutional
entanglement distillation protocol.
Suppose we have the following m generators
fN (u
i
(D)) : 1img;
where
2
6
6
6
6
6
6
6
4
u
1
(D)
u
2
(D)
.
.
.
u
m
(D)
3
7
7
7
7
7
7
7
5
=
2
6
6
6
6
6
6
6
4
z
1
(D)
z
2
(D)
.
.
.
z
m
(D)
x
1
(D)
x
2
(D)
.
.
.
x
m
(D)
3
7
7
7
7
7
7
7
5
: (9.14)
164
We make no assumption about the commutation relations of the above generators. We choose
them solely for their error-correcting properties.
We again utilize the shifted symplectic product to design a convolutional entanglement distil-
lation protocol with multiple generators. Let us adopt the following shorthand for the auto and
cross shifted symplectic products of generators u
1
(D);:::; u
m
(D):
u
+
i
(u
i
u
i
) (D)
+
; (9.15)
u
i;j
(u
i
u
j
) (D): (9.16)
Consider the following matrix:
2
6
6
6
6
6
6
6
4
a
1
(D)
a
2
(D)
.
.
.
a
m
(D)
3
7
7
7
7
7
7
7
5
=
2
6
6
6
6
6
6
6
4
u
+
1
u
1;2
u
1;m
0 u
+
2
u
2;m
.
.
.
.
.
.
.
.
.
0 0 u
+
m
I
mm
3
7
7
7
7
7
7
7
5
: (9.17)
The symplectic relations of the entries a
i
(D) are the same as the original u
i
(D):
(a
i
a
j
) (D) = (u
i
u
j
) (D) 8i;j2f1;:::;mg;
or equivalently, if
a
(D) is the shifted symplectic product matrix for the generators in (9.17) and
u
(D) is the shifted symplectic product matrix for the \u" generators, then
a
(D) =
u
(D):
We mention that the following matrix also has the same symplectic relations:
2
6
6
6
6
6
6
6
4
u
+
1
0 0
u
2;1
u
+
2
.
.
.
.
.
.
.
.
. 0
u
m;1
u
m;2
u
+
m
I
mm
3
7
7
7
7
7
7
7
5
: (9.18)
165
Let us rewrite (9.17) as follows:
2
6
6
6
6
6
6
6
4
a
1
(D)
a
2
(D)
.
.
.
a
m
(D)
3
7
7
7
7
7
7
7
5
=
2
6
6
6
6
6
6
6
4
z
0
1
(D)
z
0
2
(D)
.
.
.
z
0
m
(D)
x
0
1
(D)
x
0
2
(D)
.
.
.
x
0
m
(D)
3
7
7
7
7
7
7
7
5
: (9.19)
The above matrix provides a straightforward way to make the original generators commute with all
of their shifts. We augment the generators in (9.14) by the generators a
i
(D) to get the following
m 2 (n +m) matrix:
U
0
(D) =
h
Z (D)
X (D)
i
=
2
6
6
6
6
6
6
6
4
z
1
(D) z
0
1
(D)
z
2
(D) z
0
2
(D)
.
.
.
.
.
.
z
m
(D) z
0
m
(D)
x
1
(D) x
0
1
(D)
x
2
(D) x
0
2
(D)
.
.
.
.
.
.
x
m
(D) x
0
m
(D)
3
7
7
7
7
7
7
7
5
:
Every row of the augmented matrix U
0
(D) has vanishing symplectic product with itself and any
other row. This condition is equivalent to the following matrix condition for shifted symplectic
orthogonality [62]:
Z (D) X
T
D
1
X (D) Z
T
D
1
= 0: (9.20)
The construction gives a commuting set of generators for arbitrary shifts and thus forms a valid
stabilizer.
We can readily develop a convolutional entanglement distillation protocol using the above
formulation. The generators in the augmented matrix U
0
(D) correct for errors on the rst n
ebits. The last m ebits are noiseless ebits that help to obtain a commuting stabilizer. It is
necessary to catalyze the distillation protocol with (n +m) noiseless ebits. Later frames can
use the noiseless ebits generated from previous frames. These initial noiseless ebits are negligible
when calculating the yield.
We comment more on the yield of the protocol. The protocol requires a set of m generators
with n +m Pauli entries. It generates n ebits for every frame. But it consumes m noiseless ebits
per frame. The net yield of a protocol using the above construction is thus (nm)=n.
166
The key benet of the above construction is that we can use an arbitrary set of Paulis for
distilling noiseless ebits. This arbitrariness in the Paulis implies that we can import an arbi-
trary classical convolutional binary or quaternary code for use in a convolutional entanglement
distillation protocol.
It is again straightforward to develop a noncatastrophic decoding circuit using previous tech-
niques [34]. Every augmented generator in U
0
(D) has \1" as an entry so that it satises the
property required for noncatastrophicity.
Example 9.4.2. We begin with a classical quaternary convolutional code with entries fromGF (4):
(j0000j1 !10j1101j0000j ): (9.21)
The above code is a convolutional version of the classical quaternary block code from Ref. [14].
We multiply the above generator by ! and ! as prescribed in Refs. [17, 29] and use the map in
(3.38) to obtain the following Pauli generators
N (u
1
(D)) = (jIIIIjZXZIjZZIZjIIIIj );
N (u
2
(D)) = (jIIIIjXYXIjXXIXjIIIIj ): (9.22)
We determine binary polynomials corresponding to the above Pauli generators:
2
4
u
1
(D)
u
2
(D)
3
5
=
2
4
1 +D D 1 D
0 1 0 0
0 1 0 0
1 +D 1 +D 1 D
3
5
: (9.23)
The rst generator anticommutes with itself shifted by one to the left or right, the second generator
anticommutes with itself shifted by one to the left or right, and the rst generator anticommutes
with the second shifted by one to the left. The following shifted symplectic products conrm the
above commutation relations:
(u
1
u
1
) (D) =D
1
+D; (u
2
u
2
) (D) =D
1
+D; (u
1
u
2
) (D) =D
1
: (9.24)
167
Consider the following two generators:
2
4
a
1
(D)
a
2
(D)
3
5
=
2
4
D 0
D D
1 0
0 1
3
5
: (9.25)
Their relations under the shifted symplectic product are the same as those in (9.24).
(a
1
a
1
) (D) = (u
1
u
1
) (D); (a
2
a
2
) (D) = (u
2
u
2
) (D); (a
1
a
2
) (D) = (u
1
u
2
) (D):
We augment the generators u
1
(D) and u
2
(D) to generators u
0
1
(D) and u
0
2
(D) respectively as
follows. The augmented matrix U
0
(D) is
U
0
(D) =
2
4
1 +D D 1 D
0 1 0 0
D 0
D D
0 1 0 0
1 +D 1 +D 1 D
1 0
0 1
3
5
: (9.26)
The rst row of U
0
(D) is generator u
0
1
(D) and the second row is u
0
2
(D). The augmented gener-
ators have the following Pauli representation.
N (u
0
1
(D)) = (jIIIIIIjZXZIXIjZZIZZIjIIIIIIj );
N (u
0
2
(D)) = (jIIIIIIjXYXIIXjXXIXZZjIIIIIIj ): (9.27)
The original block code from Ref. [14] corrects for an arbitrary single-qubit error. The above
entanglement distillation protocol corrects for a single-qubit error in eight qubits|two frames.
This error-correcting capability follows from the capability of the block code. The yield of a
protocol using the above stabilizer is again 1/2.
9.4.3 CSS-Like Construction for Convolutional Entanglement Distilla-
tion
We nally present a construction that allows us to import two arbitrary binary classical codes for
use in a convolutional entanglement distillation protocol. The construction is similar to a CSS
code because one code corrects for bit
ips and the other corrects for phase
ips.
168
We could simply use the technique from the previous section to construct a convolutional
entanglement-distillation protocol. We could represent both classical codes as codes over GF (4).
We could multiply the bit-
ip code by ! and the phase-
ip code by ! and use the map in (3.38)
from GF (4) to the Paulis. We could then use the above method for augmentation and obtain a
valid quantum code for entanglement distillation. But there is a better method that exploits the
structure of a CSS code to minimize the number of initial catalytic noiseless ebits.
Our algorithm below uses a Gram-Schmidt like orthogonalization procedure to minimize the
number of initial noiseless ebits. The procedure is similar to the algorithm in [13] with some key
dierences.
Suppose we have m generatorsfN (w
i
(D)) : 1img where
2
6
6
6
6
6
6
6
6
6
6
6
6
6
4
w
1
(D)
.
.
.
w
p
(D)
w
p+1
(D)
.
.
.
w
m
(D)
3
7
7
7
7
7
7
7
7
7
7
7
7
7
5
=
2
6
6
6
6
6
6
6
6
6
6
6
6
6
4
z
1
(D)
.
.
.
z
p
(D)
0
.
.
.
0
0
.
.
.
0
x
1
(D)
.
.
.
x
mp
(D)
3
7
7
7
7
7
7
7
7
7
7
7
7
7
5
: (9.28)
and each vector w
i
(D) has length 2n. The above matrix could come from two binary classical
codes. The vectors z
1
(D),. . . ,z
p
(D) could come from one code, and the vectors x
1
(D),. . . ,x
mp
(D)
could come from another code. The following orthogonality relations hold for the above vectors:
8 1i;jp : (w
i
w
j
) (D) = 0; (9.29)
8 p + 1i
0
;j
0
m : (w
i
0 w
j
0) (D) = 0: (9.30)
We exploit the above orthogonality relations in the algorithm below.
We can perform a Gram-Schmidt process on the above set of vectors. This process orthogo-
nalizes the vectors with respect to the shifted symplectic product. The procedure does not change
the error-correcting properties of the original codes because all operations are linear.
The algorithm breaks the set of vectors above into pairs. Each pair consists of two vectors
which are symplectically nonorthogonal to each other, but which are symplectically orthogonal
169
to all other pairs. Any remaining vectors that are symplectically orthogonal to all other vectors
are collected into a separate set, which we call the set of isotropic vectors. This idea is similar to
the decomposition of a vector space into an isotropic and symplectic part. We cannot label the
decomposition as such because the shifted symplectic product is not a true symplectic product.
We detail the initialization of the algorithm. Set parameters i = 0, c = 0, l = 0. The index i
labels the total number of vectors processed, c gives the number of pairs, and l labels the number
of vectors with no partner. Initialize setsU andV to be null: U =V =;. U keeps track of the
pairs andV keeps track of the vectors with no partner.
The algorithm proceeds as follows. While i m, let j 2c +l + 2 be the smallest index
for a w
j
(D) for which (w
2c+l+1
w
j
) (D)6= 0. Increment l and i by one, add i toV, and
proceed to the next round if no such pair exists. Otherwise, swap w
j
(D) with w
2c+l+2
(D). For
r2f2c +l + 3;:::;mg, perform
w
r
(D) = (w
2c+l+2
w
2c+l+1
) (D) w
r
(D) + (w
r
w
2c+l+2
)
D
1
w
2c+l+1
(D);
if w
r
(D) has a purely z component. Perform
w
r
(D) = (w
2c+l+1
w
2c+l+2
) (D) w
r
(D) + (w
r
w
2c+l+1
)
D
1
w
2c+l+2
(D);
if w
r
(D) has a purely x component. Divide every element in w
r
(D) by the greatest common
factor if the GCF is not equal to one. Then
(w
r
w
2c+l+1
) (D) = (w
r
w
2c+l+2
) (D) = 0: (9.31)
Increment c by one, increment i by one, add i toU, and increment i by one. Proceed to the next
round.
We now give the method for augmenting the above generators so that they form a commuting
stabilizer. At the end of the algorithm, the setsU andV have the following sizes: jUj = c and
jVj =l. Let us relabel the vectors w
i
(D) for all 1i 2c +l. We relabel all pairs: call the rst
u
i
(D) and call its partner v
i
(D) for all 1ic. Call any vector without a partner u
c+i
(D) for
170
all 1il. The relabeled vectors have the following shifted symplectic product relations after
the Gram-Schmidt procedure:
(u
i
v
j
) (D) =f
i
(D)
ij
8 i;j2f1;:::;cg;
(u
i
u
j
) (D) = 0 8 i;j2f1;:::;lg;
(v
i
v
j
) (D) = 0 8 i;j2f1;:::;cg; (9.32)
where f
i
(D) is an arbitrary polynomial. Let us arrange the above generators in a matrix as
follows:
h
u
T
1
(D) u
T
c
(D) v
T
1
(D) v
T
c
(D) u
T
c+1
(D) u
T
c+l
(D)
i
T
: (9.33)
We augment the above generators with the following matrix so that all vectors are orthogonal to
each other:
2
6
6
6
6
6
6
6
6
6
6
6
6
6
4
f
1
(D) 0 0
0 f
2
(D)
.
.
.
.
.
.
.
.
. 0
0 0 f
c
(D)
0
c1
0
c1
0
c1
0
l1
0
l1
0
l1
0
1c
0
1c
.
.
.
0
1c
I
cc
0
lc
3
7
7
7
7
7
7
7
7
7
7
7
7
7
5
: (9.34)
The yield of a protocol using the above construction is (nm)=n. Suppose we use an [n;k
1
]
classical binary convolutional code for the bit
ips and an [n;k
2
] classical binary convolutional
code for the phase
ips. Then the convolutional entanglement distillation protocol has yield
(k
1
+k
2
n)=n.
Example 9.4.3. Consider a binary classical convolutional code with the following parity check
matrix:
h
1 +D D 1
i
: (9.35)
171
We can use the above parity check matrix to correct both bit and phase
ip errors in an entan-
glement distillation protocol. Our initial quantum parity check matrix is
2
4
1 +D D 1
0 0 0
0 0 0
1 +D D 1
3
5
: (9.36)
The shifted symplectic product for the rst and second row is D
1
+D. We therefore augment
the above matrix as follows:
2
4
1 +D D 1 D
1
+D
0 0 0 0
0 0 0 0
1 +D D 1 1
3
5
: (9.37)
The above matrix gives a valid stabilizer for use in an entanglement distillation protocol. The
yield of a protocol using the above stabilizer is 1/3.
9.5 Closing Remarks
We constructed a theory of convolutional entanglement distillation. The entanglement-assisted
protocol assumes that the sender and receiver have some noiseless ebits to use as a catalyst for
distilling more ebits. These protocols have the benet of lifting the self-orthogonality constraint.
Thus we are able to import an arbitrary classical convolutional code for use in a convolutional
entanglement distillation protocol. The error-correcting properties and rate of the classical code
translate to the quantum case. Brun, Devetak, and Hsieh rst constructed the method for im-
porting an arbitrary classical block code in their work on entanglement-assisted codes [13, 14].
Our theory of convolutional entanglement distillation paves the way for exploring protocols that
approach the optimal distillable entanglement by using the well-established theory of classical
convolutional coding.
Convolutional entanglement distillation protocols also hold some key advantages over block
entanglement distillation protocols. They have a higher yield of ebits, lower decoding complexity,
and are an online protocol that a sender and receiver can employ as they acquire more noisy ebits.
We suggest that convolutional entanglement distillation protocols may bear some advantages
for distillation of a secret key because of the strong connection between distillation and privacy
172
[73]. We are currently investigating whether convolutional entanglement distillation protocols can
improve the secret key rate for quantum key distribution.
173
Chapter 10
Conclusion
Fly Photon! Trap Ion! Stay Spin!
Which of you we'll implement in?
For quantum coherence
Demands perseverance,
We'll try and God only knows when.
Quantum error correction theory plays a fundamental role in quantum computing and com-
munication. Without error-correcting protocols, quantum computing and communication devices
will fall prey to the hands of decoherence. It is crucial for theorists to continue developing tech-
niques to protect quantum information because a fundamental discovery in the theory might bring
quantum computing closer to reality.
We have augmented the theory of quantum error correction by contributing a theory of
entanglement-assisted quantum convolutional coding. With the ability to import arbitrary clas-
sical convolutional codes, we can now construct quantum convolutional codes that inherit the de-
sirable characteristics of their ancestral classical convolutional codes. Our entanglement-assisted
quantum convolutional coding theory should be useful for future quantum communication engi-
neers if they would like to have codes with a good performance/complexity trade-o.
We have said and again stress that the next important line of investigation is to combine the
quantum turbo coding theory [65] with this theory. Convolutional codes form the constituent codes
of a quantum turbo code and it would be interesting to investigate if we can enhance performance
174
with entanglement-assisted codes as the constituent codes. This investigation might produce
quantum codes that come close to achieving the entanglement-assisted or \father" capacity.
There are also other avenues to pursue|these avenues include any scenario where entanglement
assistance might help. It is useful to inspect the results of quantum Shannon theory to determine
whether we can construct a coding scenario that ts with the constructions in the asymptotic
scenario. We have conducted little analysis of the performance of our codes beyond stating that
they inherit the properties of the imported classical codes. It would be interesting to observe
the performance of these codes in a realistic noisy quantum channel when using syndrome-based
Viterbi processing for correction of quantum error.
We have seen much creativity in the eld of quantum error correction in the past decade because
of the many strange resources available in quantum theory. Experimentalists are increasingly using
an array of quantum error correction techniques with the goal of bringing us closer to having qubits
with good quantum coherence. One can only imagine what resources future quantum coding
theorists will exploit to protect their valuable quantum information.
175
BIBLIOGRAPHY
[1] Salah A. Aly, Markus Grassl, Andreas Klappenecker, Martin R otteler, and Pradeep Kiran
Sarvepalli. Quantum convolutional bch codes. In Proceedings of the 10th Canadian Workshop
on Information Theory (arXiv:quant-ph/0703113), pages 180{183, 2007.
[2] Salah A. Aly, Andreas Klappenecker, and Pradeep Kiran Sarvepalli. Quantum convolutional
codes derived from reed-solomon and reed-muller codes. arXiv:quant-ph/0701037, 2007.
[3] Paul Benio. The computer as a physical system: A macroscopic quantum mechanical hamil-
tonian model of computers as represented by turing machines. Journal of Statistical Physics,
22(5):563{591, May 1980.
[4] Charles H. Bennett and Gilles Brassard. Quantum cryptography: Public key distribution
and coin tossing. In Proceedings of IEEE International Conference on Computers Systems
and Signal Processing, pages 175{179, Bangalore, India, December 1984.
[5] Charles H. Bennett, Gilles Brassard, Claude Cr epeau, Richard Jozsa, Asher Peres, and
William K. Wootters. Teleporting an unknown quantum state via dual classical and einstein-
podolsky-rosen channels. Physical Review Letters, 70(13):1895{1899, Mar 1993.
[6] Charles H. Bennett, Gilles Brassard, Sandu Popescu, Benjamin Schumacher, John A. Smolin,
and William K. Wootters. Purication of noisy entanglement and faithful teleportation via
noisy channels. Physical Review Letters, 76(5):722{725, Jan 1996.
[7] Charles H. Bennett, David P. DiVincenzo, John A. Smolin, and William K. Wootters. Mixed-
state entanglement and quantum error correction. Physical Review A, 54(5):3824{3851, Nov
1996.
[8] Charles H. Bennett, Peter W. Shor, John A. Smolin, and Ashish V. Thapliyal. Entanglement-
assisted classical capacity of noisy quantum channels. Physical Review Letters, 83(15):3081{
3084, Oct 1999.
[9] Charles H. Bennett, Peter W. Shor, John A. Smolin, and Ashish V. Thapliyal. Entanglement-
assisted capacity of a quantum channel and the reverse shannon theorem. IEEE Transactions
on Information Theory, 48:2637{2655, 2002.
[10] Charles H. Bennett and Stephen J. Wiesner. Communication via one- and two-particle op-
erators on einstein-podolsky-rosen states. Physical Review Letters, 69(20):2881{2884, Nov
1992.
[11] C edric B eny, Achim Kempf, and David W. Kribs. Generalization of quantum error correction
via the heisenberg picture. Physical Review Letters, 98(10):100502, 2007.
176
[12] Garry Bowen. Entanglement required in achieving entanglement-assisted channel capacities.
Physical Review A, 66(5):052313, Nov 2002.
[13] Todd A. Brun, Igor Devetak, and Min-Hsiu Hsieh. Catalytic quantum error correction.
arXiv:quant-ph/0608027v2, August 2006.
[14] Todd A. Brun, Igor Devetak, and Min-Hsiu Hsieh. Correcting quantum errors with entangle-
ment. Science, 314(5798):436{439, October 2006.
[15] Todd A. Brun, Igor Devetak, and Min-Hsiu Hsieh. General entanglement-assisted quantum
error-correcting codes. In Proceedings of the IEEE International Symposium on Information
Theory, June 2007.
[16] A. Robert Calderbank, Eric M. Rains, Peter W. Shor, and N. J. A. Sloane. Quantum error
correction and orthogonal geometry. Physical Review Letters, 78(3):405{408, Jan 1997.
[17] A. Robert Calderbank, Eric M. Rains, Peter W. Shor, and N. J. A. Sloane. Quantum error
correction via codes over gf(4). IEEE Transactions on Information Theory, 44:1369{1387,
1998.
[18] A. Robert Calderbank and Peter W. Shor. Good quantum error-correcting codes exist. Phys-
ical Review A, 54(2):1098{1105, Aug 1996.
[19] H. F. Chau. Quantum convolutional error-correcting codes. Physical Review A, 58(2):905{
909, Aug 1998.
[20] H. F. Chau. Good quantum-convolutional error-correction codes and their decoding algorithm
exist. Physical Review A, 60(3):1966{1974, Sep 1999.
[21] Thomas M. Cover and Joy A. Thomas. Elements of Information Theory. Wiley-Interscience,
1991.
[22] Ana Cannas da Silva. Lectures on Symplectic Geometry. Springer, 2001.
[23] Igor Devetak. The private classical capacity and quantum capacity of a quantum channel.
IEEE Transactions on Information Theory, 51:44{55, January 2005.
[24] Igor Devetak, Aram W. Harrow, and Andreas Winter. A resource framework for quantum
shannon theory. arXiv:quant-ph/0512015, 2005.
[25] Igor Devetak, Patrick Hayden, Debbie Leung, and Peter Shor. Triple trade-os in quantum
shannon theory. In preparation, 2008.
[26] Igor Devetak and Peter W. Shor. The capacity of a quantum channel for simultaneous
transmission of classical and quantum information. Communications in Mathematical Physics,
256:287{303, 2005.
[27] David Fattal, Toby S. Cubitt, Yoshihisa Yamamoto, Sergey Bravyi, and Isaac L. Chuang.
Entanglement in the stabilizer formalism. arXiv:quant-ph/0406168, 2004.
[28] Richard P. Feynman. Simulating physics with computers. International Journal of Theoretical
Physics, 21:467{488, 1982.
177
[29] G. David Forney, Markus Grassl, and Saikat Guha. Convolutional and tail-biting quantum
error-correcting codes. IEEE Transactions on Information Theory, 53:865{880, 2007.
[30] G. David Forney and Saikat Guha. Simple rate-1/3 convolutional and tail-biting quantum
error-correcting codes. In Proceedings of the IEEE International Symposium on Information
Theory (arXiv:quant-ph/0501099), 2005.
[31] Daniel Gottesman. Solution set #9.
http://www.perimeterinstitute.ca/personal/dgottesman/QECC2007/Sols9.pdf.
[32] Daniel Gottesman. Class of quantum error-correcting codes saturating the quantum hamming
bound. Physical Review A, 54(3):1862{1868, Sep 1996.
[33] Daniel Gottesman. Stabilizer Codes and Quantum Error Correction. PhD thesis, California
Institute of Technology (arXiv:quant-ph/9705052), 1997.
[34] Markus Grassl and Martin R otteler. Noncatastrophic encoders and encoder inverses for quan-
tum convolutional codes. In Proceedings of the IEEE International Symposium on Information
Theory (quant-ph/0602129), 2006.
[35] Markus Grassl and Martin R otteler. Quantum convolutional codes: Encoders and structural
properties. In Proceedings of the Forty-Fourth Annual Allerton Conference, 2006.
[36] Markus Grassl and Martin R otteler. Constructions of quantum convolutional codes. In
Proceedings of the IEEE International Symposium on Information Theory (arXiv:quant-
ph/0703182), 2007.
[37] Lov K. Grover. A fast quantum mechanical algorithm for database search. In Proceedings
of the 28th Annual ACM Symposium on the Theory of Computing (STOC) (arXiv:quant-
ph/9605043), pages 212{219, 1996.
[38] Lov K. Grover. Quantum mechanics helps in searching for a needle in a haystack. Physical
Review Letters, 79(2):325{328, July 1997.
[39] Aram Harrow. Coherent communication of classical messages. Physical Review Letters,
92:097902, March 2004.
[40] Patrick Hayden, Micha l Horodecki, Andreas Winter, and Jon Yard. A decoupling approach
to the quantum capacity. Open Systems & Information Dynamics, 15:7{19, March 2008.
[41] Patrick Hayden, Peter W. Shor, and Andreas Winter. Random quantum codes from gaussian
ensembles and an uncertainty relation. Open Systems & Information Dynamics, 15:71{89,
March 2008.
[42] Marc Hein, W. D ur, Jens Eisert, Robert Raussendorf, Maarten Van den Nest, and Hans J.
Briegel. Entanglement in graph states and its applications. Proceedings of the Interna-
tional School of Physics \Enrico Fermi" on \Quantum Computers, Algorithms and Chaos"
(arXiv:quant-ph/0602096), July 2005.
[43] Micha l Horodecki, Seth Lloyd, and Andreas Winter. Quantum coding theorem from privacy
and distinguishability. Open Systems & Information Dynamics, 15:47{69, March 2008.
[44] Min-Hsiu Hsieh, Igor Devetak, and Todd Brun. General entanglement-assisted quantum
error-correcting codes. Physical Review A, 76(6):062313, 2007.
178
[45] Min-Hsiu Hsieh, Igor Devetak, and Todd A. Brun. Quantum quasi-cyclic low-density parity-
check codes. In Proceedings of the Asian Conference on Quantum Information Science, pages
101{102, 2007.
[46] Rolf Johannesson and Kamil Sh. Zigangirov. Fundamentals of Convolutional Coding. Wiley-
IEEE Press, 1999.
[47] Rochus Klesse. A random coding based proof for the quantum coding theorem. Open Systems
& Information Dynamics, 15:21{45, March 2008.
[48] Isaac Kremsky, Min-Hsiu Hsieh, and Todd A. Brun. Classical enhancement of quantum error-
correcting codes. Accepted for publication in Physical Review A (arXiv:0802.2414), 2008.
[49] David Kribs, Raymond La
amme, and David Poulin. Unied and generalized approach to
quantum error correction. Physical Review Letters, 94(18):180501, 2005.
[50] David W. Kribs, Raymond La
amme, David Poulin, and Maia Lesosky. Operator quantum
error correction. Quantum Information & Computation, 6:383{399, 2006.
[51] Raymond La
amme, Cesar Miquel, Juan Pablo Paz, and Wojciech Hubert Zurek. Perfect
quantum error correcting code. Physical Review Letters, 77(1):198{201, Jul 1996.
[52] Rolf Landauer. Uncertainty principle and minimal energy dissipation in the computer. In-
ternational Journal of Theoretical Physics, 21:283{297, 1982.
[53] Daniel A. Lidar, Isaac L. Chuang, and K. Birgitta Whaley. Decoherence-free subspaces for
quantum computation. Physical Review Letters, 81(12):2594{2597, Sep 1998.
[54] Seth Lloyd. Universal quantum simulators. Science, 273(5278):1073{1078, 1996.
[55] Seth Lloyd. Capacity of the noisy quantum channel. Physical Review A, 55(3):1613{1622,
Mar 1997.
[56] Zhicheng Luo and Igor Devetak. Eciently implementable codes for quantum key expansion.
Physical Review A, 75(1):010303, 2007.
[57] F. J. MacWilliams and N. J. A. Sloane. The Theory of Error-Correcting Codes. North
Holland, 1983.
[58] Yuri Manin. Computable and uncomputable. Sovetskoye Radio, 1980.
[59] N. David Mermin. Quantum Computer Science. Cambridge University Press, 2007.
[60] Michael A. Nielsen and Isaac L. Chuang. Quantum Computation and Quantum Information.
Cambridge University Press, 2000.
[61] Harold Ollivier and Jean-Pierre Tillich. Description of a quantum convolutional code. Physical
Review Letters, 91(17):177902, Oct 2003.
[62] Harold Ollivier and Jean-Pierre Tillich. Quantum convolutional codes: fundamentals.
arXiv:quant-ph/0401134, 2004.
[63] Harold Ollivier and Jean-Pierre Tillich. Trellises for stabilizer codes: Denition and uses.
Physical Review A, 74:032304, 2006.
179
[64] David Poulin. Stabilizer formalism for operator quantum error correction. Physical Review
Letters, 95(23):230504, 2005.
[65] David Poulin, Jean-Pierre Tillich, and Harold Ollivier. Quantum serial turbo-codes.
arXiv:0712.2888, 2007.
[66] Robert Raussendorf and Hans J. Briegel. A one-way quantum computer. Physical Review
Letters, 86(22):5188{5191, 2001.
[67] Claude E. Shannon. A mathematical theory of communication. Bell System Technical Jour-
nal, 27:379{423, 1948.
[68] Bilal Shaw, Mark M. Wilde, Ognyan Oreshkov, Isaac Kremsky, and Daniel Lidar. Encoding
one logical qubit into six physical qubits. arXiv:0803.1495, 2008.
[69] Peter W. Shor. Algorithms for quantum computation: Discrete logarithms and factoring.
In Proceedings of the 35th Annual Symposium on Foundations of Computer Science, pages
124{134, Los Alamitos, CA, 1994. IEEE Computer Society Press.
[70] Peter W. Shor. Scheme for reducing decoherence in quantum computer memory. Physical
Review A, 52(4):R2493{R2496, Oct 1995.
[71] Peter W. Shor. Polynomial-time algorithms for prime factorization and discrete logarithms
on a quantum computer. SIAM Journal on Scientic Computing, 26:1484, 1997.
[72] Peter W. Shor. The quantum channel capacity and coherent information. In Lecture Notes,
MSRI Workshop on Quantum Computation, 2002.
[73] Peter W. Shor and John Preskill. Simple proof of security of the bb84 quantum key distri-
bution protocol. Physical Review Letters, 85(2):441{444, Jul 2000.
[74] Andrew M. Steane. Error correcting codes in quantum theory. Physical Review Letters,
77(5):793{797, Jul 1996.
[75] Andrew J. Viterbi. Error bounds for convolutional codes and an asymptotically optimum
decoding algorithm. IEEE Transactions on Information Theory, 13:260{269, 1967.
[76] Mark M. Wilde and Todd A. Brun. Entanglement-assisted quantum convolutional coding.
arXiv:0712.2223, 2007.
[77] Mark M. Wilde and Todd A. Brun. Optimal entanglement formulas for entanglement-assisted
quantum coding. Physical Review A, 77:064302, 2008.
[78] Mark M. Wilde and Todd A. Brun. Protecting quantum information with entanglement and
noisy optical modes. In preparation, 2008.
[79] Mark M. Wilde and Todd A. Brun. Quantum convolutional coding with free entanglement.
In preparation, 2008.
[80] Mark M. Wilde and Todd A. Brun. Unied quantum convolutional coding. In Proceedings of
the IEEE International Symposium on Information Theory (arXiv:0801.0821), July 2008.
[81] Mark M. Wilde, Hari Krovi, and Todd A. Brun. Coherent communication with continuous
quantum variables. Physical Review A, 75(6):060303(R), 2007.
180
[82] Mark M. Wilde, Hari Krovi, and Todd A. Brun. Convolutional entanglement distillation.
arXiv:0708.3699, 2007.
[83] Mark M. Wilde, Hari Krovi, and Todd A. Brun. Entanglement-assisted quantum error cor-
rection with linear optics. Physical Review A, 76:052308, 2007.
[84] William K. Wootters and Wojciech H. Zurek. A single quantum cannot be cloned. Nature,
299:802{803, 1982.
[85] Paolo Zanardi and Mario Rasetti. Error avoiding quantum codes. Modern Physics Letters B,
11:1085{1093, 1997.
[86] Paolo Zanardi and Mario Rasetti. Noiseless quantum codes. Physical Review Letters,
79(17):3306{3309, Oct 1997.
181
Abstract (if available)
Abstract
Quantum error-correcting codes will be the ultimate enabler of a future quantum computing or quantum communication device. This theory forms the cornerstone of practical quantum information theory. We provide several contributions to the theory of quantum error correction -- mainly to the theory of "entanglement-assisted'' quantum error correction where the sender and receiver share entanglement in the form of entangled bits (ebits) before quantum communication begins. Our first contribution is an algorithm for encoding and decoding an entanglement-assisted quantum block code. We then give several formulas that determine the optimal number of ebits for an entanglement-assisted code. The major contribution of this thesis is the development of the theory of entanglement-assisted quantum convolutional coding. A convolutional code is one that has memory and acts on an incoming stream of qubits. We explicitly show how to encode and decode a stream of information qubits with the help of ancilla qubits and ebits. Our entanglement-assisted convolutional codes include those with a Calderbank-Shor-Steane structure and those with a more general structure. We then formulate convolutional protocols that correct errors in noisy entanglement. Our final contribution is a unification of the theory of quantum error correction -- these unified convolutional codes exploit all of the known resources for quantum redundancy.
Linked assets
University of Southern California Dissertations and Theses
Conceptually similar
PDF
Entanglement-assisted coding theory
PDF
Quantum error correction and fault-tolerant quantum computation
PDF
Quantum steganography and quantum error-correction
PDF
Applications of quantum error-correcting codes to quantum information processing
PDF
Topics in quantum information and the theory of open quantum systems
PDF
Applications and error correction for adiabatic quantum optimization
PDF
Dynamical error suppression for quantum information
PDF
Lower overhead fault-tolerant building blocks for noisy quantum computers
PDF
Towards efficient fault-tolerant quantum computation
PDF
Error correction and quantumness testing of quantum annealing devices
PDF
Quantum computation and optimized error correction
PDF
Quantum feedback control for measurement and error correction
PDF
Protecting Hamiltonian-based quantum computation using error suppression and error correction
PDF
Topics in quantum cryptography, quantum error correction, and channel simulation
PDF
Open quantum systems and error correction
PDF
Entanglement in strongly fluctuating quantum many-body states
PDF
Destructive decomposition of quantum measurements and continuous error detection and suppression using two-body local interactions
PDF
Quantum information and the orbital angular momentum of light in a turbulent atmosphere
PDF
Quantum and classical steganography in optical systems
PDF
Demonstration of error suppression and algorithmic quantum speedup on noisy-intermediate scale quantum computers
Asset Metadata
Creator
Wilde, Mark McMahon
(author)
Core Title
Quantum coding with entanglement
School
Viterbi School of Engineering
Degree
Doctor of Philosophy
Degree Program
Electrical Engineering
Degree Conferral Date
2008-08
Publication Date
07/31/2008
Defense Date
06/17/2008
Publisher
University of Southern California
(original),
University of Southern California. Libraries
(digital)
Tag
convolutional entanglement distillation,entanglement-assisted quantum error correction,OAI-PMH Harvest,quantum convolutional coding
Language
English
Advisor
Brun, Todd A. (
committee chair
), Haas, Stephan (
committee member
), Lidar, Daniel (
committee member
)
Creator Email
mark.wilde@usc.edu,mwilde@gmail.com
Permanent Link (DOI)
https://doi.org/10.25549/usctheses-m1491
Unique identifier
UC1232594
Identifier
etd-Wilde-2106 (filename),usctheses-m40 (legacy collection record id),usctheses-c127-102283 (legacy record id),usctheses-m1491 (legacy record id)
Legacy Identifier
etd-Wilde-2106.pdf
Dmrecord
102283
Document Type
Dissertation
Rights
Wilde, Mark McMahon
Type
texts
Source
University of Southern California
(contributing entity),
University of Southern California Dissertations and Theses
(collection)
Repository Name
Libraries, University of Southern California
Repository Location
Los Angeles, California
Repository Email
cisadmin@lib.usc.edu
Tags
convolutional entanglement distillation
entanglement-assisted quantum error correction
quantum convolutional coding