Quantum Programming in Python

Quantum 1D Simple Harmonic Oscillator and Quantum Mapping Gate

A Senior Project

presented to

the Faculty of the Physics Department

California Polytechnic State University, San Luis Obispo

In Partial Fulfillment

of the Requirements for the Degree

Bachelor of Science

by

Matthew Hoff

March, 2013

2013
c Matthew Hoff
 Table of Contents

Section Page

Abstract 3

Introduction 3

Example Notebook for Quantum Simple Harmonic Oscillator 4

Code for Quantum Simple Harmonic Oscillator 18

Code for Tests of Quantum Simple Harmonic Oscillator 32

Example Notebook for Quantum Mapping Gate 35

Code for Quantum Mapping Gate 46

Code for Tests of Quantum Mapping Gate 50

Appendix 52

2
 Abstract

A common problem when learning Quantum Mechanics is the complexity in the

mathematical and physical concepts, which leads to difficulty in solving and under-
standing problems. Using programming languages like Python have become more
and more prevalent in solving challenging physical systems. An open-source com-
puter algebra system, SymPy, has been developed using Python to help solve these
difficult systems. I have added code to the SymPy library for two different systems,
a One-Dimensional Quantum Harmonic Oscillator and a Quantum Mapping Gate
used in Quantum Computing.

Introduction

The goal of SymPy is “to become a full-featured computer algebra system (CAS) while keeping
the code as simple as possible in order to be comprehensible and easily extensible" (“SymPy").
Through SymPy, I have submitted two projects to their library on GitHub, which “is a web-
based hosting service for software development projects that use the Git revision control system"
(“GitHub"). The first project is a Quantum Simple Harmonic Oscillator (QSHO), which is
explained in a sample notebook using an IPython notebook. The goal of coding the QSHO is
to allow others to learn how the simple harmonic oscillator is applied to a quantum system as
well as allowing others to use components of the QSHO in other future projects. The second
project is a Quantum Mapping Gate (QMG), which again is explained in greater detail using
an IPython notebook. The QMG allows for custom creation of logic gates for quantum systems
and can be used in addition to or instead of the current quantum gates. Both projects were
coded using the Python language and have been added to the SymPy library.

Abstract and Introduction 3

 Heading 1

One-Dimensional Quantum Simple Harmonic Oscillator

Imports

Before examining the Quantum 1D Simple Harmonic Oscillator, the relevant files need to be loaded to create simple
harmonic oscillator states and operators.

In [1]: %load_ext sympy.interactive.ipythonprinting

from sympy import Symbol, Integer
from sympy.physics.quantum import (Dagger,
qapply,
represent,
InnerProduct,
Commutator)
from sympy.physics.quantum.sho1d import (RaisingOp,
LoweringOp,
NumberOp,
Hamiltonian,
SHOKet,
SHOBra)

Background

For a detailed background on the Quantum Simple Harmonic Oscillator consult Griffith's Introduciton to Quantum
Mechanics or the Wikipedia page "Quantum Harmonic Oscillator"

Components

States

The Quantum 1D Simple Harmonic Oscillator is made up of states which can be expressed as bras and kets. And those
states are acted on by different operators. Looking at the states, there are two types of states that can be made: a generic
state 'n' or numerical states. Passing a string (i.e. 'n') to SHOBra or SHOKet creates a generic bra or ket state, respectively.
And passing an integer to SHOBra or SHOKet creates a numerical bra or ket state.

SHOBra and SHOKet are passed the information from SHOState and from the Bra and Ket classes, respectively. SHOState
contains the information to find the Hilbert Space of the state as well as the energy level. SHOState also has all the
information and properties from State because State is passed into SHOState.

Quantum Simple Harmonic Oscillator Example Notebook 4

In [2]: b = SHOBra('b')
b0 = SHOBra(0)
b1 = SHOBra(1)

k = SHOKet('k')
k0 = SHOKet(0)
k1 = SHOKet(1)

Printing

There are multiple printing methods in python: LaTeX, Pretty, repr, and srepr.

Bra

In [3]: b

Out[3]: ⟨b∣∣

In [4]: b0

Out[4]: ⟨0∣∣

In [5]: b1

Out[5]: ⟨1∣∣

LaTex: Gives the printing for LaTeX typesetting

In [6]: latex(b)

Out[6]: {\left\langle b\right|}

In [7]: latex(b0)

Out[7]: {\left\langle 0\right|}

In [8]: latex(b1)

Out[8]: {\left\langle 1\right|}

Pretty

In [9]: pprint(b)

⟨b❘

In [10]: pprint(b0)

⟨0❘

In [11]: pprint(b1)

⟨1❘

Quantum Simple Harmonic Oscillator Example Notebook 5

repr

In [12]: repr(b)

Out[12]: <b|

In [13]: repr(b0)

Out[13]: <0|

In [14]: repr(b1)

Out[14]: <1|

srepr

In [15]: srepr(b)

Out[15]: SHOBra(Symbol('b'))

In [16]: srepr(b0)

Out[16]: SHOBra(Integer(0))

In [17]: srepr(b1)

Out[17]: SHOBra(Integer(1))

Ket

In [18]: k

Out[18]: ∣k⟩

In [19]: k0

Out[19]: ∣0⟩

In [20]: k1

Out[20]: ∣1⟩

Latex: Gives the printing for LaTeX typesetting

In [21]: latex(k)

Out[21]: {\left|k\right\rangle
}

Quantum Simple Harmonic Oscillator Example Notebook 6

In [22]: latex(k0)

Out[22]: {\left|0\right\rangle
}

In [23]: latex(k1)

Out[23]: {\left|1\right\rangle
}

Pretty

In [24]: pprint(k)

❘k⟩

In [25]: pprint(k0)

❘0⟩

In [26]: pprint(k1)

❘1⟩

repr

In [27]: repr(k)

Out[27]: |k>

In [28]: repr(k0)

Out[28]: |0>

In [29]: repr(k1)

Out[29]: |1>

srepr

In [30]: srepr(k)

Out[30]: SHOKet(Symbol('k'))

In [31]: srepr(k0)

Out[31]: SHOKet(Integer(0))

In [32]: srepr(k1)

Out[32]: SHOKet(Integer(1))

Properites

Quantum Simple Harmonic Oscillator Example Notebook 7

Hilbert Space

In [33]: b.hilbert_space

Out[33]: ∞

In [34]: b0.hilbert_space

Out[34]: ∞

In [35]: k.hilbert_space

Out[35]: ∞

In [36]: k0.hilbert_space

Out[36]: ∞

Energy Level

In [37]: b.n

Out[37]: b

In [38]: b0.n

Out[38]: 0

In [39]: b1.n

Out[39]: 1

In [40]: k.n

Out[40]: k

In [41]: k0.n

Out[41]: 0

In [42]: k1.n

Out[42]: 1

Operators

The states are acted upon by operators. There are four operators that act on simple harmonic kets: RaisingOp,
LoweringOp, NumberOp, and Hamiltonian. The operators are created by passing a string 'n' to the operator. They can
also be printed in multiple ways, but only the raising operator has a distinct difference.

Each of the operators are passed the information and properties from SHOOp. SHOOp contains information on the hilbert
space of the operators and how the arguments are evaluated. Each of these operators are limited to one argument. The

Quantum Simple Harmonic Oscillator Example Notebook 8

Operatos class is passed to SHOOp, which is in turn passed to each of the four quantum harmonic oscillators.

In [43]: ad = RaisingOp('a')
a = LoweringOp('a')
N = NumberOp('N')
H = Hamiltonian('H')

Printing

RaisingOp

In [44]: ad

Out[44]: a†

In [45]: latex(ad)

Out[45]: a^{\dag}

In [46]: pprint(ad)

†
a

In [47]: repr(ad)

Out[47]: RaisingOp(a)

In [48]: srepr(ad)

Out[48]: RaisingOp(Symbol('a'))

LoweringOp

In [49]: a

Out[49]: a

In [50]: latex(a)

Out[50]: a

In [51]: pprint(a)

In [52]: repr(a)

Out[52]: a

In [53]: srepr(a)

Out[53]: LoweringOp(Symbol('a'))

Quantum Simple Harmonic Oscillator Example Notebook 9

NumberOp

In [54]: N

Out[54]: N

In [55]: latex(N)

Out[55]: N

In [56]: pprint(N)

In [57]: repr(N)

Out[57]: N

In [58]: srepr(N)

Out[58]: NumberOp(Symbol('N'))

Hamiltonian

In [59]: H

Out[59]: H

In [60]: latex(H)

Out[60]: H

In [61]: pprint(H)

In [62]: repr(H)

Out[62]: H

In [63]: srepr(H)

Out[63]: Hamiltonian(Symbol('H'))

Properties

Hilbert Space

In [64]: ad.hilbert_space

Out[64]: ∞

Quantum Simple Harmonic Oscillator Example Notebook 10

In [65]: a.hilbert_space

Out[65]: ∞

In [66]: N.hilbert_space

Out[66]: ∞

In [67]: H.hilbert_space

Out[67]: ∞

Properties and Operations

There are a couple properties and operations of a quantum simple harmonic oscillator state that are defined. Taking the
dagger of a bra returns the ket and vice versa. Using the property 'dual' returns the same value as taking the dagger. The
property 'n' as seen in the State Section above returns the argument/energy level of the state, which is used when
operators act on states.

In [68]: Dagger(b)

Out[68]: ∣b⟩

In [69]: Dagger(k)

Out[69]: ⟨k∣∣

In [70]: Dagger(b0)

Out[70]: ∣0⟩

Tests that the dagger of a bra is equal to the ket.

In [71]: Dagger(b0) == k0

Out[71]:

Tests that the dagger of a ket is equal to the bra

In [72]: Dagger(k1) == b1

Out[72]:

The energy level of the states must be the same for the dagger of the bra to equal the ket

In [73]: Dagger(b1) == k0

Out[73]:

Quantum Simple Harmonic Oscillator Example Notebook 11

Tests that dagger(ket) = ket.dual and dagger(bra) = bra.dual

In [74]: k.dual

Out[74]: ⟨k∣∣

In [75]: Dagger(k) == k.dual

Out[75]:

The raising operator is the dagger of the lowering operator

In [76]: Dagger(a)

Out[76]: a†

In [77]: Dagger(ad)

Out[77]: a

In [78]: Dagger(a) == ad

Out[78]:

The operators can be expressed in terms of other operators. Aside from the operators stated above rewriting in terms of the
position (X) and momentum operators (Px) is common. To rewrite the operators in terms of other operators, we pass a
keyword that specifies which operators to rewrite in.

'xp' -- Position and Momentum Operators

'a' -- Raising and Lowering Operators

'H' -- Hamiltonian Operator

'N' -- Number Operator

In [79]: ad.rewrite('xp')

Out[79]: √2‾ (mωX − ıPx)

2√ℏ‾‾√mω
‾‾‾

In [80]: a.rewrite('xp')

Out[80]: √2‾ (mωX + ıPx)

2√ℏ‾‾√mω
‾‾‾

In [81]: N.rewrite('xp')

Out[81]: 1 m2 ω2 (X)2 + (Px)2

− +
2 2ℏmω

Quantum Simple Harmonic Oscillator Example Notebook 12

In [82]: N.rewrite('a')

Out[82]: a† a

In [83]: N.rewrite('H')

Out[83]: 1 H
− +
2 ℏω

In [84]: H.rewrite('xp')

Out[84]: m2 ω2 (X)2 + (Px)2

2m

In [85]: H.rewrite('a')

(2 )
Out[85]: 1
ℏω + a† a

In [86]: H.rewrite('N')

(2 )
Out[86]: 1
ℏω +N

Operator Methods

Apply Operators to States: Each of the operators can act on kets using qapply.

The raising operator raises the value of the state by one as well as multiplies the state by the square root of the new state.

In [87]: qapply(ad*k)

Out[87]: + 1‾∣k + 1⟩
√‾k‾‾‾

Two numerical examples with the ground state and first excited state.

In [88]: qapply(ad*k0)

Out[88]: ∣1⟩

In [89]: qapply(ad*k1)

Out[89]: √2‾ ∣2⟩

The lowering operator lowers the value of the state by one and multiples the state by the square root of the original state.
When the lowering operator acts on the ground state it returns zero because the state cannot be lowered.

Quantum Simple Harmonic Oscillator Example Notebook 13

In [90]: qapply(a*k)

Out[90]: √k∣k − 1⟩

Two numerical examples with the ground state and first excited state.

In [91]: qapply(a*k0)

Out[91]: 0

In [92]: qapply(a*k1)

Out[92]: ∣0⟩

The number operator is defined as the raising operator times the lowering operator. When the number operator acts on a
ket it returns the same state multiplied by the value of the state. This can be checked by applying the lowering operator on
a state then applying the raising operator to the result.

In [93]: qapply(N*k)

Out[93]: k∣k⟩

In [94]: qapply(N*k0)

Out[94]: 0

In [95]: qapply(N*k1)

Out[95]: ∣1⟩

In [96]: result = qapply(a*k)

qapply(ad*result)

Out[96]: k∣k⟩

When the hamiltonian operator acts on a state it returns the energy of the state, which is equal to hbar*omega times the
value of the state plus one half.

In [97]: qapply(H*k)

Out[97]: 1
ℏkω∣k⟩ + ℏω∣k⟩
2

In [98]: qapply(H*k0)

Out[98]: 1
ℏω∣0⟩
2

In [99]: qapply(H*k1)

Out[99]: 3
ℏω∣1⟩
2

Quantum Simple Harmonic Oscillator Example Notebook 14

Commutators

A commutator is defined as [A, B] = A*B - B*A where A and B are both operators. Commutators are used to see if operators
commute, which is an important property in quantum mechanics. If they commute it allows for rearranging the order
operators act on states.

In [100]: Commutator(ad,a).doit()

Out[100]: −1

In [101]: Commutator(ad,N).doit()

Out[101]: −a†

In [102]: Commutator(a,ad).doit()

Out[102]: 1

In [103]: Commutator(a,N).doit()

Out[103]: a

Matrix Representation

The bras and kets can also be represented as a row or column vector, which are then used to create matrix representation
of the different operators. The bras and kets must be numerical states rather than a generic n state

In [104]: represent(b0)

Out[104]:
[1 0 0 0]

In [105]: represent(k0)

[ 00 ]
Out[105]: 1
0

Because these vectors and matrices are mostly zeros there is a different way of creating and storing these vectors/matrices,
that is to use the format scipy.sparse. The default format is sympy and another common format to use is numpy. Along with
specifying the format in which the matrices are created, the dimension of the matrices can also be specified. A dimension of
4 is the default.

In [106]: represent(k1, ndim=5, format='sympy')

⎡0⎤
⎢1⎥
Out[106]:

⎢ 00 ⎥
⎣0⎦

Quantum Simple Harmonic Oscillator Example Notebook 15

In [107]: represent(k1, ndim=5, format='numpy')

Out[107]: [[
0.]
[
1.]
[
0.]
[
0.]
[
0.]]

In [108]: represent(k1, ndim=5, format='scipy.sparse')

Out[108]: (1, 0)
1.0

Operators can be expressed as matrices using the vector representation of the bras and kets.
⟨i|N|j⟩
The operator acts on the ket then the inner product of the bra and the new resulting ket is performed.

In [109]: represent(ad, ndim=4, format='sympy')

⎡0 0⎤
⎢1 0⎥
Out[109]: 0 0

⎢0 0⎥
0 0

⎣0 0⎦
√2 0
0 √3

In [110]: represent(ad, format='numpy')

Out[110]: [[ 0. 0. 0.
0. ]
[ 1. 0. 0.
0. ]
[ 0. 1.41421356 0.
0. ]
[ 0. 0. 1.73205081 0.
]]

In [111]: represent(ad, format='scipy.sparse', spmatrix='lil')

Out[111]: (1, 0)
1.0
(2, 1)1.41421356237
(3, 2)1.73205080757

In [112]: str(represent(ad, format='scipy.sparse', spmatrix='lil'))

Out[112]: (1, 0)
1.0
(2, 1)1.41421356237
(3, 2)1.73205080757

Quantum Simple Harmonic Oscillator Example Notebook 16

In [113]: represent(a)

⎡0 0 ⎤
⎢0 0 ⎥
Out[113]: 1 0

⎢0 √3 ⎥
0 √2

⎣0 0 ⎦
0 0
0 0

In [114]: represent(N)

[ 00 3]
Out[114]: 0 0 0 0
0 1 0 0
0 2 0
0 0

In [115]: represent(H)

⎡ ⎤
⎢ ⎥
Out[115]: 1
ℏω 0 0 0
⎢ 0 ⎥
2
3

⎢ ⎥
0 ℏω 0

⎢
2

0 ⎥
5
0 0 ℏω
⎢ 2
⎥
⎣ ℏω ⎦
7
0 0 0
2

There are some interesting properties that we can test using the matrix representation, like the definition of the Number
Operator.

In [116]: represent(N) == represent(ad) * represent(a)

Out[116]:

For Additional Quantum Harmonic Oscillator Information

Griffiths, David J. Introduction to Quantum Mechanics. Upper Saddle River, NJ: Pearson Prentice Hall, 2005. Print.

http://en.wikipedia.org/wiki/Quantum_harmonic_oscillator

http://en.wikipedia.org/wiki/Harmonic_oscillator#Simple_harmonic_oscillator

In [ ]:

Quantum Simple Harmonic Oscillator Example Notebook 17

 1 """Simple Harmonic Oscillator 1-Dimension"""!
2 !
3 from sympy import sqrt, I, Symbol, Integer, S!
4 from sympy.physics.quantum.constants import hbar!
5 from sympy.physics.quantum.operator import Operator!
6 from sympy.physics.quantum.state import Bra, Ket, State!
7 from sympy.physics.quantum.qexpr import QExpr!
8 from sympy.physics.quantum.cartesian import X, Px!
9 from sympy.functions.special.tensor_functions import KroneckerDelta!
10 from sympy.physics.quantum.hilbert import ComplexSpace!
11 from sympy.physics.quantum.matrixutils import matrix_zeros!
12 from sympy.physics.quantum.represent import represent!
13 !
14 #-------------------------------------------------------------------------
… -----!
15 !
16 class SHOOp(Operator):!
17 """A base class for the SHO Operators.!
18 !
19 We are limiting the number of arguments to be 1.!
20 !
21 """!
22 !
23 @classmethod!
24 def _eval_args(cls, args):!
25 args = QExpr._eval_args(args)!
26 if len(args) == 1:!
27 return args!
28 else:!
29 raise ValueError("Too many arguments")!
30 !
31 @classmethod!
32 def _eval_hilbert_space(cls, label):!
33 return ComplexSpace(S.Infinity)!
34 !
35 class RaisingOp(SHOOp):!
36 """The Raising Operator or a^dagger.!
37 !
38 When a^dagger acts on a state it raises the state up by one. Taking!
39 the adjoint of a^dagger returns 'a', the Lowering Operator. a^dagger!
40 can be rewritten in terms of postion and momentum. We can represent!
41 a^dagger as a matrix, which will be its default basis.!
42 !
43 Parameters!
44 ==========!
45 !
46 args : tuple!
47 The list of numbers or parameters that uniquely specify the!
48 operator.!
49 !
50 Examples!
51 ========!

Quantum Simple Harmonic Oscillator 18

 52 !
53 Create a Raising Operator and rewrite it in terms of positon and!
54 momentum, and show that taking its adjoint returns 'a':!
55 !
56 >>> from sympy.physics.quantum.sho1d import RaisingOp!
57 >>> from sympy.physics.quantum import Dagger!
58 !
59 >>> ad = RaisingOp('a')!
60 >>> ad.rewrite('xp').doit()!
61 sqrt(2)*(m*omega*X - I*Px)/(2*sqrt(hbar)*sqrt(m*omega))!
62 !
63 >>> Dagger(ad)!
64 a!
65 !
66 Taking the commutator of a^dagger with other Operators:!
67 !
68 >>> from sympy.physics.quantum import Commutator!
69 >>> from sympy.physics.quantum.sho1d import RaisingOp, LoweringOp!
70 >>> from sympy.physics.quantum.sho1d import NumberOp!
71 !
72 >>> ad = RaisingOp('a')!
73 >>> a = LoweringOp('a')!
74 >>> N = NumberOp('N')!
75 >>> Commutator(ad, a).doit()!
76 -1!
77 >>> Commutator(ad, N).doit()!
78 -RaisingOp(a)!
79 !
80 Apply a^dagger to a state:!
81 !
82 >>> from sympy.physics.quantum import qapply!
83 >>> from sympy.physics.quantum.sho1d import RaisingOp, SHOKet!
84 !
85 >>> ad = RaisingOp('a')!
86 >>> k = SHOKet('k')!
87 >>> qapply(ad*k)!
88 sqrt(k + 1)*|k + 1>!
89 !
90 Matrix Representation!
91 !
92 >>> from sympy.physics.quantum.sho1d import RaisingOp!
93 >>> from sympy.physics.quantum.represent import represent!
94 >>> ad = RaisingOp('a')!
95 >>> represent(ad, basis=N, ndim=4, format='sympy')!
96 [0, 0, 0, 0]!
97 [1, 0, 0, 0]!
98 [0, sqrt(2), 0, 0]!
99 [0, 0, sqrt(3), 0]!
100 !
101 """!
102 !
103 def _eval_rewrite_as_xp(self, *args):!

Quantum Simple Harmonic Oscillator 19

104 return (Integer(1)/sqrt(Integer(2)*hbar*m*omega))*(!
105 Integer(-1)*I*Px + m*omega*X)!
106 !
107 def _eval_adjoint(self):!
108 return LoweringOp(*self.args)!
109 !
110 def _eval_commutator_LoweringOp(self, other):!
111 return Integer(-1)!
112 !
113 def _eval_commutator_NumberOp(self, other):!
114 return Integer(-1)*self!
115 !
116 def _apply_operator_SHOKet(self, ket):!
117 temp = ket.n + Integer(1)!
118 return sqrt(temp)*SHOKet(temp)!
119 !
120 def _represent_default_basis(self, **options):!
121 return self._represent_NumberOp(None, **options)!
122 !
123 def _represent_XOp(self, basis, **options):!
124 # This logic is good but the underlying positon!
125 # representation logic is broken.!
126 # temp = self.rewrite('xp').doit()!
127 # result = represent(temp, basis=X)!
128 # return result!
129 raise NotImplementedError('Position representation is not
… implemented')!
130 !
131 def _represent_NumberOp(self, basis, **options):!
132 ndim_info = options.get('ndim', 4)!
133 format = options.get('format','sympy')!
134 spmatrix = options.get('spmatrix', 'csr')!
135 matrix = matrix_zeros(ndim_info, ndim_info, **options)!
136 for i in range(ndim_info - 1):!
137 value = sqrt(i + 1)!
138 if format == 'scipy.sparse':!
139 value = float(value)!
140 matrix[i + 1, i] = value!
141 if format == 'scipy.sparse':!
142 matrix = matrix.tocsr()!
143 return matrix!
144 !
145
… #-------------------------------------------------------------------------
… -!
146 # Printing Methods!
147
… #-------------------------------------------------------------------------
… -!
148 !
149 def _print_contents(self, printer, *args):!
150 arg0 = printer._print(self.args[0], *args)!

Quantum Simple Harmonic Oscillator 20

151 return '%s(%s)' % (self.__class__.__name__, arg0)!
152 !
153 def _print_contents_pretty(self, printer, *args):!
154 from sympy.printing.pretty.stringpict import prettyForm!
155 pform = printer._print(self.args[0], *args)!
156 pform = pform**prettyForm(u'\u2020')!
157 return pform!
158 !
159 def _print_contents_latex(self, printer, *args):!
160 arg = printer._print(self.args[0])!
161 return '%s^{\\dag}' % arg!
162 !
163 class LoweringOp(SHOOp):!
164 """The Lowering Operator or 'a'.!
165 !
166 When 'a' acts on a state it lowers the state up by one. Taking!
167 the adjoint of 'a' returns a^dagger, the Raising Operator. 'a'!
168 can be rewritten in terms of position and momentum. We can!
169 represent 'a' as a matrix, which will be its default basis.!
170 !
171 Parameters!
172 ==========!
173 !
174 args : tuple!
175 The list of numbers or parameters that uniquely specify the!
176 operator.!
177 !
178 Examples!
179 ========!
180 !
181 Create a Lowering Operator and rewrite it in terms of positon and!
182 momentum, and show that taking its adjoint returns a^dagger:!
183 !
184 >>> from sympy.physics.quantum.sho1d import LoweringOp!
185 >>> from sympy.physics.quantum import Dagger!
186 !
187 >>> a = LoweringOp('a')!
188 >>> a.rewrite('xp').doit()!
189 sqrt(2)*(m*omega*X + I*Px)/(2*sqrt(hbar)*sqrt(m*omega))!
190 !
191 >>> Dagger(a)!
192 RaisingOp(a)!
193 !
194 Taking the commutator of 'a' with other Operators:!
195 !
196 >>> from sympy.physics.quantum import Commutator!
197 >>> from sympy.physics.quantum.sho1d import LoweringOp, RaisingOp!
198 >>> from sympy.physics.quantum.sho1d import NumberOp!
199 !
200 >>> a = LoweringOp('a')!
201 >>> ad = RaisingOp('a')!
202 >>> N = NumberOp('N')!

Quantum Simple Harmonic Oscillator 21

203 >>> Commutator(a, ad).doit()!
204 1!
205 >>> Commutator(a, N).doit()!
206 a!
207 !
208 Apply 'a' to a state:!
209 !
210 >>> from sympy.physics.quantum import qapply!
211 >>> from sympy.physics.quantum.sho1d import LoweringOp, SHOKet!
212 !
213 >>> a = LoweringOp('a')!
214 >>> k = SHOKet('k')!
215 >>> qapply(a*k)!
216 sqrt(k)*|k - 1>!
217 !
218 Taking 'a' of the lowest state will return 0:!
219 !
220 >>> from sympy.physics.quantum import qapply!
221 >>> from sympy.physics.quantum.sho1d import LoweringOp, SHOKet!
222 !
223 >>> a = LoweringOp('a')!
224 >>> k = SHOKet(0)!
225 >>> qapply(a*k)!
226 0!
227 !
228 Matrix Representation!
229 !
230 >>> from sympy.physics.quantum.sho1d import LoweringOp!
231 >>> from sympy.physics.quantum.represent import represent!
232 >>> a = LoweringOp('a')!
233 >>> represent(a, basis=N, ndim=4, format='sympy')!
234 [0, 1, 0, 0]!
235 [0, 0, sqrt(2), 0]!
236 [0, 0, 0, sqrt(3)]!
237 [0, 0, 0, 0]!
238 !
239 """!
240 !
241 def _eval_rewrite_as_xp(self, *args):!
242 return (Integer(1)/sqrt(Integer(2)*hbar*m*omega))*(!
243 I*Px + m*omega*X)!
244 !
245 def _eval_adjoint(self):!
246 return RaisingOp(*self.args)!
247 !
248 def _eval_commutator_RaisingOp(self, other):!
249 return Integer(1)!
250 !
251 def _eval_commutator_NumberOp(self, other):!
252 return Integer(1)*self!
253 !
254 def _apply_operator_SHOKet(self, ket):!

Quantum Simple Harmonic Oscillator 22

255 temp = ket.n - Integer(1)!
256 if ket.n == Integer(0):!
257 return Integer(0)!
258 else:!
259 return sqrt(ket.n)*SHOKet(temp)!
260 !
261 def _represent_default_basis(self, **options):!
262 return self._represent_NumberOp(None, **options)!
263 !
264 def _represent_XOp(self, basis, **options):!
265 # This logic is good but the underlying positon!
266 # representation logic is broken.!
267 # temp = self.rewrite('xp').doit()!
268 # result = represent(temp, basis=X)!
269 # return result!
270 raise NotImplementedError('Position representation is not
… implemented')!
271 !
272 def _represent_NumberOp(self, basis, **options):!
273 ndim_info = options.get('ndim', 4)!
274 format = options.get('format', 'sympy')!
275 spmatrix = options.get('spmatrix', 'csr')!
276 matrix = matrix_zeros(ndim_info, ndim_info, **options)!
277 for i in range(ndim_info - 1):!
278 value = sqrt(i + 1)!
279 if format == 'scipy.sparse':!
280 value = float(value)!
281 matrix[i,i + 1] = value!
282 if format == 'scipy.sparse':!
283 matrix = matrix.tocsr()!
284 return matrix!
285 !
286 !
287 class NumberOp(SHOOp):!
288 """The Number Operator is simply a^dagger*a!
289 !
290 It is often useful to write a^dagger*a as simply the Number Operator!
291 because the Number Operator commutes with the Hamiltonian. And can be!
292 expressed using the Number Operator. Also the Number Operator can be!
293 applied to states. We can represent the Number Operator as a matrix,!
294 which will be its default basis.!
295 !
296 Parameters!
297 ==========!
298 !
299 args : tuple!
300 The list of numbers or parameters that uniquely specify the!
301 operator.!
302 !
303 Examples!
304 ========!
305 !

Quantum Simple Harmonic Oscillator 23

306 Create a Number Operator and rewrite it in terms of the ladder!
307 operators, position and momentum operators, and Hamiltonian:!
308 !
309 >>> from sympy.physics.quantum.sho1d import NumberOp!
310 !
311 >>> N = NumberOp('N')!
312 >>> N.rewrite('a').doit()!
313 RaisingOp(a)*a!
314 >>> N.rewrite('xp').doit()!
315 -1/2 + (m**2*omega**2*X**2 + Px**2)/(2*hbar*m*omega)!
316 >>> N.rewrite('H').doit()!
317 -1/2 + H/(hbar*omega)!
318 !
319 Take the Commutator of the Number Operator with other Operators:!
320 !
321 >>> from sympy.physics.quantum import Commutator!
322 >>> from sympy.physics.quantum.sho1d import NumberOp, Hamiltonian!
323 >>> from sympy.physics.quantum.sho1d import RaisingOp, LoweringOp!
324 !
325 >>> N = NumberOp('N')!
326 >>> H = Hamiltonian('H')!
327 >>> ad = RaisingOp('a')!
328 >>> a = LoweringOp('a')!
329 >>> Commutator(N,H).doit()!
330 0!
331 >>> Commutator(N,ad).doit()!
332 RaisingOp(a)!
333 >>> Commutator(N,a).doit()!
334 -a!
335 !
336 Apply the Number Operator to a state:!
337 !
338 >>> from sympy.physics.quantum import qapply!
339 >>> from sympy.physics.quantum.sho1d import NumberOp, SHOKet!
340 !
341 >>> N = NumberOp('N')!
342 >>> k = SHOKet('k')!
343 >>> qapply(N*k)!
344 k*|k>!
345 !
346 Matrix Representation!
347 !
348 >>> from sympy.physics.quantum.sho1d import NumberOp!
349 >>> from sympy.physics.quantum.represent import represent!
350 >>> N = NumberOp('N')!
351 >>> represent(N, basis=N, ndim=4, format='sympy')!
352 [0, 0, 0, 0]!
353 [0, 1, 0, 0]!
354 [0, 0, 2, 0]!
355 [0, 0, 0, 3]!
356 !
357 """!

Quantum Simple Harmonic Oscillator 24

358 !
359 def _eval_rewrite_as_a(self, *args):!
360 return ad*a!
361 !
362 def _eval_rewrite_as_xp(self, *args):!
363 return (Integer(1)/(Integer(2)*m*hbar*omega))*(Px**2 + (!
364 m*omega*X)**2) - Integer(1)/Integer(2)!
365 !
366 def _eval_rewrite_as_H(self, *args):!
367 return H/(hbar*omega) - Integer(1)/Integer(2)!
368 !
369 def _apply_operator_SHOKet(self, ket):!
370 return ket.n*ket!
371 !
372 def _eval_commutator_Hamiltonian(self, other):!
373 return Integer(0)!
374 !
375 def _eval_commutator_RaisingOp(self, other):!
376 return other!
377 !
378 def _eval_commutator_LoweringOp(self, other):!
379 return Integer(-1)*other!
380 !
381 def _represent_default_basis(self, **options):!
382 return self._represent_NumberOp(None, **options)!
383 !
384 def _represent_XOp(self, basis, **options):!
385 # This logic is good but the underlying positon!
386 # representation logic is broken.!
387 # temp = self.rewrite('xp').doit()!
388 # result = represent(temp, basis=X)!
389 # return result!
390 raise NotImplementedError('Position representation is not
… implemented')!
391 !
392 def _represent_NumberOp(self, basis, **options):!
393 ndim_info = options.get('ndim', 4)!
394 format = options.get('format', 'sympy')!
395 spmatrix = options.get('spmatrix', 'csr')!
396 matrix = matrix_zeros(ndim_info, ndim_info, **options)!
397 for i in range(ndim_info):!
398 value = i!
399 if format == 'scipy.sparse':!
400 value = float(value)!
401 matrix[i,i] = value!
402 if format == 'scipy.sparse':!
403 matrix = matrix.tocsr()!
404 return matrix!
405 !
406 !
407 class Hamiltonian(SHOOp):!
408 """The Hamiltonian Operator.!

Quantum Simple Harmonic Oscillator 25

409 !
410 The Hamiltonian is used to solve the time-independent Schrodinger!
411 equation. The Hamiltonian can be expressed using the ladder operators,!
412 as well as by position and momentum. We can represent the Hamiltonian!
413 Operator as a matrix, which will be its default basis.!
414 !
415 Parameters!
416 ==========!
417 !
418 args : tuple!
419 The list of numbers or parameters that uniquely specify the!
420 operator.!
421 !
422 Examples!
423 ========!
424 !
425 Create a Hamiltonian Operator and rewrite it in terms of the ladder!
426 operators, position and momentum, and the Number Operator:!
427 !
428 >>> from sympy.physics.quantum.sho1d import Hamiltonian!
429 !
430 >>> H = Hamiltonian('H')!
431 >>> H.rewrite('a').doit()!
432 hbar*omega*(1/2 + RaisingOp(a)*a)!
433 >>> H.rewrite('xp').doit()!
434 (m**2*omega**2*X**2 + Px**2)/(2*m)!
435 >>> H.rewrite('N').doit()!
436 hbar*omega*(1/2 + N)!
437 !
438 Take the Commutator of the Hamiltonian and the Number Operator:!
439 !
440 >>> from sympy.physics.quantum import Commutator!
441 >>> from sympy.physics.quantum.sho1d import Hamiltonian, NumberOp!
442 !
443 >>> H = Hamiltonian('H')!
444 >>> N = NumberOp('N')!
445 >>> Commutator(H,N).doit()!
446 0!
447 !
448 Apply the Hamiltonian Operator to a state:!
449 !
450 >>> from sympy.physics.quantum import qapply!
451 >>> from sympy.physics.quantum.sho1d import Hamiltonian, SHOKet!
452 !
453 >>> H = Hamiltonian('H')!
454 >>> k = SHOKet('k')!
455 >>> qapply(H*k)!
456 hbar*k*omega*|k> + hbar*omega*|k>/2!
457 !
458 Matrix Representation!
459 !
460 >>> from sympy.physics.quantum.sho1d import Hamiltonian!

Quantum Simple Harmonic Oscillator 26

461 >>> from sympy.physics.quantum.represent import represent!
462 !
463 >>> H = Hamiltonian('H')!
464 >>> represent(H, basis=N, ndim=4, format='sympy')!
465 [hbar*omega/2, 0, 0, 0]!
466 [ 0, 3*hbar*omega/2, 0, 0]!
467 [ 0, 0, 5*hbar*omega/2, 0]!
468 [ 0, 0, 0, 7*hbar*omega/2]!
469 !
470 """!
471 !
472 def _eval_rewrite_as_a(self, *args):!
473 return hbar*omega*(ad*a + Integer(1)/Integer(2))!
474 !
475 def _eval_rewrite_as_xp(self, *args):!
476 return (Integer(1)/(Integer(2)*m))*(Px**2 + (m*omega*X)**2)!
477 !
478 def _eval_rewrite_as_N(self, *args):!
479 return hbar*omega*(N + Integer(1)/Integer(2))!
480 !
481 def _apply_operator_SHOKet(self, ket):!
482 return (hbar*omega*(ket.n + Integer(1)/Integer(2)))*ket!
483 !
484 def _eval_commutator_NumberOp(self, other):!
485 return Integer(0)!
486 !
487 def _represent_default_basis(self, **options):!
488 return self._represent_NumberOp(None, **options)!
489 !
490 def _represent_XOp(self, basis, **options):!
491 # This logic is good but the underlying positon!
492 # representation logic is broken.!
493 # temp = self.rewrite('xp').doit()!
494 # result = represent(temp, basis=X)!
495 # return result!
496 raise NotImplementedError('Position representation is not
… implemented')!
497 !
498 def _represent_NumberOp(self, basis, **options):!
499 ndim_info = options.get('ndim', 4)!
500 format = options.get('format', 'sympy')!
501 spmatrix = options.get('spmatrix', 'csr')!
502 matrix = matrix_zeros(ndim_info, ndim_info, **options)!
503 for i in range(ndim_info):!
504 value = i + Integer(1)/Integer(2)!
505 if format == 'scipy.sparse':!
506 value = float(value)!
507 matrix[i,i] = value!
508 if format == 'scipy.sparse':!
509 matirx = matrix.tocsr()!
510 return hbar*omega*matrix!
511 !

Quantum Simple Harmonic Oscillator 27

512 #-------------------------------------------------------------------------
… -----!
513 !
514 class SHOState(State):!
515 """State class for SHO states"""!
516 !
517 @classmethod!
518 def _eval_hilbert_space(cls, label):!
519 return ComplexSpace(S.Infinity)!
520 !
521 @property!
522 def n(self):!
523 return self.args[0]!
524 !
525 !
526 class SHOKet(SHOState, Ket):!
527 """1D eigenket.!
528 !
529 Inherits from SHOState and Ket.!
530 !
531 Parameters!
532 ==========!
533 !
534 args : tuple!
535 The list of numbers or parameters that uniquely specify the ket!
536 This is usually its quantum numbers or its symbol.!
537 !
538 Examples!
539 ========!
540 !
541 Ket's know about their associated bra:!
542 !
543 >>> from sympy.physics.quantum.sho1d import SHOKet!
544 !
545 >>> k = SHOKet('k')!
546 >>> k.dual!
547 <k|!
548 >>> k.dual_class()!
549 <class 'sympy.physics.quantum.sho1d.SHOBra'>!
550 !
551 Take the Inner Product with a bra:!
552 !
553 >>> from sympy.physics.quantum import InnerProduct!
554 >>> from sympy.physics.quantum.sho1d import SHOKet, SHOBra!
555 !
556 >>> k = SHOKet('k')!
557 >>> b = SHOBra('b')!
558 >>> InnerProduct(b,k).doit()!
559 KroneckerDelta(k, b)!
560 !
561 Vector representation of a numerical state ket:!
562 !

Quantum Simple Harmonic Oscillator 28

563 >>> from sympy.physics.quantum.sho1d import SHOKet, NumberOp!
564 >>> from sympy.physics.quantum.represent import represent!
565 !
566 >>> k = SHOKet(3)!
567 >>> N = NumberOp('N')!
568 >>> represent(k, basis=N, ndim=4)!
569 [0]!
570 [0]!
571 [0]!
572 [1]!
573 !
574 """!
575 !
576 @classmethod!
577 def dual_class(self):!
578 return SHOBra!
579 !
580 def _eval_innerproduct_SHOBra(self, bra, **hints):!
581 result = KroneckerDelta(self.n, bra.n)!
582 return result!
583 !
584 def _represent_default_basis(self, **options):!
585 return self._represent_NumberOp(None, **options)!
586 !
587 def _represent_NumberOp(self, basis, **options):!
588 ndim_info = options.get('ndim', 4)!
589 format = options.get('format', 'sympy')!
590 options['spmatrix'] = 'lil'!
591 vector = matrix_zeros(ndim_info, 1, **options)!
592 if isinstance(self.n, Integer):!
593 if self.n >= ndim_info:!
594 return ValueError("N-Dimension too small")!
595 value = Integer(1)!
596 if format == 'scipy.sparse':!
597 vector[int(self.n), 0] = 1.0!
598 vector = vector.tocsr()!
599 elif format == 'numpy':!
600 vector[int(self.n), 0] = 1.0!
601 else:!
602 vector[self.n, 0] = Integer(1)!
603 return vector!
604 else:!
605 return ValueError("Not Numerical State")!
606 !
607 !
608 class SHOBra(SHOState, Bra):!
609 """A time-independent Bra in SHO.!
610 !
611 Inherits from SHOState and Bra.!
612 !
613 Parameters!
614 ==========!

Quantum Simple Harmonic Oscillator 29

615 !
616 args : tuple!
617 The list of numbers or parameters that uniquely specify the ket!
618 This is usually its quantum numbers or its symbol.!
619 !
620 Examples!
621 ========!
622 !
623 Bra's know about their associated ket:!
624 !
625 >>> from sympy.physics.quantum.sho1d import SHOBra!
626 !
627 >>> b = SHOBra('b')!
628 >>> b.dual!
629 |b>!
630 >>> b.dual_class()!
631 <class 'sympy.physics.quantum.sho1d.SHOKet'>!
632 !
633 Vector representation of a numerical state bra:!
634 !
635 >>> from sympy.physics.quantum.sho1d import SHOBra, NumberOp!
636 >>> from sympy.physics.quantum.represent import represent!
637 !
638 >>> b = SHOBra(3)!
639 >>> N = NumberOp('N')!
640 >>> represent(b, basis=N, ndim=4)!
641 [0, 0, 0, 1]!
642 !
643 """!
644 !
645 @classmethod!
646 def dual_class(self):!
647 return SHOKet!
648 !
649 def _represent_default_basis(self, **options):!
650 return self._represent_NumberOp(None, **options)!
651 !
652 def _represent_NumberOp(self, basis, **options):!
653 ndim_info = options.get('ndim', 4)!
654 format = options.get('format', 'sympy')!
655 opitons['spmatrix'] = 'lil'!
656 vector = matrix_zeros(1, ndim_info, **options)!
657 if isinstance(self.n, Integer):!
658 if self.n >= ndim_info:!
659 return ValueError("N-Dimension too small")!
660 if format == 'scipy.sparse':!
661 vector[0, int(self.n)] = 1.0!
662 vector = vector.tocsr()!
663 elif format == 'numpy':!
664 vector[0, int(self.n)] = 1.0!
665 else:!
666 vector[0, self.n] = Integer(1)!

Quantum Simple Harmonic Oscillator 30

667 return vector!
668 else:!
669 return ValueError("Not Numerical State")!
670 !
671 !
672 ad = RaisingOp('a')!
673 a = LoweringOp('a')!
674 H = Hamiltonian('H')!
675 N = NumberOp('N')!
676 omega = Symbol('omega')!
677 m = Symbol('m')!
678

Quantum Simple Harmonic Oscillator 31

 1 """Tests for sho1d.py"""!
2 !
3 from sympy import Integer, Symbol, sqrt, I, S!
4 from sympy.physics.quantum import Dagger!
5 from sympy.physics.quantum.constants import hbar!
6 from sympy.physics.quantum import Commutator!
7 from sympy.physics.quantum.qapply import qapply!
8 from sympy.physics.quantum.innerproduct import InnerProduct!
9 from sympy.physics.quantum.cartesian import X, Px!
10 from sympy.functions.special.tensor_functions import KroneckerDelta!
11 from sympy.physics.quantum.hilbert import ComplexSpace!
12 from sympy.physics.quantum.represent import represent!
13 from sympy.external import import_module!
14 from sympy.utilities.pytest import skip!
15 !
16 from sympy.physics.quantum.sho1d import (RaisingOp, LoweringOp,!
17 SHOKet, SHOBra,!
18 Hamiltonian, NumberOp)!
19 !
20 ad = RaisingOp('a')!
21 a = LoweringOp('a')!
22 k = SHOKet('k')!
23 kz = SHOKet(0)!
24 kf = SHOKet(1)!
25 k3 = SHOKet(3)!
26 b = SHOBra('b')!
27 b3 = SHOBra(3)!
28 H = Hamiltonian('H')!
29 N = NumberOp('N')!
30 omega = Symbol('omega')!
31 m = Symbol('m')!
32 ndim = Integer(4)!
33 !
34 np = import_module('numpy', min_python_version=(2, 6))!
35 scipy = import_module('scipy', __import__kwargs={'fromlist': ['sparse']})!
36 !
37 ad_rep_sympy = represent(ad, basis=N, ndim=4, format='sympy')!
38 a_rep = represent(a, basis=N, ndim=4, format='sympy')!
39 N_rep = represent(N, basis=N, ndim=4, format='sympy')!
40 H_rep = represent(H, basis=N, ndim=4, format='sympy')!
41 k3_rep = represent(k3, basis=N, ndim=4, format='sympy')!
42 b3_rep = represent(b3, basis=N, ndim=4, format='sympy')!
43 !
44 def test_RaisingOp():!
45 assert Dagger(ad) == a!
46 assert Commutator(ad, a).doit() == Integer(-1)!
47 assert Commutator(ad, N).doit() == Integer(-1)*ad!
48 assert qapply(ad*k) == (sqrt(k.n + 1)*SHOKet(k.n + 1)).expand()!
49 assert qapply(ad*kz) == (sqrt(kz.n + 1)*SHOKet(kz.n + 1)).expand()!
50 assert qapply(ad*kf) == (sqrt(kf.n + 1)*SHOKet(kf.n + 1)).expand()!
51 assert ad.rewrite('xp').doit() == \!
52 (Integer(1)/sqrt(Integer(2)*hbar*m*omega))*(Integer(-1)*I*Px +

Tests for Quantum Simple Harmonic Oscillator 32

52… m*omega*X)!
53 assert ad.hilbert_space == ComplexSpace(S.Infinity)!
54 for i in range(ndim - 1):!
55 assert ad_rep_sympy[i + 1,i] == sqrt(i + 1)!
56 !
57 if not np:!
58 skip("numpy not installed or Python too old.")!
59 !
60 ad_rep_numpy = represent(ad, basis=N, ndim=4, format='numpy')!
61 for i in range(ndim - 1):!
62 assert ad_rep_numpy[i + 1,i] == float(sqrt(i + 1))!
63 !
64 if not np:!
65 skip("numpy not installed or Python too old.")!
66 if not scipy:!
67 skip("scipy not installed.")!
68 else:!
69 sparse = scipy.sparse!
70 !
71 ad_rep_scipy = represent(ad, basis=N, ndim=4, format='scipy.sparse',
… spmatrix='lil')!
72 for i in range(ndim - 1):!
73 assert ad_rep_scipy[i + 1,i] == float(sqrt(i + 1))!
74 !
75 assert ad_rep_numpy.dtype == 'float64'!
76 assert ad_rep_scipy.dtype == 'float64'!
77 !
78 def test_LoweringOp():!
79 assert Dagger(a) == ad!
80 assert Commutator(a, ad).doit() == Integer(1)!
81 assert Commutator(a, N).doit() == a!
82 assert qapply(a*k) == (sqrt(k.n)*SHOKet(k.n-Integer(1))).expand()!
83 assert qapply(a*kz) == Integer(0)!
84 assert qapply(a*kf) == (sqrt(kf.n)*SHOKet(kf.n-Integer(1))).expand()!
85 assert a.rewrite('xp').doit() == \!
86 (Integer(1)/sqrt(Integer(2)*hbar*m*omega))*(I*Px + m*omega*X)!
87 for i in range(ndim - 1):!
88 assert a_rep[i,i + 1] == sqrt(i + 1)!
89 !
90 def test_NumberOp():!
91 assert Commutator(N, ad).doit() == ad!
92 assert Commutator(N, a).doit() == Integer(-1)*a!
93 assert Commutator(N, H).doit() == Integer(0)!
94 assert qapply(N*k) == (k.n*k).expand()!
95 assert N.rewrite('a').doit() == ad*a!
96 assert N.rewrite('xp').doit() ==
… (Integer(1)/(Integer(2)*m*hbar*omega))*(!
97 Px**2 + (m*omega*X)**2) - Integer(1)/Integer(2)!
98 assert N.rewrite('H').doit() == H/(hbar*omega) - Integer(1)/Integer(2)!
99 for i in range(ndim):!
100 assert N_rep[i,i] == i!
101 assert N_rep == ad_rep_sympy*a_rep!

Tests for Quantum Simple Harmonic Oscillator 33

102 !
103 def test_Hamiltonian():!
104 assert Commutator(H, N).doit() == Integer(0)!
105 assert qapply(H*k) == ((hbar*omega*(k.n +
… Integer(1)/Integer(2)))*k).expand()!
106 assert H.rewrite('a').doit() == hbar*omega*(ad*a +
… Integer(1)/Integer(2))!
107 assert H.rewrite('xp').doit() == \!
108 (Integer(1)/(Integer(2)*m))*(Px**2 + (m*omega*X)**2)!
109 assert H.rewrite('N').doit() == hbar*omega*(N + Integer(1)/Integer(2))!
110 for i in range(ndim):!
111 assert H_rep[i,i] == hbar*omega*(i + Integer(1)/Integer(2))!
112 !
113 def test_SHOKet():!
114 assert SHOKet('k').dual_class() == SHOBra!
115 assert SHOBra('b').dual_class() == SHOKet!
116 assert InnerProduct(b,k).doit() == KroneckerDelta(k.n, b.n)!
117 assert k.hilbert_space == ComplexSpace(S.Infinity)!
118 assert k3_rep[k3.n, 0] == Integer(1)!
119 assert b3_rep[0, b3.n] == Integer(1)!
120

Tests for Quantum Simple Harmonic Oscillator 34

 Heading 1

Mapping Gate

Imports

Before examining the Mapping Gate, the relevant files need to be loaded.

In [1]: %load_ext sympy.interactive.ipythonprinting

from sympy import Symbol, Integer, I
from sympy.core.containers import Dict
from sympy.physics.quantum import qapply, represent
from sympy.physics.quantum.qubit import Qubit
from sympy.physics.quantum.mappinggate import MappingGate

Theory/Background

Creating a MappingGate can be very useful in Quantum Computing. Normally one would have to use a combination of
various quantum gates to get the desired input-output state pairings. The Mapping Gate allows for user provided initial and
final state pairings for every state. Then a quantum gate that has the same pairings is created.

The Mapping Gate maps an initial qubits to scalars times final qubits. If no scalar is specified one is assumed. So there are
two or three arguments for the mapping gate.

arg[0] = initial state

arg[1] = scalar or final state

arg[2] = final state or none

The qubits can either be strings or qubits. The resulting arguments of the MappingGate are converted to a sympy
dictionary.

There are multiple ways to specify the qubit pairings. All quantum gates have the property of being unitary, which means
only half of the gate needs to be specified and the rest can be assumed and created to preserve the unitary property. When
thinking about the gates as matrices, it is only required to specify half of the matrix. And if an initial state is not paired to a
final state it will return itself like the Identity Gate.

The Mapping Gate can also take a Python or Sympy dictionary as its argument. The dictionary requires qubit objects rather
than strings and the scalars are multiplied with the final states.

{Qubit('initial'):scalar*Qubit('final'), ...}

Creating the MappingGate

Specify all states

Quantum Mapping Gate Example Notebook 35

Here, all pairs are specified. There are 2^n number of pairs, where n is the number of qubits in each state.

In [2]: M_all = MappingGate(('00', I, '11'), ('01', exp(I), '10'), ('10', exp(-I), '01'), ('11'

In [3]: M_all.args

Out[3]:
( { ∣00⟩ : ı∣11⟩, ∣01⟩ : eı ∣10⟩, ∣10⟩ : e−ı ∣01⟩, ∣11⟩ : −ı∣00⟩ } )

Another useful way to express a quantum gate is using outer product representation. This takes the form:

ket(final)*bra(initial) + ...

To call this, we use rewrite and pass it a keyword, in this case 'op'.

In [4]: M_all.rewrite('op')

Out[4]: −ı∣00⟩⟨11∣ + e−ı ∣01⟩⟨10∣ + eı ∣10⟩⟨01∣ + ı∣11⟩⟨00∣

Another common way of expressing a quantum gate is in matrix form. Any term in a matrix can be identified using a bra and
a ket (i.e. (0,1) is the same as bra(0) ket(1)). Using this idea a quantum gate is created by inserting the outer product in
between each identifying bra and ket for each term. If the qubits in the MappingGate return themselves the resulting matrix
is the identity gate.

In [5]: M_test = MappingGate(('0','0'), ('1','1'))

In [6]: represent(M_test)

[0 1]
Out[6]: 1 0

Now taking a look at the more complex qubit mapping from above, it is clear that the outer product terms are directly
related to the terms of the matrix.

In [7]: represent(M_all)

[ 0ı 0 ]
Out[7]: 0 0 0 −ı
0 0 e−ı 0
eı 0
0 0 0

Specify only half of the states and relying on the unitary property of the gate.

Here, only half of the pairs are specified because the unitary property of the gate can fill the rest. Given that initial = scalar *
final, this implies that final = conjugate(scalar) * initial. This is what allows for only mapping the upper triangle of the matrix.
The idea of only mapping the one triangle will be more easily seen when the gate is represented in matrix form

In [8]: M_half = MappingGate(('00', I, '11'), ('01', exp(I), '10'))

Quantum Mapping Gate Example Notebook 36

In [9]: M_half.args

Out[9]:
( { ∣00⟩ : ı∣11⟩, ∣01⟩ : eı ∣10⟩, ∣10⟩ : e−ı ∣01⟩, ∣11⟩ : −ı∣00⟩ } )

We can check that the mapping for this is the same as the full mapping

In [10]: M_half.args == M_all.args

Out[10]:

Let's look at the outerproduct representation, it should be the same as above in M_all

In [11]: M_half.rewrite('op')

Out[11]: −ı∣00⟩⟨11∣ + e−ı ∣01⟩⟨10∣ + eı ∣10⟩⟨01∣ + ı∣11⟩⟨00∣

Using the matrix representation it is clear that we only mapped the terms at (3,0) and (2,1) and the terms at (0,3) and (1,2)
are the conjugates of the mapped terms.

In [12]: represent(M_half)

[ 0ı 0 ]
Out[12]: 0 0 0 −ı
0 0 e−ı 0
eı 0
0 0 0

Specify only some states

Here, only some states will be specified and their compliments. Any state not specified returns itself, but is not one of the
arguments of MappingGate.

In [13]: M_some = MappingGate(('00', I, '11'))

In [14]: M_some.args

Out[14]:
( { ∣00⟩ : ı∣11⟩, ∣11⟩ : −ı∣00⟩ } )

When using the outer product representation it will be clear that non-specified states return themselves.

In [15]: M_some.rewrite('op')

Out[15]: ∣01⟩⟨01∣ + ∣10⟩⟨10∣ − ı∣00⟩⟨11∣ + ı∣11⟩⟨00∣

States that return themselves will yield a 1 along the diaganol like the identity matrix.

In [16]: represent(M_some)

[ 0ı 0 ]
Out[16]: 0 0 0 −ı
0 1 0 0
0 1 0
0 0

Quantum Mapping Gate Example Notebook 37

Using a Python Dictionary

The MappingGate can also take dictionaries as its arguments. Passing a dictionary as the argument to MappingGate works
exactly the same as seen above except for the required form of the dictionary. Where as above MappingGate accepts either
strings or qubits, a dictionary must contain qubits. Again if not all states are specified they will return themselves and only
half of the matrix needs to be mapped. MappingGate converts the python dictionary to a sympy dictionary.

In [17]: d = dict({Qubit('00'):I*Qubit('11'), Qubit('01'):exp(I)*Qubit('10')})

M_python_dict = MappingGate(d)

In [18]: M_python_dict.args

Out[18]:
( { ∣00⟩ : ı∣11⟩, ∣01⟩ : eı ∣10⟩, ∣10⟩ : e−ı ∣01⟩, ∣11⟩ : −ı∣00⟩ } )

Check that the outer product and matrix are the same as the the previous gates.

In [19]: M_python_dict.rewrite('op')

Out[19]: −ı∣00⟩⟨11∣ + e−ı ∣01⟩⟨10∣ + eı ∣10⟩⟨01∣ + ı∣11⟩⟨00∣

In [20]: M_python_dict.rewrite('op') == M_half.rewrite('op') == M_all.rewrite('op')

Out[20]:

In [21]: represent(M_python_dict)

[ 0ı 0 ]
Out[21]: 0 0 0 −ı
0 0 e−ı 0
eı 0
0 0 0

In [22]: represent(M_python_dict) == represent(M_half) == represent(M_all)

Out[22]:

Using a Sympy Dictionary

A sympy dictionary can also be used to specify the qubit mapping. It works the same as the python dictionary.

In [23]: d = Dict({Qubit('00'):I*Qubit('11'), Qubit('01'):exp(I)*Qubit('10')})

M_sympy_dict = MappingGate(d)

In [24]: M_sympy_dict.args

Out[24]:
( { ∣00⟩ : ı∣11⟩, ∣01⟩ : eı ∣10⟩, ∣10⟩ : e−ı ∣01⟩, ∣11⟩ : −ı∣00⟩ } )

In [25]: M_sympy_dict.rewrite('op')

Out[25]: −ı∣00⟩⟨11∣ + e−ı ∣01⟩⟨10∣ + eı ∣10⟩⟨01∣ + ı∣11⟩⟨00∣

Quantum Mapping Gate Example Notebook 38

In [26]: represent(M_sympy_dict)

[ 0ı 0 ]
Out[26]: 0 0 0 −ı
0 0 e−ı 0
eı 0
0 0 0

Examples

Create an arbitrary qubit mapping and pass it to MappingGate, then check some of its properties

In [27]: M = MappingGate(('000', -1, '001'), ('010', I, '101'), ('100', I*exp(I), '111'))

Check the arguments and outer product representation make sure there are 8 terms.

In [28]: M.args

Out[28]:
( { ∣000⟩ : −∣001⟩, ∣001⟩ : −∣000⟩, ∣010⟩ : ı∣101⟩, ∣100⟩ : ıeı ∣111⟩, ∣101⟩ : −ı∣010⟩, ∣111⟩ : −ıe

In [29]: M.rewrite('op')

Out[29]: ∣011⟩⟨011∣ + ∣110⟩⟨110∣ − ∣000⟩⟨001∣ − ∣001⟩⟨000∣ − ı∣010⟩⟨101∣ − ıe−ı ∣100⟩⟨111∣ + ı∣101⟩⟨010∣ + ıeı ∣111

Using hilbert_space checks the hilbert space of the gate.

In [30]: M.hilbert_space

2
Out[30]: ⊗3

There are three ways to get the final state from the initial state: get_final_state, mapping, and qapply. get_final_state takes
either strings or qubits where both mapping and qapply require qubits.

In [31]: M.get_final_state('100')

Out[31]: ıeı ∣111⟩

In [32]: M.mapping[Qubit('100')]

Out[32]: ıeı ∣111⟩

In [33]: qapply(M*Qubit('100'))

Out[33]: ıeı ∣111⟩

The MappingGate can also act on individual qubit states or multiple qubit states.

Quantum Mapping Gate Example Notebook 39

In [34]: q1 = Qubit('000')
q2 = Qubit('110') + Qubit('100')
q3 = Qubit('101') + Qubit('000') + Qubit('100')

In [35]: qapply(M*q1)

Out[35]: −∣001⟩

In [36]: qapply(M*q2)

Out[36]: ∣110⟩ + ıeı ∣111⟩

In [37]: qapply(M*q3)

Out[37]: −∣001⟩ − ı∣010⟩ + ıeı ∣111⟩

There are three formats of the matrix representation that can be used, sympy-default, numpy, and scipy.sparse. For large
matrices (i.e. large number of qubits) it is common to use the scipy.sparse format.

In [38]: represent(M, format='sympy')

⎡ 0 ⎤
⎢ −1 ⎥
Out[38]: −1 0 0 0 0 0 0
0 0 0 0 0 0 0
⎢ 0 0 0 0 0 −ı 0 0 ⎥
⎢ 00 0 0 1 0 0 0 0 ⎥
⎢ 0 0 0 0 0 0 0 −ıe−ı
⎥
⎢ 0 0 ı 0 0 0 0 0
⎥
⎣ 0 ⎦
0 0 0 0 0 1 0
0 0 0 ıeı 0 0 0

Quantum Mapping Gate Example Notebook 40

In [39]: represent(M, format='numpy')

Out[39]: [[ 0.00000000+0.j -1.00000000+0.j

0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
]
[-1.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
]
[ 0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
0.00000000-1.j
0.00000000+0.j 0.00000000+0.j
]
[ 0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
1.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
]
[ 0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j
-0.84147098-0.54030231j]
[ 0.00000000+0.j 0.00000000+0.j
0.00000000+1.j
0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
]
[ 0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
1.00000000+0.j 0.00000000+0.j
]
[ 0.00000000+0.j 0.00000000+0.j
0.00000000+0.j
0.00000000+0.j -0.84147098+0.54030231j
0.00000000+0.j
0.00000000+0.j 0.00000000+0.j
]]

Quantum Mapping Gate Example Notebook 41

In [40]: represent(M, format='scipy.sparse')

Out[40]: (0, 1.0) (-1+0j)

(1, 0.0) (-1+0j)
(2, 5.0)
-1j
(3, 3) (1+0j)
(4, 7.0) (-0.841470984808-0.540302305868j)
(5, 2.0)
1j
(6, 6) (1+0j)
(7, 4.0) (-0.841470984808+0.540302305868j)

Example with nqubits = 5

The matrix representation of a quantum gate is a 2^n by 2^n matrix, so even for relatively small states there is a lot of data
stored. An example with states of 5 qubits should use scipy.sparse representation rather than the default sympy
representation.

In [41]: M_large = MappingGate(('00000', I, '00001'), ('00010', '11111'))

In [42]: represent(M_large)

Out[42]: ⎡0 −ı 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0⎤
⎢ 0ı 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0⎥
⎢0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0⎥
1
⎢0 0⎥
0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
⎢ 00 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0⎥
⎢0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0⎥
0

⎢0 0⎥
0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
⎢ 00 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0⎥
⎢0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0⎥
0

⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
⎢ 00 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0⎥
⎢0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0⎥
0

⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0
⎢ 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0⎥
⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0

⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0
⎢ 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0⎥
⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 0

⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0
⎢ 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0⎥
⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0

⎢0 0⎥
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0
⎢ 00 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0 0⎥
⎣0 0⎦
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 1 0
0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0

Notice that essentially the entire matrix is zeros with ones along the diagonal. Using the scipy.sparse format here will
condense the result.

Quantum Mapping Gate Example Notebook 42

In [43]: represent(M_large, format='scipy.sparse')

Out[43]: (0, 1.0) -1j

(1, 0.0) 1j
(2, 31.0) (1+0j)
(3, 3)
(1+0j)
(4, 4)
(1+0j)
(5, 5)
(1+0j)
(6, 6)
(1+0j)
(7, 7)
(1+0j)
(8, 8)
(1+0j)
(9, 9)
(1+0j)
(10, 10) (1+0j)
(11, 11) (1+0j)
(12, 12) (1+0j)
(13, 13) (1+0j)
(14, 14) (1+0j)
(15, 15) (1+0j)
(16, 16) (1+0j)
(17, 17) (1+0j)
(18, 18) (1+0j)
(19, 19) (1+0j)
(20, 20) (1+0j)
(21, 21) (1+0j)
(22, 22) (1+0j)
(23, 23) (1+0j)
(24, 24) (1+0j)
(25, 25) (1+0j)
(26, 26) (1+0j)
(27, 27) (1+0j)
(28, 28) (1+0j)
(29, 29) (1+0j)
(30, 30) (1+0j)
(31, 2.0) (1+0j)

Creating Quantum Gates

MappingGate can be used to create any of the common quantum gates by specifying the same mappings. Let's create the
ZGate, XGate, and YGate.

ZGate

In [44]: from sympy.physics.quantum.gate import ZGate

In [45]: Z = ZGate(0)
M_Z = MappingGate(('0', '0'), ('1', -1, '1'))

Quantum Mapping Gate Example Notebook 43

In [46]: represent(Z, nqubits=1)

[0 −1 ]
Out[46]: 1 0

In [47]: represent(M_Z)

[0 −1 ]
Out[47]: 1 0

In [48]: represent(Z, nqubits=1) == represent(M_Z)

Out[48]:

XGate

In [49]: from sympy.physics.quantum.gate import XGate

In [50]: X = XGate(0)
M_X = MappingGate(('0', '1'))

In [51]: represent(X, nqubits=1)

[1 0]
Out[51]: 0 1

In [52]: represent(M_X)

[1 0]
Out[52]: 0 1

In [53]: represent(X, nqubits=1) == represent(M_X)

Out[53]:

In [54]: from sympy.physics.quantum.gate import YGate

In [55]: Y = YGate(0)
M_Y = MappingGate(('0', I, '1'))

In [56]: represent(Y, nqubits=1)

[ı 0 ]
Out[56]: 0 −ı

Quantum Mapping Gate Example Notebook 44

In [57]: represent(M_Y)

[ı 0 ]
Out[57]: 0 −ı

In [58]: represent(Y, nqubits=1) == represent(M_Y)

Out[58]:

For Additional Quantum Gate Information

Griffiths, David J. Introduction to Quantum Mechanics. Upper Saddle River, NJ: Pearson Prentice Hall, 2005. Print.

http://en.wikipedia.org/wiki/Quantum_gate

In [ ]:

Quantum Mapping Gate Example Notebook 45

 1 """Mapping Quantum Gates
2
3 TODO:
4 - Enable sparse mappings for large numbers of qubits
5 """
6
7 from sympy import Integer, conjugate, Add, Mul
8 from sympy.core.containers import Dict
9 from sympy.physics.quantum import Dagger
10 from sympy.physics.quantum.gate import Gate
11 from sympy.physics.quantum.qubit import Qubit, IntQubit
12 from sympy.physics.quantum.matrixutils import matrix_eye
13 from sympy.physics.quantum.qexpr import split_qexpr_parts
14 from sympy.physics.quantum.hilbert import ComplexSpace
15
16 #-----------------------------------------------------------------------------
17
18
19 class MappingGate(Gate):
20 """
21
22 Parameters
23 ==========
24
25 args : tuple, dict
26
27 arg[0] = initial state
28 arg[1] = scalar or final state
29 arg[2] = None or final state
30
31 The list of initial state and final state pairs. The final states are
32 multiplied by some scalar. If no scalar is given, 1 is assumed. Only n
33 supply the qubit mapping for half of the matrix representation of the
34 Since a quantum gate is required to be unitary, the other half is crea
35 to ensure it is unitary. Can pass either a python or sympy dictionary
36 already has the qubit mappings.
37
38 Examples
39 ========
40
41 Creating a Mapping Gate and checking its arguments and properties. Getting
42 state from initial state.
43
44 >>> from sympy.physics.quantum.mappinggate import MappingGate
45 >>> from sympy.physics.quantum.qubit import Qubit
46 >>> from sympy import I
47 >>> M = MappingGate(('00',I,'11'), ('01','10'), ('10','01'), ('11',-I,
48 >>> M.args
49 ({|00>: I*|11>, |01>: |10>, |10>: |01>, |11>: -I*|00>},)
50 >>> M.nqubits
51 2
52 >>> M.mapping[Qubit('00')]

Quantum Mapping Gate 46

 53 I*|11>
54 >>> M.get_final_state('00')
55 I*|11>
56
57 Create a Mapping Gate by only giving half of the initial and final state p
58 the resulting arguments are the same as the example above. Also passing a
59 or sympy dictionary to MappingGate can have the same result.
60
61 >>> from sympy.physics.quantum.mappinggate import MappingGate
62 >>> from sympy import I
63 >>> M = MappingGate(('00', I, '11'), ('01', '10'))
64 >>> M.args
65 ({|00>: I*|11>, |01>: |10>, |10>: |01>, |11>: -I*|00>},)
66 >>> d = dict({Qubit('00'):I*Qubit('11'), Qubit('01'):Qubit('10')})
67 >>> M_dict = MappingGate(d)
68 >>> M.args
69 ({|00>: I*|11>, |01>: |10>, |10>: |01>, |11>: -I*|00>},)
70
71 Using qapply on initial states returns the final states.
72
73 >>> from sympy.physics.quantum.mappinggate import MappingGate
74 >>> from sympy import I
75 >>> from sympy.physics.quantum.qapply import qapply
76 >>> from sympy.physics.quantum.qubit import Qubit
77 >>> M = MappingGate(('00', I, '11'), ('01', '10'))
78 >>> q = Qubit('00') + Qubit('01')
79 >>> qapply(M*q)
80 |10> + I*|11>
81
82 The MappingGate can be rewritten as an outer product of states. We will sh
83 examples: one where all four states are given and one where only one state
84 given. If not all initial states are specified they return themselves as f
85 states.
86
87 >>> from sympy.physics.quantum.mappinggate import MappingGate
88 >>> from sympy import I
89 >>> M = MappingGate(('00', I, '11'), ('01', '10'))
90 >>> M.rewrite('op')
91 |01><10| + |10><01| - I*|00>*<11| + I*|11>*<00|
92 >>> M = MappingGate(('00', -1, '00'))
93 >>> M.rewrite('op')
94 |01><01| + |10><10| + |11><11| - |00>*<00|
95
96 The MappingGate is also expressed as a matrix where the rows and columns
97 represent the Qubits.
98
99 >>> from sympy.physics.quantum.mappinggate import MappingGate
100 >>> from sympy.physics.quantum.represent import represent
101 >>> from sympy import I
102 >>> M = MappingGate(('00', I, '11'), ('01', '10'))
103 >>> represent(M)
104 [0, 0, 0, -I]

Quantum Mapping Gate 47

105 [0, 0, 1, 0]
106 [0, 1, 0, 0]
107 [I, 0, 0, 0]
108
109 """
110
111 @classmethod
112 def _eval_args(cls, args):
113 if len(args) == 1 and isinstance(args[0], (dict, Dict)):
114 temp = {}
115 for i, f in args[0].items():
116 terms = split_qexpr_parts(f)
117 if len(terms[1]) == 0:
118 temp[f] = i
119 else:
120 temp[terms[1][0]] = conjugate(Mul(*terms[0]))*i
121 temp[i] = f
122 new_args = Dict(temp)
123 else:
124 temp = {}
125 for arg in args:
126 i = Qubit(arg[0])
127 if len(arg) == 2:
128 scalar = Integer(1)
129 f = Qubit(arg[1])
130 elif len(arg) == 3:
131 scalar = arg[1]
132 f = Qubit(arg[2])
133 else:
134 raise ValueError('Too many scalar arguments')
135 if i.nqubits != f.nqubits:
136 raise ValueError('Number of qubits for each state do not m
137 temp[f] = conjugate(scalar)*i
138 temp[i] = scalar*f
139 new_args = Dict(temp)
140 return (new_args,)
141
142 @classmethod
143 def _eval_hilbert_space(cls, args):
144 return ComplexSpace(2)**args[0].keys()[0].nqubits
145
146 @property
147 def mapping(self):
148 return self.args[0]
149
150 @property
151 def nqubits(self):
152 """Gives the dimension of the matrix representation"""
153 return self.args[0].keys()[0].nqubits
154
155 def get_final_state(self, qubit):
156 """Returns the final state for a given initial state, if initial state

Quantum Mapping Gate 48

157 not mapped to a final state the initial state is returned."""
158 i = Qubit(qubit)
159 return self.mapping.get(i, i)
160
161 def _apply_operator_Qubit(self, qubit):
162 return self.get_final_state(qubit)
163
164 def _eval_rewrite_as_op(self, *args):
165 terms = []
166 for i in range(2**self.nqubits):
167 initial = Qubit(IntQubit(i, self.nqubits))
168 fin = self.get_final_state(initial)
169 terms.append(fin*Dagger(initial))
170 return Add(*terms)
171
172 def _represent_default_basis(self, **options):
173 return self._represent_ZGate(None, **options)
174
175 def _represent_ZGate(self, basis, **options):
176 format = options.get('format','sympy')
177 matrix = matrix_eye(2**self.nqubits, **options)
178 for i, f in self.mapping.items():
179 col = IntQubit(i).as_int()
180 terms = split_qexpr_parts(f)
181 if len(terms[1]) == 0:
182 row = IntQubit(*terms[0]).as_int()
183 scalar = Integer(1)
184 else:
185 row = IntQubit(*terms[1]).as_int()
186 scalar = Mul(*terms[0])
187 if format == 'scipy.sparse':
188 matrix = matrix.tolil()
189 col = float(col)
190 row = float(row)
191 scalar = complex(scalar)
192 matrix[col, col] = 0.0
193 matrix[row, col] = scalar
194 elif format == 'numpy':
195 scalar = complex(scalar)
196 matrix[col, col] = 0.0
197 matrix[row, col] = scalar
198 else:
199 matrix[col, col] = Integer(0)
200 matrix[row, col] = scalar
201 return matrix
202

Quantum Mapping Gate 49

 1 """Tests for mappinggate.py"""!
2 !
3 from sympy import I, Integer, Mul, Add!
4 from sympy.physics.quantum import Dagger!
5 from sympy.physics.quantum.qapply import qapply!
6 from sympy.physics.quantum.represent import represent!
7 from sympy.physics.quantum.qexpr import split_qexpr_parts!
8 from sympy.physics.quantum.hilbert import ComplexSpace!
9 from sympy.physics.quantum.qubit import Qubit, IntQubit!
10 from sympy.physics.quantum.mappinggate import MappingGate!
11 from sympy.external import import_module!
12 from sympy.utilities.pytest import skip!
13 !
14 np = import_module('numpy', min_python_version=(2, 6))!
15 scipy = import_module('scipy', __import__kwargs={'fromlist': ['sparse']})!
16 !
17 # All 3 ways produce same Qubit Mappings!
18 M = MappingGate(('00', I, '11'), ('01', '10'), ('10', '01'), ('11', -I,
… '00'))!
19 M_half = MappingGate(('00', I, '11'), ('01', '10'))!
20 d = dict({Qubit('00'):I*Qubit('11'), Qubit('01'):Qubit('10')})!
21 M_dict = MappingGate(d)!
22 !
23 M_rep = represent(M, format='sympy')!
24 !
25 def test_MappingGate():!
26 assert M.get_final_state('00') == I*Qubit('11')!
27 assert M.mapping[Qubit('00')] == I*Qubit('11')!
28 assert qapply(M*Qubit('01')) == Qubit('10')!
29 assert M.hilbert_space == ComplexSpace(2)**M.nqubits!
30 # Shows same qubit mappings!
31 assert M.args == M_half.args!
32 assert M.args == M_dict.args!
33 !
34 terms = []!
35 for i in range(2**M.nqubits):!
36 initial = Qubit(IntQubit(i, M.nqubits))!
37 fin = M.get_final_state(initial)!
38 terms.append(fin*Dagger(initial))!
39 result = Add(*terms)!
40 assert M.rewrite('op') == result!
41 !
42 for i, f in M.mapping.items():!
43 col = IntQubit(i).as_int()!
44 terms = split_qexpr_parts(f)!
45 if len(terms[1]) == 0:!
46 row = IntQubit(*terms[0]).as_int()!
47 scalar = Integer(1)!
48 else:!
49 row = IntQubit(*terms[1]).as_int()!
50 scalar = Mul(*terms[0])!
51 assert M_rep[row, col] == scalar!

Tests for Quantum Mapping Gate 50

52 !
53 if not np:!
54 skip("numpy not installed or Python too old.")!
55 !
56 M_rep_numpy = represent(M, format='numpy')!
57 for i, f in M.mapping.items():!
58 col = IntQubit(i).as_int()!
59 terms = split_qexpr_parts(f)!
60 if len(terms[1]) == 0:!
61 row = IntQubit(*terms[0]).as_int()!
62 scalar = Integer(1)!
63 else:!
64 row = IntQubit(*terms[1]).as_int()!
65 scalar = Mul(*terms[0])!
66 assert M_rep_numpy[row, col] == complex(scalar)!
67 !
68 if not np:!
69 skip("numpy not installed or Python too old.")!
70 if not scipy:!
71 skip("scipy not installed.")!
72 else:!
73 sparse = scipy.sparse!
74 !
75 M_rep_scipy = represent(M, format='scipy.sparse')!
76 for i, f in M.mapping.items():!
77 col = IntQubit(i).as_int()!
78 terms = split_qexpr_parts(f)!
79 if len(terms[1]) == 0:!
80 row = IntQubit(*terms[0]).as_int()!
81 scalar = Integer(1)!
82 else:!
83 row = IntQubit(*terms[1]).as_int()!
84 scalar = Mul(*terms[0])!
85 col = float(col)!
86 row = float(row)!
87 scalar = complex(scalar)!
88 assert M_rep_scipy[row, col] == scalar!
89

Tests for Quantum Mapping Gate 51

 Appendix

Links
The following are the addresses of the two Quantum projects on the GitHub website in the
SymPy directory.

Quantum Simple Harmonic Oscillator

https://github.com/sympy/sympy/blob/master/sympy/physics/quantum/sho1d.py

Quantum Mapping Gate

https://github.com/sympy/sympy/blob/master/sympy/physics/quantum/mappinggate.py

References
“GitHub." <http://en.wikipedia.org/wiki/GitHub>.

Griffiths, David J. Introduction to Quantum Mechanics. Upper Saddle River, NJ: Pearson
Prentice Hall, 2005. Print.

“SymPy." SymPy. Web. 15 Mar. 2013. <http://sympy.org/en/index.html>.

Appendix 52