Introduction to Quantum Information Processing C

Document Sample
Introduction to Quantum Information Processing C Powered By Docstoc
					       Introduction to
Quantum Information Processing
             CS 467 / CS 667
           Phys 467 / Phys 767
           C&O 481 / C&O 681

            Lecture 17 (2005)
Richard Cleve
DC 3524
cleve@cs.uwaterloo.ca
Course web site at:
http://www.cs.uwaterloo.ca/~cleve/courses/cs467   1
                      Contents
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    2
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    3
  Bell’s Inequality and its violation
  Part II: computer scientist’s view:
 input:      s                                    t



output:        a                                  b
Rules: 1. No communication after inputs received      st   ab
          2. They win if ab = st                    00   0
                                                      01   0
With classical resources, Pr[ab = st] ≤ 0.75        10   0
                                                      11   1
But, with prior entanglement state 00 – 11,
Pr[ab = st] = cos2(/8) = ½ + ¼√2 = 0.853…                4
         The quantum strategy
• Alice and Bob start with entanglement
   = 00 – 11

• Alice: if s = 0 then rotate by A =  /16
                                                                  st = 11

  else rotate by A = + 3/16 and measure
                                                                 3/8    st = 01 or 10
                                                                  /8
                                                                  -/8


• Bob: if t = 0 then rotate by B =  /16                               st = 00

  else rotate by B = + 3/16 and measure

                     cos(A – B ) (00 – 11) + sin(A – B ) (01 + 10)

 Success probability:
 Pr[ab = st] = cos2(/8) = ½ + ¼√2 = 0.853…
                                                                             5
Nonlocality in operational terms

                  information
                  processing
                      task

                                 !

   classically,                   quantum
 communication                  entanglement
   is needed

                                               6
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    7
                  Magic square game
Problem: fill in the matrix with bits such that each row has
even parity and each column has odd parity

                    a11 a12 a13   even
                    a21 a22 a23   even

                    a31 a32 a33   even
                    odd odd odd
Game: ask Alice to fill in one row and Bob to fill in one column

They win iff parities are correct and bits agree at intersection
Success probabilities:     8/9   classical and 1 quantum
[Aravind, 2002]                        (details omitted here)   8
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    9
 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
                                                               10
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)

                                                                 11
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    12
       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]
                                                                          13
                     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]                                                                     14
                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)                  15
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]                                               16
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    17
 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]                                                   18
             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
                                                               19
[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!
                                                                 20
   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]                                                      21
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    22
                      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]                              23
      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
                                                         24
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)



                                                              25
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)               26
• The Bell inequality and its violation
   – Physicist‟s perspective
   – Computer Scientist‟s perspective
• The magic square game
• Communication complexity
   –   Equality checking
   –   Appointment scheduling (quadratic savings)
   –   Are exponential savings possible?
   –   Lower bound for the inner product problem

• Simultaneous message passing and fingerprinting
                                                    27
           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

                                                       28
                 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
                                                                     29
                                   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]                         30
          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

The states can be constructed via a suitable (classical) error-
correcting code, which is a function e :{0,1}n  {0,1}cn where,
for all x ≠ y, dcn ≤ Δ(e(x),e(y)) ≤ (1− d )cn (c, d are constants)
                                                               31
             Construction of almost
               orthogonal states
                  cn
             1
Set x          (1)
                               e ( x )k
                                          k      for each x{0,1}n (log(cn) qubits)
             cn   k 1



Then xy            1   cn
                                          [ e ( x )e ( y )]k          2e( x), e( y )
                         cn
                             (1)
                             k 1
                                                                k  1
                                                                            cn

Since dcn ≤ Δ(e(x),e(y)) ≤ (1− d )cn, we have |xy| ≤ 1− 2d


By duplicating each state, xx … x, the pairwise
inner products can be made arbitrarily small: (1− 2d )r ≤ 
                                                                                m/r
Result: m = r log(cn) qubits storing 2n = 2(1/c)2                                     different states
                                                                                                  32
          Quantum fingerprints
Let 000, 001, …, 111 be 2n states on O(log n) qubits such
that |xy| ≤  for all x ≠ y

Given xy, one can check if x = y or x ≠ y as follows:
                                       if x = y, Pr[output = 0] = 1
  0     H               H            if x ≠ y, Pr[output = 0] = (1+ 2)/2
 x              S
                   W
 y              A
                   P


                                        Note: error probability can
Intuition: 0xy + 1yx    be reduced to ((1+ 2)/2)r
                                                                       33
                      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]                         34
Quantum protocol for equality
  in simultaneous message model
x1x2  xn                                  y1y2  yn

            x                   y



                   x    y
                                      Recall that, with a
                   Orthogonality      shared key, the
                        test          problem is easy
                                      classically ...
                                                        35
36