Quantum Circuit Complexity1

Andrew Chi-Chih Yao

Department of Computer Science
Princeton University
Princeton, New Jersey 08544

Abstract
We study a complexity model of quantum circuits analogous to the standard (acyclic)
Boolean circuit model. It is shown that any function computable in polynomial time by a
quantum Turing machine has a polynomial-size quantum circuit. This result also enables
us to construct a universal quantum computer which can simulate, with a polynomial
factor slowdown, a broader class of quantum machines than that considered by Bernstein
and Vazirani [BV93], thus answering an open question raised in [BV93]. We also develop
a theory of quantum communication complexity, and use it as a tool to prove that the
majority function does not have a linear-size quantum formula.

Keywords. Boolean circuit complexity, communication complexity, quantum communi-

cation complexity, quantum computation
AMS subject classications. 68Q05, 68Q15

1
This research was supported in part by the National Science Foundation under grant CCR-9301430.
1 Introduction
One of the most intriguing questions in computation theroy (see e.g. Feynman [Fe82])
is whether computing devices based on quantum theory can perform computations faster
than the standard Turing machines. Deutsch proposed a Turing-like model [De85] for
quantum computations, and constructed a universal quantum computer that can simulate
any given quantum machine (but with a possible exponential slowdown). He subsequently
considered a network-like model, called quantum computational networks, and established
some of their basic properties [De89]. His discussions, however, centered mostly on the
computability issue without regard to the complexity (i.e. cost) issue.
A signicant step towards better understanding the complexity issue in the quantum
Turing model was taken by Bernstein and Vazirani [BV93], who constructed an ecient
universal quantum computer which can simulate a large class of quantum Turing machines
with only a polynomial factor slowdown. In classical computation, Boolean circuit com-
plexity has provided an important alternative framework than Turing complexity. It is
thus of interest to develop an analogous quantum model to address the question whether
quantum devices can perform computations faster than the classical Boolean devices.
A natural place to start is the framework of quantum computational networks as dis-
cussed in [De89]; these networks may be viewed as the quantum analog of conventional
logical circuits (with feedback). In this paper, we single out the subclass of acyclic net-
works, and develop a complexity theory of quantum circuits analogous to the standard
(acyclic) Boolean circuit model. We show that any function computable in polynomial
time by a quantum Turing machine has a polynomial-size quantum circuit. This result,
somewhat unexpectedly, also allows us to construct a universal quantum computer which
can simulate, with a polynomial factor slowdown, a broader class of quantum machines
than that considered by Bernstein and Vazirani [BV93], thus answering an open question
raised in [BV93]. We also develop a theory of quantum communication complexity, and
use it as a tool to prove that the majority function does not have a linear-size quantum
formula.
For other developments on quantum complexity, see Berthiaume and Brassard [BB92]
and Jozsa [Jo91]. Qquantum eects have also been studied in the context of cryptographic
protocols by Wiesner, Bennett, Brassard, Crepeau, and others; for more information on
this subject, see [Br93] for an up-to-date survey and the references in the recent paper
[BCJL93]. For work in quantum systems from the perspective of information theory, see
for example, Kholevo [Kh73] and Schumacher [Schu90].

2
2 Quantum Boolean Circuits
In Deutsch [De89], a quantum computation model dierent from that of quantum Turing
machines was introduced. This is the quantum analog to the classical sequential logical cir-
cuits. In essence, some set of elementary gates is chosen as a basis, where each elementary
gate is some `-input `-output device specied by a 2`  2` unitary matrix U . The function
of the gate needs to be understood in the context of quantum computation (see [De89]).
We summarize it brie y. Let Cd denote the vector space of d-tuples of complex numbers,
P
equipped with an inner product < u; v >= 1id ui vi for u; v 2 Cd . The length of a vec-
tor u is given by (< u; u >)1=2. We say that u; v are orthogonal if < u; v >= 0. Let d = 2` .
Identify each of the d natural unit vectors (those with a single 1 in one component and
0 in all other components) with one of the elements in f0; 1g`. The matrix U transforms
P
any vector u 2 Cd into another vector u0 as follows. For an input  = x~2f0;1g` cx~ x~, the
P
output is given by  = x~2f0;1g` cx~ Ux~;y~ y~. In the above formulas, x~; y~ are interpreted as
unit vectors in Cd (and not as an `-tuple of numbers), and multiplications (by constants)
and summations are with respect to operations in the vector space Cd . By denition, a
unitary matrix transforms mutually orthogonal unit vectors into mutually orthogonal unit
vectors.
A computational network is composed of elementary gates connected together by wires,
with suitably chosen time delays as in the classical sequential circuits. The network has
a set of external input wires and output wires. A computation is carried out by setting
some of the input wires to variables, repetitions allowed, x1 ; x2;


; xn (the rest set to
constants 0; 1), and designate some of the output wires as containing the output variables
y1; y2;


; ym to be sampled at a specied time. We will not give a detailed illustration of
how such networks function, since we are mainly interested in a restricted class of networks
which are analogs of acyclic Boolean circuits. >From now on, by circuits we mean acyclic
circuits.
Let m denote the set of all m-input m-output quantum gates. Deutsch showed [De89]
that, for n  3, any unitary transformation in C2n (as induced by n Boolean variables)
can be computed by a computational network using 3 as a basis, and with only n wires
(initially each wire contains one distinct input variable). It turns out that one can show
that the feedback loops can be avoided (as in classical sequential circuits), but at the
price of adding additional wires (called dummy wires) which are set to constants (0 or
1) initially and take on the same constant values again at the output end. Note that
the same phenomenon arose in reversible computing networks for the classical Boolean
computation (Tooli [To81]).

3
Theorem 1 Let n  1. Any unitary transformation in in C2n (as induced by n Boolean
variables) can be computed by a quantum Boolean circuit using 2O(n) elementary gates
from 3, and with O(n) auxiliary wires.

We use 3 as the basis, and consider quantum Boolean circuits built from these gates.
Since the circuits are acyclic, we don't need to specify the delay time for various gates
and wires. For any quantum Boolean circuit K , with input variables x1; x2;


; xn and
output variables y1 ; y2;


; ym (which is a subset of output wires), we associate with each
input x~ 2 f0; 1gn a probability distribution x~ over f0; 1gm. The probability is dened in
the normal way for quantum computations. For input x~, write the nal quantum state v
P
corresponding to all the output wires (not just the output variables yi ) as v = y~2f0;1gm vy~,
where vy~ is the projection of v when the output variables are set to the values y~. Then
x~ (~y) is equal to the square of the length kvy~k2. We say that fx~ j x~ 2 f0; 1gng is the
distribution generated by K .
The case m = 1 is of special interest, in which case the distribution is specied by a
real number px~ = x~(1) for each x~ 2 f0; 1gn. We say that a string x~ 2 f0; 1gn is accepted
by the circuit K if px~ > 2=3, and rejected by K if px~ < 1=3. If every x~ 2 f0; 1gn is either
accepted or rejected, we say that K computes the language fx~ j x~ is accepted by K g.
The size of a quantum Boolean circuit is the number of elementary gates in the circuit,
and the depth is the maximum length of any (directed) path from any input wire to any
output wire. A circuit is a formula if every input wire is connected to a unique output
variable yi , and that the path connecting them is unique. Note that due to the unitary
nature of quantum computation, the entire circuit cannot look like a forest. The denition
here expresses the condition that, when one looks at only the part of circuit connected by
directed paths to output variables, one sees a forest. (See Figure 1.)
For any language L  f0; 1gn, let CQ (L); DQ(L) be the minimum circuit size, circuit
depth for any quantum circuit computing L. Let FQ (L) be the minimum size of any
quantum formula for computing L.
To illustrate how elementary gates from 3 transform inputs, we consider an example.
For each real number , let D denote the 3-input 3-output elementary gate, with its
associated unitary matrix given by
Ma0b0 c0;abc = aa0 bb0 [(1 ? ab)cc0 + iabhcc0 ];
where ij = 1 if i = j and 0 otherwise, hcc0 = cos(=2) if c + c0 is even and ?i sin(=2)
if c + c0 is odd. (See Figure 2 for the matrix explicitly exihibited.) This family of gates
was introduced by Deutsch [De89] as an extension of the Tooli gates (Tooli [To81])

4
for classical Boolean circuits. Just as Tooli gates are complete for reversible (classical)
Boolean circuits, Deutsch showed that the family D are sucient to implement all quan-
tum connection networks in the sense that any single D with  irrational is universal in
the sense that any computational network can be approximated by networks built from
D . For additional interesting members of 3, see Deutsch [De89].

3 Relationships with Turing Machines

A quantum Boolean circuit K with n input variables is said to (n; t)-simulate a quantum
Turing machine M , if the family of probability distributions px~ , x~ 2 f0; 1gn generated by
K is identical to the distribution of the conguration of M after t steps with x~ as input.
For deniteness, the conguration is encoded as a list of the tape symbols from cell ?t
to t, followed by the state and the position of the head, all naturally encoded as binary
strings.

Theorem 2 Let M be a quantum Turing machine and n; t be positive integers. There

exists a quantum Boolean circuit K of size poly (n; t) that (n; t)-simulates Q.
Corollary If L 2 P , then CQ(Ln) = O(nk ) for some xed k. (Ln is the set of strings
in L of length n.)

This is the quantum analog of the simulation of deterministic Turing machines by

classical Boolean circuits (see Savage [Sa72], Schnorr [Schn76], Pippenger and Fischer
[PF79]). The proof for the quantum version involves subtler arguments. A sketch of the
main steps in the proof is given in Section 6.

4 A Universal Quantum Turing Machine

As noted in [BV93], the simulation of quantum machines is a nontrivial problem, and

needs careful discussions even for the subclass of deterministic reversible machines (see
[Be73] for discussions of such machines). In this section, we answer an open question
about simulating quantum machines raised by Berstein and Vazirani [BV93]. In [BV93],
it was shown that there is a univeral quantum Turing machine (with a polynomial slow-
down) for the class of quantum Turing machines in which the read/write head must move
either to the right or to the left at each step. It was asked whether there is a universal
machine with only a polynomial slow-down when the head is not required to move. This
5
is an interesting question, as it would be an uncomfortable situation in which one may
produce quantum machines but cannot execute them as programs on a general computer
eciently, if the answer turns out to be negative. The next result gives a positive answer.
In this extended abstract, by quantum Turing machines we mean one-tape machines
with its head allowed to move in each quantum step either to the right, or to the left, or
stay in the same place. (For a formal specication, see [BV93].) Theorems 1 and 2 can be
extended to the standard variations of this model. (This will be discussed in the complete
paper.)

Theorem 3 There exists a universal quantum Turing machine that can simulate any
given quantum Turing machine with only a polynomial slow-down.

The proof of Theorem 3 uses Theorem 2. Basically, the universal machine rst con-
structs a quantum circuit K to simulate the given Turing machine, then follows the circuit
diagram deterministically and uses quantum steps to simulate computation of successive
elementary gates. One complication is that since a universal machine has only a nite set
of transitions, one needs to perform approximate computations in the same way as was
done in [BV93]. We omit the details in this extended abstract.

5 Quantum Communication Complexity

Interacting quantum machines can be dened in several ways. We will only introduce
a special model here which can be used to prove lower bounds on circuit complexity.
An interacting pair (M1 ; M2) of quantum Boolean circuits is a partition of a quantum
Boolean circuit such that M1 and M2 have disjoint sets of input variables, and all the
output variables are contained in one side. The communication cost of (M1; M2) is the
number of wires passing between M1 and M2 .
Analogous to the standard notion of communication complexity (see [Ya79]), the quan-
tum communication complexity of a function f (~x; y~) is dened to be the minimum com-
munication cost of any interacting pair of quantum Boolean circuit for computing f with
x~, y~ being the respective inputs to M1 ; M2. It is possible to generalize this concept to
other models, such as the multi-party case with shared variables (Chandra, Furst and Lip-
ton [CFL83]) and the communication complexity for relations (Karchmer and Wigderson
[KW90]). One can also dene quantum communication complexity with no error allowed,
or with quantum help bits, etc. We discuss these matters further in the complete paper.

6
 The determination of communication complexity is more dicult in the quantum case,
we discuss here only one result here. It will be applied to prove a lower bound result about
quantum formula size.
Let x~ = (x1; x2;


; xn), y~ = (y1 ; y2;


; yn) be n-tuples of Boolean variables. Let
f (~x; y~) = 1 if there are at least n 1's among the 2n arguments, and 0 otherwise.

Theorem 4 The quantum communication complexity of f is 

(log log n).

A proof of Theorem 4 is given in Section 7. Let MAJn be the majority function of n

variables. We show that MAJn have no linear-size quantum formula.

Theorem 5 FQ(MAJn)=n ! 1.

To prove Theorem 5, we reduce the problem to one of communication complexity

(using a Ramsey-type argument similar to those used by Hodes and Specker [HS68]), and
then apply Theorem 4. We omit the proofs here.

6 Proof of Theorem 2
Let M be a quantum Turing machine with alphabet set , set of states Q, and transitional
coeecients  (q; a; ; q 0; a0) with  2 f ; ; !g; the symbols ; !;  are interpreted as
moving to the left, to the right, and staying stationary. As is in the notation of [BV93],
 is the amplitude of M to change state to q 0 , print a0 and move according to  , if the
machine is currently in state q and reading tape symbol a.
We construct a quantum circuit which is the concatenation of T identical subcircuits.
Each subcircuit, denoted by K , performs one step of the simulation.
The encoding for the conguration can be chosen dierently from the one specied in
Section 3. As long as it is polynomial-time equivalent to the required format, one can add
an encoding and decoding unit to the front and back ends of the solution to obtain the
required nal network.
For our solution, we use ` = O(2 + dlog2 (jQj + 1)e + dlog2 jje) wires for each of the
2t + 1 cells (numbered from 0 to 2t instead of from ?t to t). The current values of the
wires for cell i will be denoted by si ; qi; ai, where si 2 f0; 1; 2; 3g (two wires), qi 2 Q [ f;g
(dlog2(jQj + 1)e wires) and ai 2  (dlog2 jje wires). The variable si takes on value 0

7
when the head is not at cell i, value 1 when the head is at cell i and has not been actively
invoked in the simulation, and 2 when the head has been used in the simulation and is
now at cell i.
The subcircuit K is constructed as follows. The basic building block is a circuit G
with 3` wires. We build K by cascading 2t ? 1 units of G, each shifting right by ` wires,
and at the end, adding a circuit I whose function is to change all si with values 2 to 1
and 1 to 2. Denote the i-th unit of G by Gi . (See Figure 3.)
Clearly, I is unitary, and can be constructed with O(t) elementary gates. We now
describe how to construct the unitary G.
The central idea is as follows. Think of G as having 3` inputs describing the contents of
three consecutive cells (including the information whether the head is there). We want G
to transform the contents of these cells if the head is at the middle cell and the simulated
step has not occurred (i.e. si = 1 if cell i is the middle cell), according to how the simulated
machine would transform the contents. The obvious rst try for designing G would be to
let G do nothing when si 6= 1. This would not work since some linear combinations of
congurations with si 6= 1 can lead to the same output as when si = 1, and G would not be
unitary. The idea is for G to leave all the realizable linear combinations of congurations
with si 6= 1 untouched, but allowed to alter the values of wires for situations that do not
arise in any computation. This turns out to give enough freedom for a unitary G to exist
(and constructible).
Let us formalize the above conditions. We write down the conditions for the i + 1st
unit G (with wires from cells i ? 1; i; i + 1). Let H denote the subspace of C2 ` spanned 3

by three types of vectors:

(i) jsi?1; qi?1; ai?1; si ; qi; ai; si+1 ; qi+1; ai+1 >
where si 6= 1 and none of si?1 ; si; si+1 is equal to 2;
(ii) vqi? ;ai? ;ai ;ai for all possible values of these parameters, where
1 1 +1

X (q v; aqi? ;a;i?; ;aq0i;;aai0)j2=; q0; a0; 0; ;; a ; 0; ;; a > +

1 1 +1

i?1 i?1 i i+1

X (q
q0 ;a0
0 0 0 0
i?1; ai?1; !; q ; a )j0; ;; a ; 2; q ; ai ; 0; ;; ai+1 > ;
q0 ;a0

(iii) uqi? ;ai? ;a0 ;ai? ;ai for all possible values of these parameters, where
2 2 1

X (q ;uaqi? ;a; i!? ;;aq0;a0; ia?0);aj2i ;=q0; a ; 0; ;; a ; 0; ;; a > :

2 2 1

i?2 i?2 i?1 i i+1

q0

8
 Type (i) vectors and their linear combinations are distinct from, and in fact orthogonal
to, any possible resulted vector when the Turing machine takes a step with head at cell i.
Type (ii) vectors are vectors resulted when the Turing machine takes a step with head at
cell i ? 1 and, afterwards, with the head resting at cell i ? 1 or i. Type (iii) vectors are
vectors resulted when the Turing machine takes a step with head at cell i ? 2 and with
the head resting at cell i ? 1. >From the viewpoint of G, the only input congurations are
linear combinations of two kinds of vectors: those with si = 1, and those from H . Clearly,
these two kinds of vectors are orthogonal. The next lemma states the crucial property
that, for an input w with si = 1 (a vector of the former kind), the execution of one step
of the simulated Turing machine takes w to w0 which will still be orthogonal to H . Write
w as j0; ;; ai?1; 1; qi; ai; 0; ;; ai+1 >.
Lemma 1 For all possible values of ai?1; qi; ai; ai+1, the following vectors are mutually
orthogonal unit vectors and are orthogonal to the subspace H :
X (q ; a ; ; q0; a0)j2; q0; a ; 0; ;; a0; 0; ;; a >
i i i?1 i+1
X
q0 ;a0
+  (qi; ai; ; q 0; a0)j0; ;; ai?1; 2; q 0; a0; 0; ;; ai+1 >
X q0 ;a0
+  (q ; a ; !; q 0; a0)j0; ;; a ; 0; ;; a0; 2; q 0; a > :
i i i?1 i+1
q0 ;a0

Proof By a careful check of the unitarity constraints on the quantum Turing machine
M . Details omitted from this abstract. 2
We put the following requirements on G:
(a) For each v 2 H , G(v ) = v .
(b) Gj0; ;; ai?1; 1; qi; ai; 0; ;; ai+1 >=
X (q ; a ; ; q0; a0)j2; q0; a ; 0; ;; a0; 0; ;; a >
i i i?1 i+1
X (q ; a ; ; q0; a0)j0; ;; a ; 2; q0; a0; 0; ;; a >
+
q0 ;a0
i i i?1 i+1
Xq0 ;a0
+  (q ; a ; !; q 0; a0)j0; ;; a ; 0; ;; a0; 2; q 0; a > :
i i i?1 i+1
q0 ;a0

Lemma 2 There exists a unitary G satisfying the above requirements. Furthermore,

the matrix entries of G are rational functions of entries of transitional coecients of the
simulated Turing machine.
Proof The requirements state that all the vectors in the subspace H remain xed by
G, and that a set of unit vectors mutually orthogonal and orthogonal to H are transformed

9
by G into unit vectors that are mutually orthogonal and orthogonal to H . Such G exists
and can be found by solving a set of linear equations. 2
By Theorem 1, G can be implemented as a quantum Boolean circuit using 2O(`) el-
ementary gates. We have thus specied how K is built as an O(t2O(`) )-size quantum
Boolean circuit. It remains to prove that K correctly simulates one step of the operation
of the given quantum Turing machine M .
It suces to prove that K correctly simulates one step of M when the head is at cell
i for 1  i  2t ? 1. For each Turing machine (pure) conguration , let  ( ) denote the
corresponding unit vector js0; q0; a0; s1; q1 ; a1;


; s2t; q2t; a2t > 2 C(2t+1)`.
Let 0 be any (pure) conguration of M with head at some cell 1  i  2t ? 1. Let
0!
P c after one step of execution by M . We show that, for input ( 0) to K , the
P
output of K is c  ( ).
Let  ( 0) = k0; k1;


; k2t?1, where ki is the vector in C2 t ` corresponding to the
(2 +1)

wire values in K after Gi has just been passed by. We would like to show that k2t?1 is
P
essentially equal to c  ( ) (except that the values of sj would be 2 when they should
be 1).
Clearly, for j = 1; 2;


; i ? 1, the 3-cell segments input to Gj belongs to H (in fact type
(i)), and hence no modications of wire values take place. Thus, kj = k0 for 0  j  i ? 1.
At Gi, since si = 1, ki is obtained from ki?1 according to item (b) in the requirements for
G (see the paragraph before Lemma 2). This is almost P c  ( ), except that the values
of sj would be 2 when they should be 1. We only need to show that this vector remains
the same through the rest of the G units (i.e. Gi+1 ;


; G2t?1).
At Gi+1 , we can calculate ki+1 as follows. Write ki = ki0 + ki00, where ki0 is the portion
with the head at cell i ? 1 and ki00 is the portion with the head at cell i and i + 1. We
can examine how Gi+1 modies ki0 and ki00 separately and add the resulted vectors. It is
easy to see that the 3-cell segment of ki0 input to Gi+1 is a vector in H (in fact a linear
combination of vectors of type (i)), and hence ki0 will not be changed by Gi+1. It is also
easy to see that the 3-cell segment of ki00 input to Gi+2 is a vector in H of type (ii), and
hence ki00 will also not be changed by Gi+1 . We conclude the ki+1 = ki . A similar argument
shows that Gi+2 does not change its input in any way and hence ki+2 = ki+1 = ki .
Note that ki is a linear
combination of vectors of the form js0 ; q0; a0; s1; q1; a1;


; s2t; q2t; a2t) >2 C 2 t `
(2 +1)
with
sj = 2 for some j 2 fi ? 1; i; i + 1g and all other sr = 0. It follows that, by induction,
each Gj (j > i + 2) sees only 3-cell segments belonging to H (type (i) vectors), and hence
kj = ki. This completes the proof of Theorem 2.

10
7 Proof of Theorem 4
Let (M1 ; M2) be a pair of interacting quantum Boolean circuit that computes f with error
probability less than 1=3. We will show that t 
(log log n), where t is the number of
wires crossing between M1 and M2 .
Without loss of generality, we can assume that the t cross wires go alternately from
one machine to the other, with the rst wire being from M1 to M2 , and the last from M2
to M1 . The last wire carries the result of the computation, with the answer being 1 if the
the wire is in state j1 >. Let
= fj0 >; j1 >g. By denition,
is a computational basis
for the signal space of every wire, and the Hilbert space of the circuit is the direct product
of these signal spaces.
Let M1 and M2 contain k +1 and ` wires, respectively. The Hilbert space of the circuit
can be regarded as the direct product of three Hilbert spaces H1, H2, and H3, where H1
and H2 come from the wires in M1 and M2 , and H3 is the signal space of one wire which
goes from M1 to M2 and back t times. Clearly, H1 and H2 have dimensions 2k and 2` ,
and H3 has dimension 2.
Let ~e = (e1 ; e2;


; et) 2
t, where ei denotes the state of the i-th cross wire. For any
input x 2 f0; 1gn to M1 , let ax;~e 2 H1 be the output state of M1 obtained from the input
state as follows: at cross wire # 1, project the current state s00 2 H1  H3 to s1 2 H1
by restricting the component of s00 in H3 to e1 ; then at cross wire # 2, with s1 having
evolved within M1 to state s01 , force the # 2 cross wire state to be e2, i.e. make the state
of the circuit on the M1 side s2 = s01
e2 ; following the circuit to the point of cross wire
# 3, project the current state s02 2 H1  H3 (s2 having evolved into s02 ) to s3 2 H1 by
restricting the component of s02 in H3 to e3 ;


, etc. In a similar way, for any y 2 f0; 1gn,
let by;~e 2 H2 be the output state of M2 obtained by the circuit from input y .
It is clear that, for input (x; y ) to the circuit (M1 ; M2), the output state is equal to
X ax;~e
by;~e
et :
~e=(e1 ;


;et)2
t
Thus, the probability of the circuit accepting input (x; y ) is
px;y = k
Xa 2;
x;~e
by;~ek
~e2E
where E =
t?1  fj1 >g.
The idea of the proof is to show that, if t is not large enough, then there will be
two y; y 0 2 f0; 1gn with dierent number of 1's in them, say n1 and n2 , but with similar
features in by;~e ; by0;~e such that px;y  px;y0 for all x. This leads to a contradiction if we
11
select an x with its number of 1's between n ? n1 and n ? n2 , since the circuit should
accept exactly one of the pairs (x; y ), (x; y 0). We now make it precise.
For every e; e0 2 E , let a^x;e;e0 =< ax;e ; ax;e0 >, and ^by;e;e0 =< by;e; by;e0 >.
Lemma 3 px;y = Pe;e02E a^x;e;e0^by;e;e0 for all x; y.
Proof Omitted. 2
For each y , dene the feature vector of y by
vy = ((m; m0) j e; e0 2 E );
where m = bRe(^by;e;e0 )(log2 n)3c and m0 = bIm(^by;e;e0 )(log2 n)3c. Clearly, there are at
most (((log2 n)3 ) + 1)2E distinct possible feature vectors.
2

Assume that t < (log2 log2 n ? log2 log2 log2 n ? 10)=2. We will derive a contradiction
(for large n). Clearly, E = 2t?1 < (log2 n=20 log2 log2 n)1=2. Thus, there are at most
((log2 n)3 + 1)2E < n dierent feature vectors. It follows that there are two y; y 0 with
2

dierent number of 1's, say n1 > n2 , but with vy = vy0 .

Using Lemma 3, we have for any x
jpx;y ? px;y0 j 
X ^a 0 j^b 0 ? ^b 0 0 j
x;e;e y;e;e y ;e;e


X ^a 0 2(log n)?3
e;e0 2E
x;e;e 2
e;e0 2E
 2E 2=(log2 n)3
 (log2 n)?1:
Let x 2 f0; 1gn be a string with its number of 1's being in the interval [n ? n1 ; n ? n2]. Then
one of px;y ; px;y0 should be less than 1=3 and the other greater than 2=3, since exactly one
of the pairs (x; y ), (x; y 0) is accepted by the circuit. This is a contradiction. This proves
the theorem.

8 Conclusions
We have initiated a study of Boolean circuit and communication complexity in the quan-
tum computation context. It is hoped that this line of investigation leads to interesting
new mathematical questions, and perhaps sheds light on other aspects of quantum com-
putation such as the quantum Turing machine model. The results presented here seem to
be encouraging.

12
References
[Be73] C. Bennett, \Logical reversibility of computation," IBM J. Res. Develop. 17
(1973), 525-532.
[BB92] A. Berthiaume and G. Brassard, \The quantum challenge to structural com-
plexity theory," Proceedings of 7th IEEE Conference on Structure in Complexity
Theory, 1992.
[BV93] E. Bernstein and U. Vazirani, \Quantum complexity theory," Proceedings of
1993 ACM Symposium on Theory of Computing, 1993.
[Br93] G. Brassard, \Cryptology column - quantum cryptology: a bibliography," Sigact
News, vol. 24, no. 3, 1993, 16-20.
[BCJL93] G. Brassard, C. Crepeau, R. Jozsa, and D. Langlois, \A quantum bit commit-
ment scheme provably unbreakable by both parties," Proceedings of 1993 IEEE
Symposium on Foundations of Computer Science, 1993.
[CFL83] A. Chandra, M. Furst, and R. Lipton, \Multi-party protocols," Proceedings of
1983 ACM Symposium on Theory of Computing (1983), 94-99.
[De85] D. Deutsch, \Quantum theory, the Church-Turing principle and the universal
quantum computer," Proceedings of the Royal Society of London, Volume A400
(1985), 97-117.
[De89] D. Deutsch, \Quantum computational networks," Proceedings of the Royal So-
ciety of London, Volume A425 (1989), 73-90.
[Fe82] R. Feynman, \Simulating physics with computers," International Journal of
Theoretical Physics 21 (1982), 467-488.
[HS68] L. Hodes and E. Specker, \Lengths of formulas and elimination of quantiers
I," in Contributions to Mathematical Logic, edited by H. Schmidt, K Schutte
and H. Thiele, North-Holland (1968), 175-188.
[Jo91] R. Jozsa, \Characterizing classes of functions computable by quantum paral-
lelism," Proceedings of the Royal Society of London A435 (1991), 563-574.
[KW90] M. Karchmer and A. Wigderson, \Monotone circuits for connectivity require
super-logarithmic depth," SIAM Journal on Discrete Mathematics 3 (1990),
255-265.

13
[Kh73] A. Kholevo, \Bounds for the quantity of information transmitted by a quantum
communication channel," Problemy Peredachi Informatsii 9 (1973), 3-11. En-
glish translation of the journal by IEEE under the title Problems of Information
Transfer.
[PF79] N. Pippenger and M. Fischer, \Relations among complexity measures," Journal
of ACM 26 (1979), 361-381.
[Sa72] J. Savage, \Computational work and time on nite functions," Journal of ACM
19 (1972), 660-674.
[Schn76] C. Schnorr, \The network complexity and Turing machine complexity of nite
functions," Acta Informatica 7 (1976), 95-107.
[Schu90] B. Schumacher, \Information from quantum measurements," in Complexity,
Entropy, and the Physics of Information, Santa Fe Institute Studies in the
Sciences of Complexity, Volume VIII, edited by W. Zurek, Addison-Wesley,
1990, 29-38.
[To81] T. Tooli, \Bicontinuous extensions of invertible combinatorial functions,"
Mathematical Systems Theory 14 (1981), 13-23.
[Ya79] A. Yao, \Some questions on the complexity of distributive computing," Proc.
1979 STOC, 1979, 209-213.

14