{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Density Operator and Matrix "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Imports"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"from IPython.display import display"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"# TODO: there is a bug in density.py that is preventing this from working, uncomment to reproduce\n",
"# from sympy import init_printing\n",
"# init_printing(use_latex=True)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"from sympy import *\n",
"from sympy.core.trace import Tr\n",
"from sympy.physics.quantum import *\n",
"from sympy.physics.quantum.density import *\n",
"from sympy.physics.quantum.spin import (\n",
" Jx, Jy, Jz, Jplus, Jminus, J2,\n",
" JxBra, JyBra, JzBra,\n",
" JxKet, JyKet, JzKet,\n",
")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Basic density operator"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Create a density matrix using symbolic states:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"psi = Ket('psi')\n",
"phi = Ket('phi')"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((|psi>, 0.5),(|phi>, 0.5))"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = Density((psi,0.5),(phi,0.5));\n",
"d"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"(|psi>, |phi>)"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d.states()"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"(0.5, 0.5)"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d.probs()"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0.5*|phi><phi| + 0.5*|psi><psi|"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d.doit()"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((|psi>, 0.5),(|phi>, 0.5))"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Dagger(d)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"A = Operator('A')"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((A*|psi>, 0.5),(A*|phi>, 0.5))"
]
},
"execution_count": 11,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d.apply_op(A)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Density operator for spin states"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now create a density operator using spin states:"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"up = JzKet(S(1)/2,S(1)/2)\n",
"down = JzKet(S(1)/2,-S(1)/2)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((|1/2,1/2>, 0.5),(|1/2,-1/2>, 0.5))"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d2 = Density((up,0.5),(down,0.5)); d2"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Matrix([\n",
"[0.5, 0],\n",
"[ 0, 0.5]])"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"represent(d2)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((Jz*|1/2,1/2>, 0.5),(Jz*|1/2,-1/2>, 0.5))"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d2.apply_op(Jz)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((hbar*|1/2,1/2>/2, 0.5),(-hbar*|1/2,-1/2>/2, 0.5))"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qapply(_)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0.5*Jy*|1/2,-1/2><1/2,-1/2| + 0.5*Jy*|1/2,1/2><1/2,1/2|"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qapply((Jy*d2).doit())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Evaluate entropy of the density matrices"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"log(2)/2"
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"entropy(d2)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"log(2)/2"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"entropy(represent(d2))"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"(0.69314718055994529-0j)"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"entropy(represent(d2,format=\"numpy\"))"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"(0.69314718055994529-0j)"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"entropy(represent(d2,format=\"scipy.sparse\"))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Density operators with tensor products"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0.5*(A*Dagger(A))x(B*Dagger(B)) + 0.5*(C*Dagger(C))x(D*Dagger(D))"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"A, B, C, D = symbols('A B C D',commutative=False)\n",
"\n",
"t1 = TensorProduct(A,B,C)\n",
"\n",
"d = Density([t1, 1.0])\n",
"d.doit()\n",
"\n",
"t2 = TensorProduct(A,B)\n",
"t3 = TensorProduct(C,D)\n",
"\n",
"d = Density([t2, 0.5], [t3, 0.5])\n",
"d.doit() "
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"1.0*(A*Dagger(A))x(B*Dagger(B)) + 1.0*(A*Dagger(C))x(B*Dagger(D)) + 1.0*(C*Dagger(A))x(D*Dagger(B)) + 1.0*(C*Dagger(C))x(D*Dagger(D))"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = Density([t2+t3, 1.0])\n",
"d.doit() "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Trace operators on density operators with spin states"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Tr(Density((|1,1>, 0.5),(|1,-1>, 0.5)))"
]
},
"execution_count": 24,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = Density([JzKet(1,1),0.5],[JzKet(1,-1),0.5]);\n",
"t = Tr(d);\n",
"t"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"1.00000000000000"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t.doit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Partial Trace on density operators with mixed state"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((AxB, 0.5),(CxD, 0.5))"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"A, B, C, D = symbols('A B C D',commutative=False)\n",
"\n",
"t1 = TensorProduct(A,B,C)\n",
"\n",
"d = Density([t1, 1.0])\n",
"d.doit()\n",
"\n",
"t2 = TensorProduct(A,B)\n",
"t3 = TensorProduct(C,D)\n",
"\n",
"d = Density([t2, 0.5], [t3, 0.5])\n",
"d"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"0.5*A*Dagger(A)*Tr(B*Dagger(B)) + 0.5*C*Dagger(C)*Tr(D*Dagger(D))"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"tr = Tr(d,[1])\n",
"tr.doit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Partial trace on density operators with spin states"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"tp1 = TensorProduct(JzKet(1,1), JzKet(1,-1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Trace out the `0` index:"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Tr((|1,1>x|1,-1>, 1))"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d = Density([tp1,1]);\n",
"t = Tr(d,[0])\n",
"t"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"|1,-1><1,-1|"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t.doit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Trace out the `1` index:"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Tr((|1,1>x|1,-1>, 1))"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t = Tr(d,[1])\n",
"t"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"|1,1><1,1|"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"t.doit()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Examples of `qapply()` on density matrices with spin states"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"O*Density((|psi>, 0.5),(|phi>, 0.5))"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"psi = Ket('psi')\n",
"phi = Ket('phi')\n",
"\n",
"u = UnitaryOperator()\n",
"d = Density((psi,0.5),(phi,0.5)); d\n",
"\n",
"qapply(u*d)"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Matrix([\n",
"[ 0, Density((|1/2,1/2>, 0.5),(|1/2,-1/2>, 0.5))],\n",
"[Density((|1/2,1/2>, 0.5),(|1/2,-1/2>, 0.5)), 0]])"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"up = JzKet(S(1)/2, S(1)/2)\n",
"down = JzKet(S(1)/2, -S(1)/2)\n",
"d = Density((up,0.5),(down,0.5))\n",
"\n",
"uMat = Matrix([[0,1],[1,0]])\n",
"qapply(uMat*d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Example of `qapply()` on density matrices with qubits"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"Density((|0>, 0.5),(|1>, 0.5))"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"from sympy.physics.quantum.gate import UGate\n",
"from sympy.physics.quantum.qubit import Qubit\n",
"\n",
"uMat = UGate((0,), Matrix([[0,1],[1,0]]))\n",
"d = Density([Qubit('0'),0.5],[Qubit('1'), 0.5])\n",
"d"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"U((0,),Matrix([\n",
"[0, 1],\n",
"[1, 0]]))*Density((|0>, 0.5),(|1>, 0.5))"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"#after applying Not gate\n",
"qapply(uMat*d)"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.1"
}
},
"nbformat": 4,
"nbformat_minor": 0
}