Introduction to Quantum Information Processing by kmb15358

VIEWS: 9 PAGES: 23

									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?
Answer: 2m

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