Docstoc

Jones Polynomial

Document Sample
Jones Polynomial Powered By Docstoc
					                                                                                 Overview
                                                                                Four Talks

                                                                • A Rosetta Stone for Quantum Computation
                                                                • Quantum Algorithms & Beyond
                                                                • Distributive Quantum Computing
                              atica
                       Inform
                               i
                       Per Can



                                                                • Topological quantum Computing and the
                                                                  Jones Polynomial

                                                                • A Quantum Computing Knot Theoretic Mystery
                                                                  -- Can be found on my webpage.




       Topological Quantum Computing

                          and the
                Jones Polynomial                                This work is in collaboration with
              Samuel J. Lomonaco, Jr.
            Dept. of Comp. Sci. & Electrical Engineering
                            Sci.                                         Louis H. Kauffman
             University of Maryland Baltimore County
                       Baltimore, MD 21250
                Email:        Lomonaco@UMBC.EDU
          WebPage: http://www.csee.umbc.edu/~lomonaco
          WebPage: http://www.csee.umbc.edu/~lomonaco




                                                      L-O-O-P




        This work is supported by:                               This talk is about an algorithm found in:
•     The Defense Advance Research Projects                     Dorit, Aharonov,
                                                                Dorit, Aharonov, Vaughan Jones,and Zeph Landau,
       Agency (DARPA) & Air Force Research                      On the Quantum Algorithm for Approximating the
Laboratory (AFRL), Air Force Materiel Command,                         Polynomial,
                                                                Jones Polynomial,
USAF Agreement Number F30602-01-2-0522.                         http://arxiv.org/abs/quant-ph/0511096
                                                                http://arxiv.org/abs/quant-

•        The National Institute for Standards
and Technology (NIST)                                              We will refer to this paper as AJL

•          The Mathematical Sciences Research
Institute (MSRI).                                                and also about the paper
•   L-O-O-P    The L-O-O-P Fund.                                  Lomonaco, and Kauffman, Topological Quantum
•              The Institute of Scientific Interchange                                     Polynomial,
                                                                  Computing and the Jones Polynomial,
                                                                  http://arxiv.org/abs/quant-
                                                                  http://arxiv.org/abs/quant- ph/0605004




                                                                                                                  1
                                                   Jones                                       m      World
                                                     Polynomial                          Quantu
                                                              ???
                                                                                        Quantum States

                                                                                          Superposition


                                   atica                                                                      Unitary
                            Inform
                            Per Can
                                    i                                           Measurement
                                                                                                             Evolution


                                                                                              Entanglement




                                                                                         Quantum Algorithms




                  Quantum Algorithms Zoo                         Other
                                                                 Algs.
                                                                 Algs.
                                                                                   Fundamental Questions ???

             Deutsch-
             Deutsch-Jozsa
                                       Grover ’s
                                       Grover’                              What are the limits of Quantum
                                                               Jones
                Simon’
                Simon’s                                      Poly. Alg .    Computation ???
                                    Amplitude
                                     Amplif.
                                     Amplif.
                 Shor’
                 Shor’s                                        Trace
                                      Algs.
                                      Algs.                  Estimation
               Q. Hidden
             Subgroup Algs.
                      Algs.
                                    Quadratic
                                                                New         Will future quantum computers be general
                                     Speedup
                                                                            purpose or special purpose devices ???
              Exponential                    Q. Random
               Speedup
 Quantum                                       Walks
                                                           Adiabatic
Simulation
                                           Non-
                                           Non-Classical     Algs
  of Q.                      Related
 Systems                                     Behavior
                               ???                            ???




                                                                                         Complexity
                          Questions ???

   Why are we interested in the Jones                                      But the Jones polynomial is in the complexity
   polynomial ???                                                          class #P !!!.

   Why do we want to find a fast, i.e.
   polytime,
   polytime, quantum algorithm for the Jones
   polynomial ???
                                                                                    So what !!!
                   DoD
   Why should the MoD be interested in
   the Jones polynomial ???
                                                                                    So what ! Who cares ?




                                                                                                                           2
                       The Class #P                                                     Questions ???
                            SAT)     NP-
The satisfiability problem (SAT ) is NP-complete                     So a #P problem is computationally harder than
                                                                        NP-
                                                                     an NP - complete problem.
  Boolean expr
  in CNF form
                                       Yes ?       Decision                                              polytime,
                                                                     Why do we want to find a fast, i.e. polytime,
  e ( x1 ,K , xn )     Satisfiable                                   quantum algorithm for the Jones polynomial ???
                          ???                      Problem
                                       No ?
                                                                     Answer:                                  BQP.
                                                                     Answer: This would mean that P#P is in BQP.
                                                                     But since NP is in P#P, this implies that NP is in
  The corresponding #P class is                     Counting         BQP.
                                                                     BQP. Hence, a polytime quantum algorithm for the
                                                                     Jones polynomial implies there exists a polytime
                                                    Problem                                  NP-
                                                                     quantum algorithm for NP - complete problems.
                         Find # of         r
                                           u           r
                                                       u
    e( x1 ,K , x n )     Satisfying
                           Values
                                          {       }
                                                   n
                                                              }
                                         # ξ∈{ 0,1 : e(ξ) =True
                                                                                            Wow !!!
    Boolean expr                                                              But this is probably not the case!!!
    in CNF form




                       Questions ???                                                On the other hand …
                                      polytime,
 Why do we want to find a fast, i.e. polytime, quantum
 algorithm for the Jones polynomial ???                                     held,              belief:
                                                                     Widely held, but unproven belief : There is
                                                                                                             NP-
                                                                     no quantum algorithm that computes an NP-
  Answer:
  Answer: This would mean that        P # P ⊆ BQP                    complete problem in polynomial time.
               But       NP ⊆ P # P
                                                                     So can there really be a polytime quantum
               Ergo,     NP ⊆ BQP                                    algorithm for computing the Jones
  Therefore, there exists polytime quantum                           polynomial ??? Probably not !!!
                 NP-
  algorithms for NP-Complete problems !

                           Wow !!!                                   But creating a quantum algorithm for the
                                                                     Jones polynomial might well give us some
          But this is probably not the case!!!                       insight why NP is not in BQP ???




                       Questions ???
                                                                  We will now discuss the polytime algorithm:

        • How can we compute the Jones
        polynomial on a quantum computer ?

                                                                  Knot   K=                                Jones polynomial


        • How fast is the resulting quantum                       Integer       k
                                                                                           AFJKL
                                                                                          Algorithm            (        )
                                                                                                           V K e 2π i / k ± ε
        algorithm ?                                                                                        with exponentially
                                                                  Precision     ε                          small probability of
                                                                                                           error




                                                                                                                                  3
     We will now discuss the following theorem:

Theorem.
Theorem . (AJL)
                                                                               Quick
For a given braid β in Bn with m crossings
and for a given integer k , there is a quantum
                                                                                 Overview
algorithm which is polynomial in n, m , k , which
with all but exponentially (in n, m , k) small                                      to
                                                                                       Knot
probability, outputs a result in the closed
interval

       (               )                  (                )
  Re V tr ( e2 π i / k ) − εd n −1 , Re V t r ( e 2π i / k ) + ε d n −1 
      β                                  β                                             Theory
                                                                                     Skip to braids

for ε which is inverse polynomial in n, k, m .
The same is true for the imaginary part.




           Placement Problem: Knot Theory
                                                                         ¡3                           Knot Diagram
  • Ambient space = ¡             3       Orientation
                                          Preserving

  • Group G = AutoHomeo( ¡ )              3                                                                  Labeled
                                                                                                             Vertex


            S1                                men
                                                 t#1
                                         Place                                                                           Labeled
                                                                                                                         Vertex
                                         Placement#2                               Labeled
                                                                                   Vertex
       ~K




Def.
Def .
                                                                                       • Planar four valent graph with
       K
           1




           if g ∈ G s.t . gK 1 = K 2
                                                                                       • Labeled vertices
           2




Problem.
Problem. When are two placements the same ?
                                          ?
                      K
               K
                      ~
                     1
                     2




                           Reidemeister Moves                                      Comment: R1 is not a Physical Move
  R0



 R1


                                                                              R1
R2




R3
                                                                                                A Discontinuous Move !


                           These are local moves !




                                                                                                                                   4
 Differential Geometry: The Frenet Frame                 Differential Geometry: The Frenet Frame

                         3-
Each point of a curve in 3- space is naturally                                   3-
                                                        Each point of a curve in 3- space is naturally
                  3-                           frame.
associated with a 3- frame, called the Frenet frame.                      3-                           frame.
                                                        associated with a 3- frame, called the Frenet frame.


                                                                                            B
                                                                        B
                B = binormal = TxN




                                                                                                         B
                                                                                    T




                                                                                                    T
                                                                                                    T
                                                                        T
                               T = tangent                   B




                                                                                                                 B
                                                                                                          T
                                                                                                          T
                                                                                        N

                                                                                                N
                                                                                N
                                                                            N




                                                                                                                 T
                   N=normal
                   N= normal




                                                                                                        N
 Differential Geometry: The Frenet Frame                         Comment: R1 is not a Physical Move

 In other words, given a smooth curve
                                                        R1
        x ( t ) = ( x1 ( t ), x 2 ( t), x 3 ( t ))
    3-
 in 3 - space, there is a naturally associated
 curve
                     A( t )
 in    SO(3)
                                                                                 A Discontinuous Move !




                                                        Example of Application of Reidemeister Moves
 When do two Knot diagrams represent the
       same or different knots ?

                                                                            R3                          R2, R2


            Reidemeister).
Theorem (Reidemeister). Two knots (or
links) diagrams represent the same knot
(or link) iff one can be transformed                                                                                 R1
                                                                 Sa
                                                                 S
                                                                   me
                                                                   me




into the other by a finite sequence of
                                                                   Kn
                                                                     ot
                                                                      tT




Reidemester moves.
                                                                        Ty
                                                                          p
                                                                          pe




                                                                                                            R1




                                                                                                                          5
            What is a knot invariant ?

    Def.
    Def . A knot invariant I is a map
        I : Knots → MathematicalDomain
    that takes each knot K to a mathematical
                                                             What Is the Braid
    object I(K) such that

                        ⇒ I     (      )=         (     )
                                                               Group Bn ???
         K




                                              I
    K
         ~
        1




Consequently,

            I(       ) ≠ I( )⇒
                                     ~K
        2

            K
         K
                 1




      The Jones polynomial is a knot invariant.
            K K
                 2
         K
        1


                 1
                 2
        2




                                                                    A Braid
Why is the braid group important for Q Comp ?

•    The representations of the Symmetric Sn are                     Hat Box
     the basic building blocks for the representation
     of the unitary group U used in quantum mechanics,

•    The braid group B n “ sits above ” the symmetric   Bn
     group Sn , i.e., there is a natural epimorphism


• Thus, new representations of the braid group          Sn
    B n will give us new representations of the
    unitary group U , i.e., quantum gates

• Claim: These quantum gates can be implemented in
  Claim:
    quantum systems that are resistant to decoherence            3 Strand braid β
                           obstructions,
    because of topological obstructions, e.g., in terms
    of the fractional quantum Hall effect, anyonic systems




                     Two Equal Braids                            Two Unequal Braids




                           =                                            ≠

                 β1 = β 2                                       β1 ≠ β 2


                                                                                      6
                     Shorthand Notation                                         Product of Braids

      Hat Box




                          Shorthand
                           Notation
                                                                        Times
                                                                                            =           =
3 Strand braid β                                  β
                                                                            β1 • β 2 = β 3


                  Inverse of of a Braid                                Generators of the Braid Group Bn




                                           =
                                                                                   Bn is generated by

                             =
                                                                 The braid group

         Times


                                                                    L                   L       L       L
              β • β −1 = 1                                        b1                  b2         L      bn−1
To construct the inverse of a braid, take the mirror
image of each crossing, and then reverse the order
of the crossings.




      Relations Among the Generators of Bn

                                                 ster 3 M
                                                          ov e     bi bi +1bi = bi +1bbi +1 , 1 ≤ i < n
                                                                                      i
                                      Reidemei



     bi bi +1bi = bi +1bbi +1 , 1 ≤ i < n
                        i


                                                                                        =
      bi bj = bjbi , for i − j ≥ 2

   Skip to presentation




                                                                                                               7
                                                                                        A Presentation of the Braid Group Bn
        bi bj = bjbi , for i − j ≥ 2
                                                                                                         bibi +1 bi = bi+1bi bi+1 , 1 ≤ i < n −1                  
                                                                                                                                                                  
                                                                                    b1 , b2 ,K, bn−1 :                                                            
                                  =                                                
                                                                                                       bibj = bjbi , i − j > 1,1 ≤ i , j < n − 1                  
                                                                                                                                                                   


                                                                                                                                 Complete
                                                                                    Generators                                    set of
                                                                                                                                 Relations




                      Almost”
          A Braid Is “Almost” a Permutation                                                             Braids as Words

                                                                                     Every braid β in Bn can be written as a
                             bbi +1bi = bi +1bi bi +1 , 1 ≤ i < n −1               product of braid generators b1 , b 2 ,K , bn − 1
                                                                          
                               i

 Bn =  b1 , b2 ,K, bn−1 :                                                          and their inverses b1−1 , b2 −1 ,K , bn −1−1
                          bb j = bj bi , i − j > 1,1 ≤ i , j< n− 1        
                           i                                                                 L
                                                                                        β=    ∏b     j( i )
                                                                                                           ε (i )
                                                                                                                    = bj 1) ε (1) bj ( 2 )ε (2) L bj ( L )ε ( L)
                                              Natural                                         i =1
                                            Epimorphism


                               bi bi +1 bi = bi + 1bi bi +1 , 1 ≤ i < n − 1   
                                                                              
B n =  b1, b2 ,K , bn −1 :         bi 2 = 1, 1 ≤ i < n − 1                    
Sn
      
                           bi b j = b j bi , i − j > 1, 1 ≤ i , j< n− 1       
                                                                                     where ε (i ) = ±1                                   Braid word w




                                                                                                            Another Perspective
             Anyons: A Very Brief Overview
             Anyons:
                                                                                        A Braid Represents the Movement of n Holes
                                                                                                         in a Disc
     Anyons are quantum systems that are
     confined to two dimensions. They were                                                                           This braiding can be used to
     first proposed by Nobel Laureate F.                                                                             represent Anyon exchanges
     Wilczek. See for example,
     Wilczek.
                                                                                                                                      A      B
       Wilczek, F., Fractional statistics and
       Wilczek,
              superconductivity,
       anyon superconductivity, World
       Scientific Press, (1990).
                                                                                                                     Anyonic braiding corresponds to
      Anyons can used to explain the fractional                                                                      a Unitary transformation
      quantum Hall effect
                                                                                               Recall: Q.M.= Qroup Rep. Theory




                                                                                                                                                                       8
       Anyons Can Also Fuse or Split              Anyons:
                                                  Anyons: A Very Brief Overview (Cont.)


                                              Quantum Topology gives us the tools needed
                                              to find new unitary representations based
                         AC B                 on fusing and braiding

                                               These new unitary transformations are
                                               created with an object called a unitary
                                               topological modular functor which we call
                                                               model.
                                               simply an anyon model.


                                                  Recall: Q.M.= Qroup Rep. Theory




                                                           From Braids to Knots

Knots                                                       The Markov Trace


     from
                                                            Closure of a Braid




         Braids                                                 Close Braid



   The Markov trace closure

                                              Braid   β                                 Closed
                                                                                         Braid   β tr




Can Every Knot Can Be Constructed from the    When Does the Closure of Two Braids Produce the
          Closure of Some braid?                               Same Link ?

                                             Theorem (Markov). Two braids β 1 and β 2 produce the
                                             same link under Markov trace braid closure iff there
                                             exists a finite sequence of Markov moves that
          Alexander).
Theorem (Alexander). Every                   transforms one braid into the other.
knot is the closure of a braid.
                                             Definition.
                                             Definition . Let β be a braid in B n .   Then the
                                             Markov moves are defined as:


                                                 M1    β a β ' = bi ±1 gβ gbim1, 1 ≤ i < n

 Skip Markov Moves
                                                 M2       β a β g bn+1±1 ∈ Bn+1




                                                                                                        9
                   The Markov 1 Move                                    The Markov 2 Move


 M1     β a β ' = bi ±1g β gbi m1, 1 ≤ i < n                  M2      β a β g bn+1±1 ∈ Bn+1
          …
                                                                         …
        bi - 1                                                                                   Apply R1
          …                                                              β
         β
                                                                         …            …
          …           …
                                                                             bn+1
        bi                                                               …
          …




                 From Braids to Knots

             The Plat Closure of a Braid

                                                                                 The
                                                           Aharonov- Freedman- Jones- Kitaev- Landau (AFJKL)
                                                           Aharonov- Freedman- Jones- Kitaev-
                                                                                Algorithm


                       Close Braid




Braid    β                                 Closed
                                            Braid   β pl




Strategy for Computing Jones Polynomial


• We use the Jones representation                                            What is the
                 ρ A : Bn → TLn( d )                            Temperley-Lieb algebra
                                                                Temperley-
                                   Temperley-
  from the braid group Bn to the Temperley-
  Lieb algebra TLn (d) , where d is an
                   (d)                                                             (d)
                                                                                TLn(d)
  indeterminate complex number, and where A
  is a complex number defined by d= -A2-A-2.
                                    d=-                                             ???




                                                                                                               10
                                   (d)
Diagrammatic Representation of TLn (d)                                  (d)
                                              Two Equal Elements of TLn (d)

              Rectangle




                                                           =

        An element X of       (d)
                          TLn (d)                        X1 = X2




      Two Unequal Elements of TLn (d)
                                  (d)                Shorthand Notation

                                         Rectangle




                 ≠                                         Shorthand
                                                            Notation




      X1 ≠ X2                             X                                   X




               Product                                  Product




     Times
                    =               =    Times         =           =          =d


      X1 • X 2 = X 3


                                                                                   11
                  Temperley-                 (d)
Generators of the Temperley-Lieb Algebra TLn (d)                                                     (d)
                                                               Relations Among the Generators of TLn (d)

   The Temperley- Lieb algebra
       Temperley-                    (d)
                                 TLn (d) is generated by

                                                                   Ei E j = E j Ei , for i − j ≥ 2

    L            L               LL L
                                                                   Ei Ei ±1Ei = Ei , 1 ≤ i < n

    1          E1           E2         L          E n−1
                                                                   E i 2 = dE i , 1 ≤ i < n




                                 (d)
      The Markov Trace Trn : TLn (d) à C                           Properties of the Markov Trace

                                          Original number
                                            of strands
                                                            The Markov trace is the unique trace satisfying
                                                            the following conditions:

                                                               •     Trn ( 1 ) = 1
            
           Trn→                         =       = d 2 −n      •    Trn ( XY ) = Trn ( YX )

                                                               •    X ∈ TLn −1 ( d ) ⇒ Trn −1 ( XEn ) =
                                                                                                          1
                                                                                                            Tr ( X )
                                                                                                          d n

                                                Number
                                                of Loops




                                                            Strategy for Computing Jones Polynomial


                                                            • We use the Jones representation
    How to Compute the                                                   ρ A : Bn → TLn ( d )
                                                                                                Temperley-
                                                               from the braid group Bn to the Temperley-
     Jones Polynomial                                                           (d)
                                                               Lieb algebra TLn (d) , where d is an
                                                               indeterminate complex number, and where A
                                                                                                 d=-
                                                               is a complex number defined by d= -A2-A-2.




                                                                                                                       12
        Temperley-                (d)
        Temperley-Lieb algebra TLn(d)                                                      Temperley-                (d)
                                                                                           Temperley-Lieb algebra TLn(d)
Let n be an integer, and let                 d be a complex number                 Let n be an integer, and let                    d be a complex number


    Temperley-
The Temperley- Lieb algebra                    (d)
                                           TLn (d) is the algebra                      Temperley-
                                                                                   The Temperley- Lieb algebra                      (d)
                                                                                                                                TLn (d) is the algebra
generated by                                                                       generated by
                  { I , E1, E2 , K , En −1 }                                                         { I , E1, E2 , K , En −1 }
 with relations                                                                     with relations

                   EiE j = EjEi , i − j ≥ 2                                                           EiE j = EjEi , i − j ≥ 2
                   E i E i± 1 E i = E i                                                               E i E i± 1 E i = E i
                   E i 2 = dE i                                                                       E i 2 = dE i
 and with an involution * defined by the conjugate                                  and with an involution * defined by the conjugate
 linear extension of
                              (E                      )                             linear extension of
                                                                                                                  (E                       )
                                   ∗                                                                                  ∗
                                   i 1 E i 2 L E ir       = E ir E ir − 1 L E i1                                       i1   E i 2 L E ir       = E ir E ir − 1 L E i1




          The Jones Representation
                                                                                     Strategy for Computing Jones Polynomial
• Let d be an indeterminate complex number, and let
   A be a complex number such that d = - A 2 - A - 2 .                               • We use Jone’s definition of the Jones poly
                                                                                              Jone’

• Let  B n denote the braid group, and let TLn (d )
                            group,             (d)
                                                                                         • Let β be an element of B           t=A
                                                                                                                                       n                                -4
  denote the Temperley- Lieb algebra.
             Temperley-      algebra.                                                    • Let β be the closure of β
                                                                                                 tr


                                                                                         • Let Tr : TL (d) à C be the standard Markov
                                                                                                      n (d)   n
   The Jones representation                                                               trace into the complex numbers C

                   ρ A : Bn → TLn ( d )                                                   • Let w(β ) be the writhe of β ,i.e.,
                                                                                                w(β
                                                                                             w(β
                                                                                             w(β ) = sum of exponents in braid word for β
   is the group representation defined by

                      bi a AI + A−1Ei                     =    A          + A−1      Then the Jones polynomial is given by

                      bi −1 a A−1 I + AEi                                             Vβ tr ( A−4 ) = − A2 w ( β ) d n −1Trn ( ρ A ( β ) )
                                                          = A−1 + A



                  Strategy (Cont.)                                                   The Graph Gk
                                                                                                                   1              2            3                K-1


 We now wish to compute a good approximation                                                                           0 1 0 L 0 0
 of the value of the Jones poly at e2πι /k for k                                                                       1 0 1       
                                                                                       Adjacency                                   
 a positive integer.                                                                                                    1          
                                                                                        Matrix                    Mk =             
                                                                                                                       M     O
        • Let
                                                                                                                                    
                                                                                                                               0 1
                  Gk be the graph                                                                                      
                                                                                                                       0           
                                                                                                                              L 1 0 ( k− 1 )×( k −1)

                                                …
                                                                                                                                   
                  1       2            3                        K-1                    Eigenvector
                                                                                                                        v
                                                                                                                        u
                                                                                                                        λ = ( λ l ) = ( sin ( π l / k )                  )
                      K - 1 vertices & k- 2 edges                                                                                                           l∈{ 1,2,K ,k− 1
                                                                                       Corresponding                                                                      }
                                                                                        Eigenvalue
                                                                                                                             2cos(π l/ k )




                                                                                                                                                                              13
   The Graph Gk
                        1     2         3   K-1                                     Strategy (Cont.)
                                                              We will use the graph Gk to construct a

  • Let d be equal to the eigenvalue 2cos(π/k)                                              Temperley-
                                                              unitary representation of the Temperley-
                                     2cos(π                                    (d)
                                                              Lieb algebra TLn (d) .

   • Since d = -A -A
                   2    , there are four
                        -2                                    • Let Pn,k = set of paths in Gk of length n

   possible chooses for A , namely                            which start at the vertex 1 .

                  A = ± e± iπ / 2 k                           • Let H n,k be the Hilbert space with
                                                              orthonormal basis
    We choose
                  A = e − iπ / 2k
                                                                                      {p          : p ∈ Pn, k}




                                    (d)
   Constructing a Unitary Rep of TLn(d)                                                   (d)
                                                         Constructing a Unitary Rep of TLn(d) (Cont.)

                                                          • We begin by identifying each path     p in Pn,k with
                                                           a binary string of length n , where we interpret a bit

   • We now construct a unitary representation
                                                                             left”
                                                           0 to be “to the left” (a “Zig”) , and bit 1 to be “ to
                                                                                     Zig”
                                                               right”
                                                          the right” (a “Zag” )
                                                                          Zag”
          Temperley-                 (d)
   of the Temperley-Lieb algebra TLn (d)
                                                           • For each path   p , let p i -1] be the subpath
                                                           corresponding to the first i - 1 bits of p . Let p [i+2
          Φ : TLn ( d ) → £U ( Hn ,k )                     be the subpath corresponding bits i+2 to the last bit
                                                           of p. Finally, let p[i..i+1] be the subpath
                                                           corresponding to bits i and i+1 of p.


                                                           • Let   ei (p ) be the endpoint of the subpath pi - 1] .
                                                              So       e i ( p ) ∈ {1,2,K , k − 1}




                                 (d)
Constructing a Unitary Rep of TLn(d) (Cont.)                                              (d)
                                                         Constructing a Unitary Rep of TLn(d) (Cont.)

                                                           • We define each                          Φi       as

  • To define the rep Φ : TL (d ) → £U ( H )
                                    n             n ,k
                                                                   0                                                                           if p [ iL i +1] = 00

   all that we need do is to specify the images                     λ ei ( p) −1        λ e ( p ) − 1λ e ( p) +1   
                                                                   
                                                                    λe ( p )        p +
                                                                                    
                                                                                              i             i
                                                                                                                       p i − 1] 10 p[ i + 2   if p[ i L i+ 1 ] = 01
   Φ i = Φ ( Ei ) on each of the generators Ei                      i                  
                                                                                         
                                                                                                 λe i ( p )           
                                                                                                                      
   of the Temperley-Lieb algebra TLn (d) ,
          Temperley-                 (d)                 Φi p =
                                                                       λe i ( p ) − 1λ ei ( p) +1  i − 1]           λ                
                                                                                                   p 0 1 p[ i + 2 +  e i ( p ) + 1    p    if p [i L i +1 ] = 1 0
   and then show that the Φi ' s are compatible                    
                                                                   
                                                                               λe i ( p )          
                                                                                                   
                                                                                                                       λe ( p )
                                                                                                                       i
                                                                                                                                        
                                                                                                                                        
                                   Temperley-
   with the relations defining the Temperley-
                                                                                                                                               if p [ i L i + 1 ] = 1 1
   Lieb algebra                                                    0




                                                                                                                                                                          14
                                 (d)
Constructing a Unitary Rep of TLn(d) (Cont.)                                                                                       (d)
                                                                                                  Constructing a Unitary Rep of TLn(d) (Cont.)

  • We define each                     Φi       as                                                 • We then verify that Φ is actually a
                                                                                                   representation by checking that it is
                                                                         [ iL i + 1]
                                                                                       = 00
              0
                      Zig-
                      Zig-Zag                  Zag-
                                               Zag-Zig
                                                                  if p
                                                                                                                                 Temperley-
                                                                                                   campatible with the following Temperley-Lieb
                            p + ( Blah) p 10 p
                                                                                                   algebra identities:
              ( Blah− )                        i −1]     [ i +2
                                                                  if p   [ iLi +1]
                                                                                     = 01
                                                                                                               Ei E j = E j E i , i − j ≥ 2
Φi p =
                  ( Blah)    i −1]
                            p 01 p     [i +2
                                               + Blah+ p if p        [iLi +1]
                                                                                 = 10                          E i E i± 1 E i = E i
                            Zig-Zag
                            Zig-                       Zag-
                                                       Zag-Zig                                                 E i 2 = dE i
                  0                                               if p   [i Li +1 ]
                                                                                       = 11                                                         Φi Φj = ΦjΦi , i − j ≥ 2
                                                                                                   i.e., the following hold                         ΦΦi±Φ = Φ i
                                                                                                                                                     i  1 i

                                                                                                                                                    Φi2 = dΦi




                      Strategy (Cont.)                                                                                                  (d)
                                                                                                               The Unitary Rep Φ of TLn (d)

                                                                                                   • Recall that we define each                  Φ i as
   • We now seek to construct a trace
   ~                                                                                                           0                                           if p [ iL i +1] = 00
   Tr: Im(Φ) à
   Tr: Im(Φ)àC which is compatible with the
                                            ~
                        (d)
   Markov trace on TLn (d) , i.e., a trace Tr                                                                   ( Blah− )    p + ( Blah) pi −1]10 p[i +2   if p[iLi +1] = 01
   such that the following diagram is
   commutative:                                                                                   Φi p =
                                                                                                                   ( Blah)   pi −1] 01 pi +2 + Blah+ p
                                                                                                                                        [
                                                                                                                                                           if p[iLi +1] = 10
  TLn ( d )           
                       →    Φ
                                               Im ( Φ ) ⊂ £U ( H n ,k )
                                                                                                                                                           if p [ i Li +1] = 11
                                                     ±
                                                                                                                   0
                   Tr ]                            ↓ Tr
                                                                                                   Lemma. The representation Φ : TLn ( d ) → £U ( H n, k )
                                                                                                   Lemma.
                                                   £                                               maps each ket p to a linear combination of
 Markov                                                                              Compatible
 Trace                                                                                 Trace       kets each labeled by a path of the same
                                                                                                   length and the same enpoint as p .




         Constructing a Compatible Trace                                                                                                (d)
                                                                                                               The Unitary Rep Φ of TLn (d)

                                                                                                  Lemma.
                                                                                                  Lemma. The representation Φ : TLn ( d ) → £U ( H n, k )
   • Let Pn,k,m = set of paths in Gk of length n
                                                                                                  maps each ket p to a linear combination of
                                                                                                  kets each labeled by a path of the same
   which start at the vertex 1 and end at
   vertex m .                                                                                     length and the same enpoint as p .

                                                                                                   Theorem.
                                                                                                   Theorem .

    • Let H     be the Hilbert space with
                  n,k,m
                                                                                                        k −1                            k− 1
                                                                                                    Φ = ⊕ Φ( m) : TLn ( d ) → ⊕ £U ( Hn, k ,m ) ⊂ £U ( Hn, k )
    orthonormal basis                                                                                   m= 1                           m= 1


                      {p             : p ∈ Pn ,k ,m }                                              where       Φ   ( m)
                                                                                                                          :TLn ( d ) →£U ( Hn, k, m )

                                                                                                                                k −1
                                                                                                   Hence,       Im ( Φ) ⊆ ⊕ £U ( Hn, k, m )
                                                                                                                                m =1




                                                                                                                                                                                  15
 Constructing a Compatible Trace (Cont.)                                                                        Constructing a Compatible Trace (Cont.)
                                    k−1

                  ⊕
                                                                                                                                     k−1

Recall TL ( d ) →
                                           (m)
                               Φ=         Φ

                                                     ⊕ £U ( H
                                                     k −1
                                                                                     )    ⊂ £U ( Hn, k )
                                                                                                                             Φ=⊕ Φ
                                                                                                                                           (m)
                                                                                                                                                       k−1
                                                                                                                  TLn ( d ) →                      ⊕ £U ( H                        )      ⊂ £U ( Hn, k )
                                    m=1
         n                                                                 n ,k ,m                                             m=1
                                                     m =1                                                                                                                    n ,k ,m
                                                                                                                                                       m =1
                           Tr ]                                        ±                                                       Tr ]
                                                                       Tr ?                                                                                           ±
                                                                                                                                                                      Tr ?
                                                                  £
                                                                                                                                                                     £
                        k −1
 So Φ ( X ) =
              ⊕ Φ (X)                                                                                           Claim : The following linear combination is
                                                                                                                Claim:
                 (m)

                        m =1                                                                                    compatible with the Markov trace.
 This give us a lot of latitude in choosing a                                                                                                                 k −1
                                                                                                                      Tr n ( Φ ( X ) ) =
                                                                                                                      ±                                       ∑λ             Tr ( Φ( m ) ( X ) )
 trace. We can choose from among all                                                                                                     1
 possible linear combinations of the standard
                                                                                                                                                                         m
                                                                                                                                         N                    m =1
 traces
                { Tr ( Φ
                   (m)
                                              ( X )) : 1≤ m < k }                                                where        N=     ∑
                                                                                                                                           k −1
                                                                                                                                           m=1
                                                                                                                                                  λ m Dim ( H n, k ,m )




                                          Recall …                                                              Constructing a Compatible Trace (Cont.)
                                                 1          2              3                     K-1
    The Graph Gk
                                                                                                                                     k−1

                                                                                                                                ⊕1 Φ
                                                                                                                                           (m)
                                                                                                                                Φ=                     k−1


                                                   0 1 0 L 0 0
                                                                                                                  TLn ( d )   →
                                                                                                                                m=
                                                                                                                                                       ⊕ £U ( H
                                                                                                                                                       m =1
                                                                                                                                                                             n ,k ,m   )      ⊂ £U ( Hn, k )
                                                   1 0 1                                                                     Tr ]
     Adjacency                                                                                                                                                      ±
                                                                                                                                                                      Tr ?
                                                    1          
      Matrix                                  Mk =             
                                                   M     O                                                                                                         £
                                                           0 1
                                                   
                                                   0           
                                                         L 1 0 ( k− 1 )×( k −1)
                                                                                                               Claim : The following linear combination is
                                                                                                                Claim:
     Eigenvector                                                                                                compatible with the Markove trace.
                                                 v
                                                 u
                                                 λ = ( λ l ) = ( sin ( π l / k )                         )                                                    k −1
                                                                                                                      Tr n ( Φ ( X ) ) =
                                                                                                                      ±                                       ∑λ             Tr ( Φ( m ) ( X ) )
                                                                                                                                         1
                                                                                                            }
                                                                                              l∈{ 1,2,K ,k− 1
                                                                                                                                                                         m
     Corresponding                                                                                                                       N                    m =1
      Eigenvalue
                                                                                                                 where               ∑        λ Dim ( H n, k ,m )
                                                                                                                                           k −1
                                                                                                                              N=           m=1 m
                                                  2cos(π l/ k )




         Proving Our Trace is Capatible                                                                          Where are we ???                                                                            Compatible
                                                                                                                                                                                                               Trace
                                                                                                                                                                                   k −1

                                                                                                                                            ⊕                                 Φ=           Φ (m )
 We prove each of the following:                                                                                We have Bn → TL n ( d ) →
                                                                                                                            ρ              A                                       m= 1
                                                                                                                                                                                                    U ( H n ,k )

   •     ±
         Tr o Φ ( 1 ) = 1                                                                                                                                                          ]                      ±
   •
                                                                                                                  Jones Rep                                                                             ↓ Tr n
         ±                ±
         Tr o Φ ( XY ) = Tr o Φ ( YX )
                                                                                                                                                                                   T rn
                                                                                                                                                                                                         £
   •
                                                                                                                              Markov Trace
                           ±                   1±
         X ∈ TLn− 1 ( d) ⇒ Tr o Φ ( XE n −1 ) = Tr o Φ ( X )
                                               d                                                                                                                                       d = 2cos ( π / k )
Since the Markov trace is the unique trace satisfying                                                                                                                                  
the above three conditions, we have that the following
                                                                                                                where d = -A2-A-2 and                                                  A = e
                                                                                                                                                                                              − i π / 2k


diagram is commutative.                                                                                                                                                                 t = A−4 = e 2π i / k
                 k −1
                                                                                                                                                                                       
              Φ = ⊕ Φ( m )                k− 1
T Ln ( d )    m  →
                  =1
                                          ⊕ £U (H
                                          m =1
                                                            n , k ,m   )     ⊂           £U   (H )n ,k
                                                                                                                Moreover, we have the Jones polynomial
                                                                                                                                                         ( )
                                                                                                                  Vβ tr ( t ) = − A                                  d n− 1Trn ( ρ A ( β ) )
               Tr ]                                    ±                                                                                             2 w β tr
                                                     ↓ Tr
Markov                                                                                        Compatible
Trace                                                £                                          Trace




                                                                                                                                                                                                                          16
                         Where are we ???                                                                                         Where are we ???
We need to compute Trn ( ρ A ( β ) )                                                                                  All we need to do is to compute the traces of
But                             ±
             Trn ( ρ A ( β )) = Trn  ( Φ o ρ A ) ( β ) 
                                                       
                                                                                                                                     (                  )
                                                                                                                           U ( m ) = Φ ( m ) o ρ A ( β ) for 1 ≤ m < k

                                        ±                          
                                               k −1
                                                                                                                     Let
                                                                                                                                     L
                                      = Trn  ⊕ Φ (m ) o ρ A  ( β )                                                       β = ∏ b j( l )ε ( l)
                                             m =1                                                                              l =1
                                              k −1
                                                                Tr  ( Φ               o ρ A ) ( β )
                                        1
                                      =
                                        N
                                              ∑λ
                                              m =1
                                                            m      
                                                                               (m )
                                                                                                                      Let    U j( m ) = ( Φ ( m ) o ρ A ) b j         ( )      for 1 ≤ m < k
                                                                                                                                                                                            1≤ j <n
Thus, all we need to do is to compute the
traces of the unitary transformations                                                                                 Then
                                                                                                                             U ( m ) = ( Φ( m ) o ρ A ) ( β ) = ∏ U ( m ) j ( l )     (                 )
                                                                                                                                                                                 L                          ε (l )

         U ( m ) = ( Φ( m ) o ρ A ) ( β )                          for 1 ≤ m < k                                                                                               l =1




  Where are we ???                                                                                                                                   Overview
Thus, all reduces to the problem of computing                                                                           The algorithm consists of two phases:
the traces of

                                 ∏ (U                       )
                                  L                             ε (l )
                     U (m) =                 (m)
                                                   j ( l)
                                                                                                                        Phase 1: Compilation Phase – We compile
                                 l= 1                                                                                   Mathematics into hardware.
                                                                                                                                                    Program)
                                                                                                                            (Braid Word = Computer Program )
 for 1 ≤ m < k ,
 where                                                                                                                  Phase 2: Execution Phase – We run our
                                                                                                                        compiled program
                     U j( m ) = ( Φ( m ) o ρ A ) bj         ( )




  Compilation Phase for Estimating V β                                                       Tr   (e   2π i / k
                                                                                                                  )      Execution Phase for Estimating V β                                        Tr   (e   2π i / k
                                                                                                                                                                                                                        )
  Select                                                                                          Select                      Algorithm AJK (n , k )
                        k     Input
   k for                                                                                            &                           Trace = 0
                                                                                                  Input
  e2π i / k                                                                                                                     loop m = 1 K k − 1
                                                                Software Compilation                                              Tracem = 0 and λm = sin ( π m / k )
                                                                                                                                  loop p ∈ P ,k ,m
                                                                                                                                            n

                                                                                      β = ∏ j= 1 bj( i )ε ( i )
                                                                                                  L
                                                                                                                                     Re = 0 and Im = 0
                                                                          n
      Hardware Compilation                                                                                                           loop Iteration = 1 K NumberIterations
                                                                                                                                         ReBit = QRe ( p ) and ImBit = QIm ( p )
    {U   j
             ( m)
                                         }
                    :1 ≤ m < k , 1 ≤ j < n                                                                                               Re = Re + ( −1 )
                                                                                                                                                            ReBit
                                                                                                                                                                    and Im = Im − ( − 1)
                                                                                                                                                                                           ImBit


                                                                     Hardware Compilation                                            end Iteration-loop
                                                                                                                                    Trace m = Tracem + ( Re + i *Im) / NumberIterations
                                                                          {U   (m )
                                                                                      : 1 ≤ m < k}                                end p -loop
                                                                                                                                  Trace = Trace + λm * Tracem
                                                                     Hardware Compilation                                       end m -loop
                                                                                                                                output Trace
                                        Stop                             {Q R em, Q I mm :1 ≤ m < k }                           endAlgorithm




                                                                                                                                                                                                                            17
    Execution Phase for Estimating V β                                       Tr   (e   2π i / k
                                                                                                  )    Execution Phase for Estimating V β                                     Tr   (e   2π i / k
                                                                                                                                                                                                   )
          Algorithm AJK (n , k )                                                                           Algorithm AJK (n , k )
            Trace = 0                                                                                        Trace = 0
            loop m = 1 K k − 1                                                                               loop m = 1 K k − 1
              Tracem = 0 and λm = sin ( π m / k )                                                              Tracem = 0 and λm = sin ( π m / k )
              loop p ∈ P ,k ,m
                        n                                                                                      loop p ∈ P ,k ,m
                                                                                                                         n

                 Re = 0 and Im = 0                                                                                Re = 0 and Im = 0
                 loop Iteration = 1 K NumberIterations                                                            loop Iteration = 1 K NumberIterations
                   ReBit = QRe ( p ) and ImBit = QIm ( p )                                                          ReBit = QRe ( p ) and ImBit = QIm ( p )
                   Re = Re + ( −1 )           and Im = Im − ( − 1)                                                  Re = Re + ( −1 )           and Im = Im − ( − 1)
                                      ReBit                          ImBit                                                             ReBit                          ImBit


                 end Iteration-loop                                                                               end Iteration-loop
                Trace m = Tracem + ( Re + i *Im) / NumberIterations                                              Trace m = Tracem + ( Re + i *Im) / NumberIterations
              end p -loop                                                                                      end p -loop
              Trace = Trace + λm * Tracem                                                                      Trace = Trace + λm * Tracem
            end m -loop                                                                                      end m -loop
            output Trace                                                                                     output Trace
            endAlgorithm                                                                                     endAlgorithm




    Execution Phase for Estimating V β                                       Tr   (e   2π i / k
                                                                                                  )   The Two Quantum Subroutines QRe & QIm
          Algorithm AJK (n , k )
            Trace = 0


                                                                                                      • QRe – Used to compute the real part
            loop m = 1 K k − 1
              Tracem = 0 and λm = sin ( π m / k )

                                                                                                                  of trace, i.e., Re ( Tr ( U ) )
              loop p ∈ P ,k ,m
                        n

                 Re = 0 and Im = 0
                 loop Iteration = 1 K NumberIterations
                   ReBit = QRe ( p ) and ImBit = QIm ( p )
                   Re = Re + ( −1 )           and Im = Im − ( − 1)
                                      ReBit                          ImBit


                 end Iteration-loop
                Trace m = Tracem + ( Re + i *Im) / NumberIterations
                                                                                                      • QIm – Used to compute the imaginary part
              end p -loop
                                                                                                                  of the trace, i.e., Im ( Tr ( U ) )
              Trace = Trace + λm * Tracem
            end m -loop
            output Trace
            endAlgorithm




          The Quantum Subroutines QRe




     In                                           Out
                                                                                                      Trace Estimation
U                  QRe                                        Re Tr ( U ) 
                                                                          




                                                                                                                                                                                                       18
                                                                      Unitary
Wiring Diagram for Unitary Transformation                          Transformation           Controlled -U
                U :H → H
                                                                                    Contr - U : H 2 ⊗ H → H 2 ⊗ H
                                                   n-Dimensional
                                                   Hilbert Space                                                        2n-Dimensiomal
                                                                                                                        2n-
                                                                             Control-Qubit
                                                                             Control-
                                                                                                                         HilbertSpace

                                                                                0
                                                                             ⊗                                         0 ⊗ψ
             ψ                   U                   Uψ                      ψ                    U

                                                                                      0 ⊗ψ
                                                                                                     Do Zilch if control = 0
                                                                             Output = 
                                                                                       1 ⊗U ψ
                                                                                                     Apply U if control = 1




   Unitary                                                            Unitary
Transformation      Controlled -U                                  Transformation           Controlled -U

             Contr - U : H 2 ⊗ H → H 2 ⊗ H                                          Contr - U : H 2 ⊗ H → H 2 ⊗ H

                                                 2n-
                                                 2n-Dimensiomal                                                         2n-Dimensiomal
                                                                                                                        2n-
        Control-
        Control-Qubit                                                        Control-Qubit
                                                                             Control-
                                                  HilbertSpace                                                           HilbertSpace

         1                                                         a 0 +b1
        ⊗                                       1 ⊗U ψ                 ⊗                                              a 0 ⊗ψ +b 1 ⊗ ψ
                                                                                                                                   U
        ψ                   U                                          ψ                          U

                 0 ⊗ψ
                               Do Zilch if control = 0                               0 ⊗ψ
                                                                                                     Do Zilch if control = 0
        Output =                                                            Output = 
                  1 ⊗U ψ
                               Apply U if control = 1                                 1 ⊗U ψ
                                                                                                     Apply U if control = 1




                            Trace(U)
                 Estimating Trace(U )                                  Engineering a Probability Distribution

   Hadamard
             H=
                1 1     1                                              0              H             H               Output = 0 or 1
   Transform             
                 2  1 − 1
                                                                        ⊗
                                                                                              U                          Measure
                                                                         p

                   H                 H                              Basis elt                                     (
                                                                                     Prob (0 ) − Prob ( 1) = Re U pp     )       Real part of
                                                                                                                                p-th diag elt
                                                                    If we repeat many times, then
                                                                          #1's − #0's
                            U
                                                                            #Bits
                                                                                      ≈ Re ( p | U | p ) = R e U pp      (      )
                                                                   Thus, we have constructed a probability distribution
        We have used Quantum Mechanics to                          for computing the real part of
        engineer a probablity distribution !!!
                                                                                 Trace (U ) = ∑ U pp = ∑ p | U | p
                                                                                                  p           p




                                                                                                                                                19
               The Quantum Subroutines QRe                                   The Quantum Subroutines QIm


                                                                        In                    Out

                                                                    U           QIm                      Im Tr ( U ) 
                                                                                                                     
          In                         Out

U                   QRe                    Re Tr ( U ) 
                                                       
                                                                                            1 0
                                                                                  H         0 i    H
                                                                                                



                                                                                        U




                       Summary                                                        Question
   We have constructed a polytime quantum
                                                                    Can we transform the AFJKL quantum
   algorithm:
                                                                    algorithm using polynomial interpolation into a
                                                                    polytime quantum algorithm that computes the
                                                                    Jones polynomial V K ( t ) with exponentially
Knot   K=                                    Jones polynomial       small probability of error ?

Integer        k
                         AFJKL
                                                 (        )
                                             V K e 2π i / k ± ε
                                                                                 No !
                        Algorithm
                                             with exponentially
                                                                    Answer:
                                                                    Answer:
Precision       ε                            small probability of
                                             error




                                           Jones
                                             Polynomial
                                                      ???




                             atica
                      Inform
                              i
                      Per Can




                                                                                                                          20

				
DOCUMENT INFO