# Introduction to Quantum Information Processing by kmb15358

VIEWS: 9 PAGES: 23

• pg 1
```									Introduction to Quantum
Information Processing

Lecture 17

Richard Cleve

1
Overview of Lecture 17
• Introduction to communication complexity
• Intersection problem (a.k.a. appointment scheduling)
• Restricted equality problem
• Exponential separation in bounded-error setting
• Inner product problem
• Simultaneous message passing model and fingerprinting

2
communication
complexity

3
Classical communication complexity
[Yao, 1979]
x1x2  xn                             y1y2  yn

f (x,y)
E.g. equality function: f (x,y) = 1 if x = y, and 0 if x  y

Any deterministic protocol requires n bits communication
Probabilistic protocols can solve with only O(log(n/)) bits
communication (error probability ), via random hashing
4
Quantum communication complexity
x1 x2  xn                      y1 y2  yn
Qubit communication
qubits
f (x,y)

        entangled qubits       
x1 x2  xn                      y1 y2  yn
Prior entanglement

bits
f (x,y)

5
Appointment scheduling
1   2   3   4   5   ...   n          1   2   3   4   5   ...   n

x= 01101…0                            y= 10011…1

i (xi = yi = 1)
Classically, (n) bits necessary to succeed with prob.  3/4

For all  > 0, O(n1/2 log n) qubits sufficient for error prob. < 

[KS „87] [BCW „98]
6
Search problem
1   2    3     4   5   6   ...   n
Given:    x= 000010…1                                     accessible via queries

log n              i                x          i 
1           b
b                            b  xi
b

Goal: find i{1, 2, …, n} such that xi = 1
Classically: (n) queries are necessary
Quantum mechanically: O(n1/2) queries are sufficient
[Grover, 1996]                                                                     7
1   2   3    4    5   6   ...   n
Alice     x= 011010…0
Bob       y= 100110…1
xy = 0 0 0 0 1 0 … 0

i xy                 i y                       x       x    y
0
           0
0                        0
b                        b
Bob               Alice   Bob

Communication per xy-query: 2(log n + 3) = O(log n)                  8
Appointment scheduling: epilogue
Bit communication:      Qubit communication:

Cost: θ(    n)          Cost: θ(   n1/2
)   (with refinements)

Bit communication       Qubit communication
& prior entanglement:   & prior entanglement:

Cost: θ(    n1/2)       Cost: θ(   n1/2)
[R „02] [AA „03]                                                   9
Restricted version of equality
Precondition (i.e. promise): either x = y or (x,y) = n/2
Hamming distance

(Distributed variant of “constant” vs. “balanced”)

Classically, (n) bits communication are necessary for
an exact solution

Quantum mechanically, O(log n) qubits communication
are sufficient for an exact solution

[BCW „98]                                                   10
Classical lower bound
Theorem: If S  {0,1}n has the property that, for all x, x′  S,
their intersection size is not n/4 then S < 1.99n

Let some protocol solve restricted equality with k bits comm.
● 2k conversations of length k
● approximately 2n/n input pairs (x, x), where Δ(x) = n/2
Therefore, 2n/2kn input pairs (x, x) that yield same conv. C

Define S = {x : Δ(x) = n/2 and (x, x) yields conv. C }
For any x, x′  S, input pair (x, x′ ) also yields conversation C

Therefore, Δ(x, x′)  n/2, implying intersection size is not n/4
Theorem implies 2n/2kn < 1.99n , so k > 0.007n
11
[Frankl and Rödl, 1987]
Quantum protocol
n
define ψ x   (1)
xj
For each x    {0,1}n,                              j
j 1
Protocol:
1. Alice sends x to Bob (log(n) qubits)
2. Bob measures state in a basis that includes y
Correctness of protocol:
If x = y then Bob‟s result is definitely y
If (x,y) = n/2 then xy = 0, so result is definitely not y

Question: How much communication if error ¼ is permitted?
Answer: just 2 bits are sufficient!
12
Exponential quantum vs. classical
separation in bounded-error models
O(log n) quantum vs. (n1/4 / log n) classical

: a log(n)-qubit state
U: unitary operation
(described classically)
on log(n) qubits
M: two-outcome measurement

Output: result of
applying M to U 

[Raz, 1999]                                                      13
Inner product
IP(x, y) = x1 y1 + x2 y2 +  + xn yn mod 2

Classically, (n) bits of communication are required,
even for bounded-error protocols

Quantum protocols also require (n) communication

[KY „95] [CNDT „98] [NS „02]                              14
Recall the BV problem
Let f(x1, x2, …, xn) = a1 x1 + a2 x2 +  + an xn mod 2

Given:              
0 x1H          x
H 1 a1

0 x2H          x
H 2 a2
 H      f     H 

0 xnH          x
H n an
1 bH          b f
H 1(x1, x2, …, xn)
Goal: determine a1, a2 , …, an
Classically, n queries are necessary
Quantum mechanically, 1 query is sufficient
15
Lower bound for inner product
IP(x, y) = x1 y1 + x2 y2 +  + xn yn mod 2

Proof: x1 x2 xn                y1 y2 yn z

Alice and Bob‟s IP protocol

Alice and Bob‟s IP protocol inverted

x1 x2 xn               y1 y2 yn zIP(x, y)

16
Lower bound for inner product
IP(x, y) = x1 y1 + x2 y2 +  + xn yn mod 2

0 0 0      1
Proof: x1 x2 xn
H      H   H    H

Alice and Bob‟s IP protocol

Alice and Bob‟s IP protocol inverted
H      H   H    H
x1 x2 xn
x1 x2 xn   1

Since n bits are conveyed from Alice to Bob, n qubits
communication necessary (by Holevo‟s Theorem)               17
quantum
fingerprints
18
Equality revisited
in simultaneous message model
x1x2  xn                        y1y2  yn

Equality function:
f (x,y)      f (x,y) = 1 if x = y
0 if x  y

Exact protocols: require 2n bits communication

19
Equality revisited
in simultaneous message model
x1x2  xn                           y1y2  yn

classical                                                  classical

f (x,y)             Pr[00] = Pr[11] = ½

Bounded-error protocols with a shared random key:
require only O(1) bits communication
Error-correcting code: e(x) = 1 0 1 1 1 1 0 1 0 1 1 0 0 1 1 0 0 1
e(y) = 0 1 1 0 1 0 0 1 0 0 1 1 0 0 1 0 1 0
20
random k
Equality revisited
in simultaneous message model
x1x2  xn                y1y2  yn

Bounded-error
protocols without
a shared key:
f (x,y)

Classical: θ(n1/2)
Quantum: θ(log n)
[A „96] [NS „96] [BCWW „01]                         21
Quantum fingerprints
Question 1: how many orthogonal states in m qubits?

Let  be an arbitrarily small positive constant
Question 2: how many almost orthogonal* states in m qubits?
(* where |xy| ≤  )
am
Answer: 22     , for some constant a > 0

To be continued during next lecture …

22
23

```
To top