{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Tight informationally complete quantum measurements"
]
},
{
"cell_type": "code",
"execution_count": 101,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"import scipy as sc\n",
"import scipy.linalg\n",
"np.set_printoptions(precision=6, suppress=True)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Spherical t-designs\n",
"\n",
"We begin with \"spherical t-designs.\" They're useful for numerical integration. Basically instead of integrating a polynomial over some space, you can instead take a finite sum of the values of the polynomial at some specially chosen points: and you get the same answer!\n",
"\n",
"So: a spherical t-design is a set of $n$ normalized vectors such that the average value of any $t$-th order (homogeneous) polynomial over the set is equal to the average of over all normalized vectors.\n",
"\n",
"In other words, working with a unit 2-sphere, and a $t$-th order polynomial $f_{t}(\\psi)$, and $n$ points $\\{ |\\psi_{i}\\rangle \\}$:\n",
"\n",
"$$ \\frac{1}{4\\pi}\\int_{S^2} p(\\psi) d\\psi = \\frac{1}{n}\\sum_{i=0}^{n} p(\\psi_{i}) $$\n",
"\n",
"As we'll see, a set of $t$-design vectors have the property that they minimize the $t$-th order frame potential:\n",
"\n",
"$$ \\sum_{i,j} |\\langle \\psi_{i} | \\psi_{j} \\rangle|^{2t} $$ \n",
"\n",
"So let's look for one! We'll use `jax` for some just-in-time complication and for taking derivatives, and `scipy.optimize` for the constrained optimization."
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {},
"outputs": [],
"source": [
"import jax\n",
"import jax.numpy as jp\n",
"\n",
"def spherical_design(d, n, t):\n",
" @jax.jit\n",
" def frame_potential(V):\n",
" R = V.reshape(d, n)\n",
" return sum([jp.abs(jp.dot(a, b))**(2*t) for b in R.T for a in R.T])\n",
" frame_potential_jac = jax.jit(jax.jacrev(frame_potential))\n",
" @jax.jit\n",
" def norm_constraint(V):\n",
" R = V.reshape(d,n)\n",
" return jp.linalg.norm(jp.linalg.norm(R, axis=0) - jp.ones(n))**2\n",
" norm_jac = jax.jit(jax.jacrev(norm_constraint))\n",
" result = sc.optimize.minimize(frame_potential,\\\n",
" np.random.randn(d*n),\\\n",
" jac=frame_potential_jac,\\\n",
" constraints=[{\"type\": \"eq\",\\\n",
" \"fun\": norm_constraint,\\\n",
" \"jac\": norm_jac}],\\\n",
" tol=1e-14,\\\n",
" options={\"ftol\": 1e-14,\\\n",
" \"disp\": True,\\\n",
" \"maxiter\": 5000},\\\n",
" method=\"SLSQP\")\n",
" return result.x.reshape(d, n)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"First, we'll look for a spherical 2-design on the 2-sphere in $\\mathbb{R}^3$ with six elements."
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Optimization terminated successfully. (Exit mode 0)\n",
" Current function value: 7.2000274658203125\n",
" Iterations: 178\n",
" Function evaluations: 437\n",
" Gradient evaluations: 178\n"
]
},
{
"data": {
"text/plain": [
"array([[ 0.654425, -0.138834, -0.029355, -0.804426, -0.871627, -0.378888],\n",
" [ 0.251973, -0.97831 , 0.589923, 0.586375, -0.381487, 0.378301],\n",
" [-0.712908, 0.153738, 0.806925, 0.095198, -0.307788, -0.84459 ]])"
]
},
"execution_count": 103,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d, n, t = 3, 6, 2\n",
"R = spherical_design(d, n, t); R"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now let's make up some random 2nd order homogeneous polynomial:"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {},
"outputs": [],
"source": [
"poly = lambda xyz: xyz[0]**2 + xyz[0]*xyz[1] + 6*xyz[2]**2 + 5*xyz[2]*xyz[0] + xyz[1]**2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We'll use `quadpy` for the numerical integration. (Ironically, of course, under the hood, they basically do the same thing!)"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {},
"outputs": [],
"source": [
"import quadpy\n",
"scheme = quadpy.u3.get_good_scheme(19)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We have $\\frac{1}{n}\\sum_{i=0}^{n} p(\\psi_{i})$:"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.6670280946135927"
]
},
"execution_count": 106,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/n)*sum([poly(r) for r in R.T])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And $\\frac{1}{4\\pi}\\int_{S^2} p(\\psi) d\\psi$:"
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"2.6666666666666665"
]
},
"execution_count": 107,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/(4*np.pi))*scheme.integrate(poly, np.zeros(3), 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Pretty darn close! Let's look at the magical points on the sphere:"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
""
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
},
{
"data": {
"application/javascript": [
"if (typeof Jupyter !== \"undefined\") { window.__context = { glowscript_container: $(\"#glowscript\").removeAttr(\"id\")};}else{ element.textContent = ' ';}"
],
"text/plain": [
""
]
},
"metadata": {},
"output_type": "display_data"
}
],
"source": [
"import vpython as vp\n",
"scene = vp.canvas(background=vp.color.white)\n",
"vp.sphere(color=vp.color.blue, opacity=0.3)\n",
"points = [vp.sphere(radius=0.2, emissive=True, pos=vp.vector(*r)) for r in R.T]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"## Frames and Spherical $t$-designs\n",
"\n",
"(The following exposition is adapted from Symmetric Informationally Complete Quantum Measurements.)\n",
"\n",
"As we now know, a collection of $n$ vectors $\\{| \\psi_{i}\\rangle \\}$ forms a frame if for all vectors $|v\\rangle$:\n",
"\n",
"$$ a|\\langle v | v \\rangle|^2 \\leq \\sum_{i}|\\langle v | \\psi_{i} \\rangle |^2 \\leq b|\\langle v | v \\rangle|^2 $$\n",
"\n",
"Where $a$ and $b$ are the \"frame bounds.\" If $a=b$, the frame is a tight frame.\n",
"\n",
"We can define the frame operator:\n",
"\n",
"$$ S = \\sum_{i} | \\psi_{i} \\rangle \\langle \\psi_{i}| $$\n",
"\n",
"For a tight frame $S = aI$: in other words, $S$ is proportional to the identity.\n",
"\n",
"One implication: a tight frame corresponds to a rank-1 POVM, whose elements are $\\frac{1}{a}|\\psi_{i}\\rangle\\langle\\psi_{i}|$. We'll sometimes write $\\frac{1}{a}\\Pi_{i}$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"\n",
"
\n",
"For a set of normalized vectors, we can define the frame potential:\n",
"\n",
"$$ Tr[S^2] = \\sum_{i,j} |\\langle \\psi_{i}|\\psi_{j}\\rangle|^2 $$\n",
"\n",
"Given a dimension $d$ and $n$ frame vectors:\n",
"\n",
"$$ Tr[S^2] \\ge max(n, \\frac{n^2}{d})$$\n",
"\n",
"The bound is achieved if and only if either a) $ n \\leq d$ and the vectors are all orthonormal or b) $ n \\ge d $, and the vectors form a tight frame.\n",
"\n",
"The proof: First, the the number of nonzero eigenvalues of $S$ is at most $q = min(n,d)$. So we have:\n",
"\n",
"$$ Tr[S] = n = \\sum_{k}^{q} \\lambda_{k} $$\n",
"\n",
"and \n",
"\n",
"$$ Tr[S^2] = \\sum_{k}^{q} \\lambda_{k}^2 $$\n",
"\n",
"\n",
"By Cauchy-Schwartz, we have:\n",
"\n",
"$$ \\sum_{k}^{q} \\lambda_{k}^2 \\ge \\frac{1}{q}(\\sum_{k}^{q} \\lambda_{k})^2$$\n",
"\n",
"$$ Tr[S^2] \\ge \\frac{n^2}{min(n,d)}$$\n",
"\n",
"$$ Tr[S^2] \\ge max(n, \\frac{n^2}{d})$$\n",
"\n",
"Equality holds if and only if $\\lambda_{k} = \\frac{n}{q}$. If $n \\leq d$, we have $\\lambda_{k} = 1$. Thus $S$ is a projector onto an $n$-dimensional subspace, which implies that the vectors are orthogonal. If $n \\ge d$, we have $\\lambda_{k} = \\frac{n}{d}$. Thus $S=\\frac{n}{d}I$, which implies that the vectors form a tight frame.\n",
"\n",
"So tight frames minimize $\\sum_{i,j} |\\langle \\psi_{i}|\\psi_{j}\\rangle|^2 $. That also means that the vectors form a 1-design!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"A symmetric informationally complete POVM, or SIC-POVM, corresponds to a set of $d^2$ normalized vectors $|\\psi_{i}\\rangle$ in $\\mathbb{C}^d$ satisfying:\n",
"\n",
"$$ |\\langle \\psi_{i} | \\psi_{j} \\rangle|^2 = \\frac{1}{d+1}, i \\neq j$$\n",
"\n",
"In other words, they form an equiangular frame.\n",
"\n",
"The POVM elements are $\\frac{1}{d}|\\psi_{i} \\rangle \\langle \\psi_{i}| = \\frac{1}{d}\\Pi_{i}$, whose pairwise Hilbert-Schmidt inner product is:\n",
"\n",
"$$ \\frac{1}{d^2} Tr[\\Pi_{i}^{\\dagger}\\Pi_{j}] = \\frac{1}{d^2(d+1)}, i \\neq j$$\n",
"\n",
"So:\n",
"\n",
"$$Tr[S^2] = \\sum_{i,j} |\\langle \\psi_{i}|\\psi_{j}\\rangle|^2 = (n^2-n)\\frac{1}{d+1} + n = \\frac{d^2(d^2 -1)}{d+1} + d^2 = d^2(d-1) + d^2 = d^3 = \\frac{n^2}{d}$$ \n",
"\n",
"Thus a SIC is a tight frame, and thus, a POVM. \n",
"\n",
"Moreover, a SIC is informationally complete: the $\\Pi_{i}$'s are linearly independent, and span the space of operators. \n",
"\n",
"This follows from the fact that each row of its Gram matrix is a cyclic shift of the previous row. Thus it's a circulant matrix and its eigenvalues are given by the Fourier transform of one of the rows. It turns out in fact that the eigenvalues are exactly the same as the values in any row. Therefore, no eigenvalues are zero, the Gram is full rank, the $\\Pi_{i}$'s are linearly independent, and the POVM is informationally complete.\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"As we discussed a moment ago, a spherical $t$-design is a set of $n$ normalized vectors such that the average value of any $t$-th order polynomial over the set is equal to the average of the polynomial over all normalized vectors.\n",
"\n",
"The concept originally applied to the real Euclidian 2-sphere, but we'll extend the idea to normalized vectors in complex Hilbert space.\n",
"\n",
"Let $\\mathcal{H} = \\mathbb{C}^{d}$, and $\\mathcal{H}_{t} = \\mathcal{H}^{\\otimes t}$ be the $t$-fold tensor product. Furthermore, let $S_{t}$ be the symmetric subspace of $\\mathcal{H}_{t}$, and let $|\\Psi^{t}\\rangle = |\\psi\\rangle^{\\otimes t}$.\n",
"\n",
"We can define a t-order polynomial function in terms of a symmetric operator $F_{t}$:\n",
"\n",
"$$ f_{t}(\\psi) = \\langle \\Psi^{t} | F_{t} | \\Psi^{t} \\rangle $$\n",
"\n",
"We can decompose $F_{t}$ as a sum of product operators: $F_{t} = \\sum_{k}\\otimes_{j=1}^{t} A_{j;k}$, and so any such function can be decomposed into monomials like:\n",
"\n",
"$$ \\langle \\Psi^{t} | \\otimes_{j=1}^{t} A_{j} | \\Psi_{t} \\rangle = \\prod_{j=1}^{t} \\langle \\psi | A_{j} |\\psi \\rangle$$\n",
"\n",
"So let's just consider the monomials, without loss of generality. We can rewrite the above as:\n",
"\n",
"$$ f_{t}(\\psi) = \\prod_{j=1}^{t} Tr[A_{j}|\\psi\\rangle\\langle\\psi |]\\$$\n",
"\n",
"If $\\Pi_{\\psi} = |\\psi\\rangle\\langle \\psi|$, we can further rewrite this as:\n",
"\n",
"$$ f_{t}(\\psi) = Tr[(\\otimes_{j=1}^{t} A_{j})\\Pi_{\\psi}^{\\otimes t}] $$\n",
"\n",
"As we've said, the defining property of a $t$-design is that the average of $f_{t}$ over the design vectors $\\{ | \\psi_{i} \\rangle \\}$ is equal to the average over all normalized vectors $| \\psi \\rangle$. So, the average of $f_{t}$ over all vectors is:\n",
"\n",
"$$\\langle f_{t} \\rangle = \\int d\\psi Tr[(\\otimes_{j=1}^{t} A_{j})\\Pi_{\\psi}^{\\otimes t}] = Tr[(\\otimes_{j=1}^{t} A_{j}) \\int d\\psi \\Pi_{\\psi}^{\\otimes t}] $$\n",
"\n",
"This should be equivalent to:\n",
"\n",
"$$\\langle f_{t} \\rangle = Tr[(\\otimes_{j=1}^{t} A_{j}) K_{t}]$$\n",
"\n",
"For some $K_{t}$ relating to the design vectors.\n",
"\n",
"A spherical $t$-design is then a set of vectors $\\{ | \\psi_{i} \\rangle \\}$ for which:\n",
"\n",
"$$ S_{t} = \\sum_{i}^{n} | \\Psi_{i}^{t} \\rangle \\langle \\Psi_{i}^{t}| = nK_{t} $$\n",
"\n",
"Where $ | \\Psi_{i}^{t} \\rangle = | \\psi_{i} \\rangle^{\\otimes t}$, and $S_{t}$ is the $t$-fold tensor product analogue of the frame operator $S$.\n",
"\n",
"$K_{t}$ only has support on the symmetric subpace. Further, since $K_{t}$ has to be invariant under any $U^{\\otimes t}$ for $U \\in SU(d)$, it has to be proportional to a projector $\\Pi_{sym}^{(t)}$ onto the symmetric subspace. (This follows from Schur's lemma.) If we consider the average of $f_{t}(\\psi) = 1$, then we get $\\langle f_{t} \\rangle = Tr[K_{t}] = 1$. Since the symmetric subspace has dimensions $\\binom{t+d-1}{d-1}$, we have:\n",
"\n",
"$$ K_{t} = \\binom{t+d-1}{d-1}^{-1}\\Pi_{sym} = \\frac{t!(d-1)!}{(t+d-1)!}\\Pi_{sym}^{(t)} $$.\n",
"\n",
"Putting it all together, a set of normalized vectors $\\{ | \\psi_{i} \\rangle \\}$ with $n \\ge \\binom{t+d-1}{d-1}$ forms a spherical t-design if and only if it minimizes the $t$-th order frame potential: indeed, that:\n",
"\n",
"$$ Tr[S_{t}^2] = \\sum_{i,j} |\\langle \\psi_{i} | \\psi_{j} \\rangle|^{2t} = \\frac{n^2t!(d-1)!}{(t+d-1)!}$$\n",
"\n",
"For the case of a 2-design with $d^2$ elements:\n",
"\n",
"$$ Tr[S_{2}^2] = \\frac{2 d^4 (d-1)!}{(d+1)!} = \\frac{2d^4}{d(d+1)} = \\frac{2d^3}{d+1}$$\n",
"\n",
"Indeed, for a SIC-POVM, we have:\n",
"\n",
"$$ Tr[S_{2}^2] = \\sum_{i,j} |\\langle \\psi_{i} | \\psi_{j} \\rangle|^{4} = \\frac{n^2-n}{(d+1)^2} + n = \\frac{d^2(d+1)(d-1)}{(d+1)^2} + d^2 = d^2( \\frac{d-1}{d+1} +1) = d^2( \\frac{d-1 + d+1}{d+1}) = \\frac{2d^3}{d+1}$$\n",
"\n",
"Thus a SIC-POVM is a 2-design. A further argument, which we omit here, proves the converse, that every 2-design with $d^2$ elements is a SIC-POVM."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Complex Projective Designs\n",
"\n",
"(The following exposition is adapted from Tight informationally complete quantum measurements.)\n",
"\n",
"It might be better think of our construction from above as relating to \"complex projective $t$-designs\". \n",
"\n",
"Recall that complex projective space $\\mathbb{C}P^{d-1}$ is the space of lines passing through the origin in $\\mathbb{C}^d$. Each point $x \\in \\mathbb{C}P^{d-1}$ can be represented as a unit vector $\\mid \\psi \\rangle \\in \\mathbb{C}^d$ modulo phase, or as a rank-1 projector $\\Pi_\\psi \\equiv | \\psi \\rangle \\langle \\psi |$.\n",
"\n",
"One way of defining a complex projective t-design:\n",
"\n",
"$$\\frac{1}{n^2} \\sum_{i,j} f_{t}(|\\langle \\psi_{i} | \\psi_{j} \\rangle|^{2t}) = \\int \\int_{\\mathbb{C}P^{d-1}} d\\mu(\\psi)d\\mu(\\phi) f_{t}(|\\langle \\psi | \\phi \\rangle|^2) $$\n",
"\n",
"Where $f_{t}$ is a real polynomial of degree $t$ or less, and $\\mu$ is the unique unitarily invariant probability measure on $\\mathbb{C}P^{d-1}$ induced by the Haar measure on $U(d)$. \n",
"\n",
"Alternatively: \n",
"\n",
"$$ \\int_{\\mathbb{C}P^{d-1}} d\\mu(\\psi) \\Pi_{\\psi}^{\\otimes t} = \\binom{t+d-1}{d-1}^{-1}\\Pi_{sym}^{(t)}$$\n",
"\n",
"Where $\\Pi_{sym}^{(t)}$ is the projector onto the totally symmetric subspace of $(\\mathbb{C}^d)^{\\otimes t}$. As I said above, this follows from the fact that the left hand side is invariant under all unitaries $U^{\\otimes t}$ that act irriducibly on the totally symmetric subspace.\n",
"\n",
"Noting that $|\\langle \\psi | \\phi \\rangle|^{2t} = Tr[\\Pi_{\\psi}^{\\otimes t}\\Pi_{\\phi}^{\\otimes t}]$, we can define a complex projective t-design via:\n",
"\n",
"$$ \\frac{1}{n} \\sum_{i} (|\\psi_{i} \\rangle \\langle \\psi_{i}|)^{\\otimes t} = \\binom{t+d-1}{d-1}^{-1}\\Pi_{sym}^{(t)}$$\n",
"\n",
"It's worth noting that $t$-designs for $\\mathbb{C}P^{d-1}$ exist for any $t$ and $d$, but:\n",
"\n",
"$$ n \\ge \\binom{d + \\lceil\\frac{t}{2}\\rceil -1 }{ \\lceil \\frac{t}{2} \\rceil }\\binom{d + \\lfloor \\frac{t}{2} \\rfloor -1}{ \\lfloor \\frac{t}{2} \\rfloor}$$\n",
"\n",
"\"Tight designs\" achieve this bound. \n",
"\n",
"Here's some nice facts:\n",
"\n",
"Tight $t$-designs in $\\mathbb{C}P^{1}$ are equivalent to tight spherical $t$-designs on the Euclidian 2-sphere. Such designs exist for $t=1,2,3,5$. \n",
"\n",
"When $d \\ge 3$, tight t-designs for $\\mathbb{C}P^{d-1}$ only exist for $t=1,2,3$. \n",
"\n",
"Tight 1-designs exist in all dimensions. Tight 2-designs have been conjectured to exist for all $d$: this is the famous SIC existence queation.\n",
"\n",
"We could also have a weighted $t$-design, such that given weights $w_{i}$, we have:\n",
"\n",
"$$ \\sum_{i} w_{i} (|\\psi_{i} \\rangle \\langle \\psi_{i}|)^{\\otimes t} = \\binom{t+d-1}{d-1}^{-1}\\Pi_{sym}^{(t)}$$\n",
"\n",
"The unweighted case implictly had $w_{i} = \\frac{1}{n}$. \n",
"\n",
"It's also clear that a (weighted) t-design is also a weighted (t-1)-design: if we trace out a subsystem, we'll still get a projector onto the symmetric subspace.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Okay, so let's find some!"
]
},
{
"cell_type": "code",
"execution_count": 109,
"metadata": {},
"outputs": [],
"source": [
"import jax\n",
"import jax.numpy as jp\n",
"\n",
"@jax.jit\n",
"def real_to_complex(z): \n",
" return z[:len(z)//2] + 1j*z[len(z)//2:]\n",
"\n",
"@jax.jit\n",
"def complex_to_real(z):\n",
" return jp.concatenate((jp.real(z), jp.imag(z)))\n",
"\n",
"def complex_projective_design(d, n, t):\n",
" @jax.jit\n",
" def frame_potential(V):\n",
" R = real_to_complex(V).reshape(d, n)\n",
" return jp.sum(jp.array([jp.abs(jp.dot(jp.conjugate(a), b))**(2*t) for b in R.T for a in R.T]))\n",
" frame_potential_jac = jax.jit(jax.jacrev(frame_potential))\n",
" @jax.jit\n",
" def norm_constraint(V):\n",
" R = real_to_complex(V).reshape(d, n)\n",
" return jp.linalg.norm(jp.linalg.norm(R, axis=0) - jp.ones(n))**2\n",
" norm_jac = jax.jit(jax.jacrev(norm_constraint))\n",
" result = sc.optimize.minimize(frame_potential,\\\n",
" complex_to_real(np.random.randn(d*n)+1j*np.random.randn(d*n)),\\\n",
" jac=frame_potential_jac,\\\n",
" constraints=[{\"type\": \"eq\",\\\n",
" \"fun\": norm_constraint,\\\n",
" \"jac\": norm_jac},\n",
" ],\\\n",
" tol=1e-14,\\\n",
" options={\"ftol\": 1e-14,\\\n",
" \"disp\": True,\\\n",
" \"maxiter\": 5000},\\\n",
" method=\"SLSQP\")\n",
" return real_to_complex(result.x).reshape(d, n)"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Optimization terminated successfully. (Exit mode 0)\n",
" Current function value: 5.3333353996276855\n",
" Iterations: 247\n",
" Function evaluations: 1842\n",
" Gradient evaluations: 247\n"
]
}
],
"source": [
"d = 2\n",
"n = d**2\n",
"SIC = complex_projective_design(d, n, 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We should minimize the $t=2$ frame potential with $\\frac{2d^3}{d+1}$."
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {
"scrolled": true
},
"outputs": [
{
"data": {
"text/plain": [
"5.333333333333333"
]
},
"execution_count": 111,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2*(d**3)/(d+1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now let's check this business with the projector onto the symmetric subspace. We should have:\n",
"\n",
"$$ \\binom{t+d-1}{d-1}^{-1} = \\binom{d+1}{d-1}^{-1} = \\frac{(d-1)!(d+1 -d +1)}{(d+1)!} = \\frac{2}{d(d+1)}$$\n",
"\n",
"$$ \\frac{1}{d^2} \\sum_{i} \\Pi_{i} \\otimes \\Pi_{i} = \\frac{2}{d(d+1)}\\Pi_{sym}^{(2)}$$"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {},
"outputs": [],
"source": [
"from itertools import permutations, product\n",
"import functools\n",
"\n",
"def basis(d, n):\n",
" v = np.zeros(d)\n",
" v[n] = 1\n",
" return v\n",
"\n",
"def kron(elements):\n",
" return functools.reduce(lambda x, y: np.kron(x, y), elements)\n",
"\n",
"def flatten(to_flatten):\n",
" return [item for sublist in to_flatten for item in sublist]\n",
"\n",
"def symmetrize(pieces):\n",
" perms = list(permutations(range(len(pieces))))\n",
" vec = sum([kron([pieces[p] for p in perm]) for perm in perms])\n",
" return vec/np.linalg.norm(vec)\n",
"\n",
"def symmetric_projector(d, n):\n",
" d = [basis(d, i) for i in range(d)]\n",
" labels = list(filter(lambda b: sum(b) == n, list(product(range(n+1), repeat=len(d)))[::-1]))\n",
" sym_basis = [symmetrize(flatten([[d[i]]*b for i, b in enumerate(label)])) for label in labels]\n",
" return sum([np.outer(s, s.conj()) for s in sym_basis])"
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([1., 0., 1., 1.]),\n",
" array([[ 0. , 0. , 1. , 0. ],\n",
" [ 0.707107, 0.707107, 0. , 0. ],\n",
" [ 0.707107, -0.707107, 0. , 0. ],\n",
" [ 0. , 0. , 0. , 1. ]]))"
]
},
"execution_count": 113,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.linalg.eig(symmetric_projector(2,2))"
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.333333, 0. , 0. , 0. ],\n",
" [0. , 0.166667, 0.166667, 0. ],\n",
" [0. , 0.166667, 0.166667, 0. ],\n",
" [0. , 0. , 0. , 0.333333]])"
]
},
"execution_count": 114,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(2/(d*(d+1)))*symmetric_projector(2,2)"
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.333+0.j, 0. +0.j, 0. +0.j, -0. +0.j],\n",
" [ 0. -0.j, 0.167+0.j, 0.167+0.j, -0. +0.j],\n",
" [ 0. -0.j, 0.167+0.j, 0.167+0.j, -0. +0.j],\n",
" [-0. -0.j, -0. -0.j, -0. -0.j, 0.333+0.j]], dtype=complex64)"
]
},
"execution_count": 115,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.round((1/d**2)*sum([np.kron(np.outer(r, r.conj()), np.outer(r, r.conj())) for r in SIC.T]), decimals=3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"## Operator Frames\n",
"\n",
"Denoting the vectorized version of an operator $A$ by $|A)$, we have the Hilbert-Schmidt inner product $(A|B) = tr[A^{\\dagger}B]$. \n",
"\n",
"In what follows, we'll be considering \"superoperators\" aka linear maps on operators.\n",
"\n",
"Suppose we fix an orthonormal operator basis such that $(H_{i}|H_{j}) = \\delta_{ij}$. For $\\mathbb{C}^{d}$, this will have $d^2$ elements.\n",
"\n",
"We can then define a superoperator in two different ways:\n",
"\n",
"$$ \\mathcal{S} = \\sum_{i,j} s_{ij}H_{i} \\odot H_{j}^{\\dagger} = \\sum_{i,j} s_{ij}|H_{i})(H_{j}|, s_{ij} \\in \\mathbb{C} $$\n",
"\n",
"The first representation gives the \"ordinary action\" of the superoperator on an operator $A$:\n",
"\n",
"$$ \\mathcal{S}(A) = \\sum_{i,j} s_{ij}H_{i} A H_{j}^{\\dagger} $$\n",
"\n",
"The second representation gives the \"left-right action\" of the superoperator:\n",
"\n",
"$$ \\mathcal{S}|A) = \\sum_{i,j} s_{ij}|H_{i})(H_{j}|A) = \\sum_{i,j}s_{ij}H_{i}tr[H_{j}^{\\dagger}A] $$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In what follows, we'll make use of the identity superoperators:\n",
"\n",
"$$\\mathcal{I} = I_{d} \\odot I_{d} = |I_{d})(I_{d}|$$"
]
},
{
"cell_type": "code",
"execution_count": 116,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 0., 0., 1.],\n",
" [0., 0., 0., 0.],\n",
" [0., 0., 0., 0.],\n",
" [1., 0., 0., 1.]])"
]
},
"execution_count": 116,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.outer(np.eye(d).reshape(d**2), np.eye(d).reshape(d**2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"and\n",
"\n",
"$$\\textbf{I} = \\sum_{i} |H_{i})(H_{i}| = I_{n}$$"
]
},
{
"cell_type": "code",
"execution_count": 117,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 0., 0., 0.],\n",
" [0., 1., 0., 0.],\n",
" [0., 0., 1., 0.],\n",
" [0., 0., 0., 1.]])"
]
},
"execution_count": 117,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def operator_basis(d):\n",
" return [np.outer(basis(d, i), basis(d, j)) for j in range(d) for i in range(d)]\n",
"\n",
"H = operator_basis(d)\n",
"sum([np.outer(h.reshape(d**2), h.reshape(d**2).conj()) for h in H])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Incidentally, let's check that we have $(H_{i}|H_{j}) = \\delta_{ij}$:"
]
},
{
"cell_type": "code",
"execution_count": 118,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 0., 0., 0.],\n",
" [0., 1., 0., 0.],\n",
" [0., 0., 1., 0.],\n",
" [0., 0., 0., 1.]])"
]
},
"execution_count": 118,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.array([[(H[i].conj().T @ H[j]).trace() for j in range(d**2)] for i in range(d**2)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can extend the notion of a frame to that of an operator frame, in other words, a set of operators $\\{ E_{i} \\}$, such that for some $a$ and $b$, and for all $C$ in the operator space:\n",
"\n",
"$$ a(C|C) \\le \\sum_{i} |(E_{i}|C)|^2 \\le b(C|C)$$\n",
"\n",
"When $a=b$, we have a tight frame, and for an operator frame with $d^2$ elements, the frame is tight if and only if it is an orthonormal basis.\n",
"\n",
"For any operator frame, there is a dual frame $\\{ D_{i} \\}$, such that:\n",
"\n",
"$$ \\sum_{i} |D_{i})(E_{i}| = \\mathbf{I}$$\n",
"\n",
"Thus any $C$ can be written:\n",
"\n",
"$$ C = \\sum_{i} (E_{i}|C) D_{i} = \\sum_{i} (D_{i}|C) E_{i} $$\n",
"\n",
"When $n > d^2$, the dual frame isn't unique. The canonical choice is defined in terms of the frame superoperator:\n",
"\n",
"$$ F = \\sum_{i} |E_{i})(E_{i}| $$\n",
"\n",
"And is given by:\n",
"\n",
"$$ |D_{i}) = F^{-1}|E_{i}) $$\n",
"\n",
"So that:\n",
"\n",
"$$\\sum_{i} |D_{i})(E_{i}| = \\sum_{i} F^{-1}|E_{i})(E_{i}| = F^{-1}F = \\textbf{I}$$\n",
"\n",
"Since for a tight operator frame $F = a\\textbf{I}$, we have $|D_{i}) = \\frac{1}{a}|E_{i})$. This is one way of seeing that a tight operator frame can't be a POVM: POVM elements are positive semi-definite, but dual elements are generally indefinite--and they can't be proportional to each other."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"Okay, so let's try it out. We can get an operator frame from pretty much any old set of matrices: with probability one, they'll be linearly independent, and span the operator space. We'll then form the frame (super)operator $F$, its inverse $F^{-1}$, and get the canonical dual elements $\\{ D_{i} \\}$."
]
},
{
"cell_type": "code",
"execution_count": 119,
"metadata": {},
"outputs": [],
"source": [
"E = [np.random.randn(d,d)+1j*np.random.randn(d,d) for i in range(d**2)]\n",
"F = sum([np.outer(o.reshape(d**2), o.reshape(d**2).conj()) for o in E])\n",
"Finv = np.linalg.inv(F)\n",
"D = [(Finv @ e.reshape(d**2)).reshape(d,d) for e in E]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice:"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1+9.71445146547012e-17j)"
]
},
"execution_count": 120,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(E[0].conj().T @ D[0]).trace()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now let's get a density matrix $\\rho$ to play around with:"
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {},
"outputs": [],
"source": [
"def rand_dm(d, n=2):\n",
" A = np.random.randn(d, n) + 1j*np.random.randn(d, n) \n",
" rho = A @ A.conj().T\n",
" return rho/rho.trace()"
]
},
{
"cell_type": "code",
"execution_count": 122,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.74103 +0.j , 0.327131+0.000948j],\n",
" [0.327131-0.000948j, 0.25897 +0.j ]])"
]
},
"execution_count": 122,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rho = rand_dm(2); rho"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's expand it in operator frame elements:"
]
},
{
"cell_type": "code",
"execution_count": 124,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.719634-0.767312j, -0.784941+0.288272j, 0.685088+0.385522j,\n",
" 0.75119 -1.772347j])"
]
},
"execution_count": 124,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"p = np.array([(e.conj().T @ rho).trace() for e in E]); p"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And in dual elements:"
]
},
{
"cell_type": "code",
"execution_count": 125,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([-0.257759-0.021812j, 0.31128 +0.661881j, 0.234991+0.431962j,\n",
" 0.442281-0.221602j])"
]
},
"execution_count": 125,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"q = np.array([(e.conj().T @ rho).trace() for e in D]); q"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The former weight the dual elements:"
]
},
{
"cell_type": "code",
"execution_count": 127,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.74103 -0.j , 0.327131+0.000948j],\n",
" [0.327131-0.000948j, 0.25897 +0.j ]])"
]
},
"execution_count": 127,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([p[i]*D[i] for i in range(d**2)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And the latter weight the frame elements:"
]
},
{
"cell_type": "code",
"execution_count": 128,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.74103 -0.j , 0.327131+0.000948j],\n",
" [0.327131-0.000948j, 0.25897 -0.j ]])"
]
},
"execution_count": 128,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([q[i]*E[i] for i in range(d**2)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, let's check out $\\sum_{i} |D_{i})(E_{i}|$:"
]
},
{
"cell_type": "code",
"execution_count": 129,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1.+0.j, 0.-0.j, 0.-0.j, 0.-0.j],\n",
" [-0.-0.j, 1.-0.j, 0.+0.j, -0.+0.j],\n",
" [ 0.+0.j, 0.-0.j, 1.-0.j, 0.-0.j],\n",
" [ 0.+0.j, -0.-0.j, 0.-0.j, 1.+0.j]])"
]
},
"execution_count": 129,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([np.outer(D[i].reshape(d**2), E[i].reshape(d**2).conj()) for i in range(d**2)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"Here's a nice trick: given any old operator frame, we can tighten it via:\n",
"\n",
"$$ |E_{i}) \\rightarrow F^{-\\frac{1}{2}}|E_{i})$$"
]
},
{
"cell_type": "code",
"execution_count": 131,
"metadata": {},
"outputs": [],
"source": [
"Fsqrt = sc.linalg.fractional_matrix_power(F, -1/2)\n",
"T = [(Fsqrt @ e.reshape(d**2)).reshape(d,d) for e in E]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now $F = \\sum_{i} |E_{i})(E_{i}| = \\textbf{I}$:"
]
},
{
"cell_type": "code",
"execution_count": 132,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1.+0.j, 0.+0.j, -0.+0.j, -0.+0.j],\n",
" [ 0.-0.j, 1.+0.j, -0.-0.j, -0.-0.j],\n",
" [-0.-0.j, -0.+0.j, 1.+0.j, 0.+0.j],\n",
" [-0.-0.j, -0.+0.j, 0.-0.j, 1.+0.j]])"
]
},
"execution_count": 132,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"TF = sum([np.outer(e.reshape(d**2), e.reshape(d**2).conj()) for e in T]); TF"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's expand $\\rho$ in tight frame elements:"
]
},
{
"cell_type": "code",
"execution_count": 133,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.74103 +0.j , 0.327131+0.000948j],\n",
" [0.327131-0.000948j, 0.25897 +0.j ]])"
]
},
"execution_count": 133,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rho"
]
},
{
"cell_type": "code",
"execution_count": 134,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.079125-0.187423j, -0.098291+0.344842j, 0.231467+0.281337j,\n",
" 0.382004-0.61774j ])"
]
},
"execution_count": 134,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"p = np.array([(e.conj().T @ rho).trace() for e in T]); p"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And behold, the elements are the same as their duals:"
]
},
{
"cell_type": "code",
"execution_count": 135,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.74103 +0.j , 0.327131+0.000948j],\n",
" [0.327131-0.000948j, 0.25897 -0.j ]])"
]
},
"execution_count": 135,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([p[i]*T[i] for i in range(d**2)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, we have:\n",
"\n",
"$$ \\sum_{i,j} |(E_{i}|E_{j})|^2 \\ge \\frac{(Tr[F])^2}{d^2} $$\n",
"\n",
"With equality for a tight operator frame, by Cauchy-Schwartz considerations."
]
},
{
"cell_type": "code",
"execution_count": 136,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3.999999999999968"
]
},
"execution_count": 136,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([abs(np.vdot(T[i].reshape(d**2), T[j].reshape(d**2)))**2 for j in range(d**2) for i in range(d**2)])"
]
},
{
"cell_type": "code",
"execution_count": 137,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(3.999999999999969+0j)"
]
},
"execution_count": 137,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(TF.trace()**2)/d**2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"## (IC-)POVM's\n",
"\n",
"A few conventions are worth establishing. \n",
"\n",
"The POVM elements we'll denote $\\{ E_{i} \\}$. "
]
},
{
"cell_type": "code",
"execution_count": 139,
"metadata": {},
"outputs": [],
"source": [
"def random_haar_povm(d, k=None, n=2):\n",
" k = k if type(k) != type(None) else d**2\n",
" povm = np.zeros((k, d, d), dtype=np.complex128)\n",
" S = np.zeros(d, dtype=np.complex128)\n",
" for i in range(k):\n",
" Xi = (np.random.randn(d, n) + 1j*np.random.randn(d,n))/np.sqrt(2) \n",
" Wi = Xi @ Xi.conjugate().T\n",
" povm[i, :, :] = Wi\n",
" S = S + Wi\n",
" S = sc.linalg.fractional_matrix_power(S, -1/2)\n",
" for i in range(k):\n",
" Wi = np.squeeze(povm[i, :, :])\n",
" povm[i, :, :] = S @ Wi @ S\n",
" return [e for e in povm]"
]
},
{
"cell_type": "code",
"execution_count": 140,
"metadata": {},
"outputs": [],
"source": [
"E = random_haar_povm(d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We'll denote the normalized elements $P_{i} = \\frac{E_{i}}{Tr[E_{i}]}$."
]
},
{
"cell_type": "code",
"execution_count": 141,
"metadata": {},
"outputs": [],
"source": [
"P = [e/e.trace() for e in E]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Finally, we'll define the POVM superoperator:\n",
"\n",
"$$ F = \\sum_{i} tr[E_{i}]|P_{i})(P_{i}| $$"
]
},
{
"cell_type": "code",
"execution_count": 142,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([1. -0.j, 0.200444-0.j, 0.046406+0.j, 0.060062-0.j]),\n",
" array([[ 0.707107+0.j , 0.430302+0.033293j, -0.363281-0.310925j,\n",
" -0.080389-0.280396j],\n",
" [-0. +0.j , 0.560117+0.j , 0.080418+0.51467j ,\n",
" 0.64414 +0.j ],\n",
" [-0. -0.j , 0.553451+0.086159j, 0.520915+0.j ,\n",
" -0.546292+0.341293j],\n",
" [ 0.707107-0.j , -0.430302-0.033293j, 0.363281+0.310925j,\n",
" 0.080389+0.280396j]]))"
]
},
"execution_count": 142,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"F = sum([E[i].trace()*np.outer(P[i].reshape(d**2), P[i].reshape(d**2).conj()) for i in range(d**2)])\n",
"np.linalg.eig(F)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Note that the identity matrix is thus an eigenvector of $F$ with eigenvalue $1$:"
]
},
{
"cell_type": "code",
"execution_count": 143,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 1.+0.j, -0.+0.j, -0.-0.j, 1.-0.j])"
]
},
"execution_count": 143,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"F @ np.eye(d).reshape(d**2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In what follows, without loss of generality, we'll often be considering the case of equal weight POVM's. "
]
},
{
"cell_type": "code",
"execution_count": 144,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 1.+0.j, -0.-0.j],\n",
" [-0.+0.j, 1.+0.j]])"
]
},
"execution_count": 144,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Generates a random unit norm tight (vector) frame aka a rank-1 equal weight POVM.\n",
"def random_funtf(d, n, rtol=1e-15, atol=1e-15):\n",
" R = np.random.randn(d, n) + 1j*np.random.randn(d, n) \n",
" done = False\n",
" while not (np.allclose(R @ R.T.conj(), (n/d)*np.eye(d), rtol=rtol, atol=atol) and\\\n",
" np.allclose(np.linalg.norm(R, axis=0), np.ones(n), rtol=rtol, atol=atol)):\n",
" R = sc.linalg.polar(R)[0]\n",
" R = np.array([state/np.linalg.norm(state) for state in R.T]).T\n",
" return R\n",
"\n",
"E = [(d/n)*np.outer(r, r.conj()) for r in random_funtf(d, d**2).T]\n",
"P = [e/e.trace() for e in E]\n",
"sum(E)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"In this case:\n",
"\n",
"$$ F = \\frac{d}{n} \\sum_{i} |P_{i})(P_{i}| $$"
]
},
{
"cell_type": "code",
"execution_count": 145,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([1. -0.j, 0.670354-0.j, 0.194656-0.j, 0.13499 +0.j])"
]
},
"execution_count": 145,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.linalg.eig((d/n)*sum([np.outer(e.reshape(d**2), e.reshape(d**2).conj()) for e in P]))[0]\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here's some facts whose proofs we omit: \n",
"\n",
"A POVM superoperator is positive under the left/right action. It must have full rank to be informationally complete. $F$ and $F^{-1}$ map Hermitian to Hermitian operators, and elements and duals are Hermitian."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"## Tight IC-POVM's\n",
"\n",
"So POVM's can't be tight operator frames per se, but maybe we can still define something analogous. Thus, we come to tight IC-POVM's.\n",
"\n",
"First: we can embed the space of quantum states (density operators) into $\\mathbb{R}^{d^2-1}$. First we map each $\\rho$ to a traceless Hermitian operator:\n",
"\n",
"$$ \\rho \\rightarrow \\rho - \\frac{1}{d}I $$\n",
"\n",
"We have the Hilbert-Schmidt inner product $(A|B) = tr[A^{\\dagger}B]$, and the Frobenius norm $||A|| = \\sqrt{(A|A)}$. With this defined, the set of all traceless Hermitian operators forms a real inner product space. \n",
"\n",
"Pure states lie on the surface of a $(d^2-2)$-sphere $|| |\\psi \\rangle \\langle \\psi | - \\frac{1}{d}I || = \\sqrt{\\frac{d-1}{d}}$, and mixed states live inside the sphere."
]
},
{
"cell_type": "code",
"execution_count": 146,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.7071067811865475"
]
},
"execution_count": 146,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rho = rand_dm(2, n=1) # pure state\n",
"np.linalg.norm(rho - np.eye(d)/d)"
]
},
{
"cell_type": "code",
"execution_count": 147,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.7071067811865476"
]
},
"execution_count": 147,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.sqrt((d-1)/d) # radius"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"For $d=2$, this the familiar Bloch sphere representation: we embed $2 \\times 2$ operators on $\\mathbb{C}^{2}$ onto a ball in $\\mathbb{R}^3$, where pure states live on the surface of the 2-sphere. The higher dimensional generalizations are more difficult to visualize.\n",
"\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now consider the POVM superoperator of some arbitrary POVM. Recall we denote its normalized elements $P_{i}$. We have:\n",
"\n",
"$$ F = \\frac{1}{d}\\mathcal{I} + \\sum_{i}Tr[E_{i}]|P_{i} - \\frac{1}{d}I)(P_{i} - \\frac{1}{d}I| $$\n",
"\n",
"Where $\\mathcal{I} = \\frac{1}{d}|I)(I|$."
]
},
{
"cell_type": "code",
"execution_count": 148,
"metadata": {},
"outputs": [],
"source": [
"E = random_haar_povm(d, d**2)\n",
"P = [e/e.trace() for e in E]"
]
},
{
"cell_type": "code",
"execution_count": 150,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.535329-0.j , 0.002444-0.034646j, 0.002444+0.034646j,\n",
" 0.464671+0.j ],\n",
" [ 0.002444+0.034646j, 0.116376-0.j , -0.045241-0.050318j,\n",
" -0.002444-0.034646j],\n",
" [ 0.002444-0.034646j, -0.045241+0.050318j, 0.116376-0.j ,\n",
" -0.002444+0.034646j],\n",
" [ 0.464671-0.j , -0.002444+0.034646j, -0.002444-0.034646j,\n",
" 0.535329-0.j ]])"
]
},
"execution_count": 150,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"F = sum([E[i].trace()*np.outer(P[i].reshape(d**2), P[i].reshape(d**2).conj()) for i in range(d**2)]); F"
]
},
{
"cell_type": "code",
"execution_count": 151,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 0., 0., 1.],\n",
" [0., 0., 0., 0.],\n",
" [0., 0., 0., 0.],\n",
" [1., 0., 0., 1.]])"
]
},
"execution_count": 151,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ID = np.outer(np.eye(d).reshape(d**2), np.eye(d).reshape(d**2)); ID"
]
},
{
"cell_type": "code",
"execution_count": 152,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.535329-0.j , 0.002444-0.034646j, 0.002444+0.034646j,\n",
" 0.464671+0.j ],\n",
" [ 0.002444+0.034646j, 0.116376-0.j , -0.045241-0.050318j,\n",
" -0.002444-0.034646j],\n",
" [ 0.002444-0.034646j, -0.045241+0.050318j, 0.116376-0.j ,\n",
" -0.002444+0.034646j],\n",
" [ 0.464671+0.j , -0.002444+0.034646j, -0.002444-0.034646j,\n",
" 0.535329-0.j ]])"
]
},
"execution_count": 152,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ID/d + sum([E[i].trace()*np.outer((P[i] - np.eye(d)/d).reshape(d**2), (P[i] - np.eye(d)/d).reshape(d**2).conj()) for i in range(d**2)])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now $ \\frac{1}{d}\\mathcal{I} = \\frac{1}{d}|I)(I|$ left/right projects onto the subspace spanned by the identity:"
]
},
{
"cell_type": "code",
"execution_count": 153,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([1., 0., 0., 0.]),\n",
" array([[ 0.707107, -0.707107, 0. , 0. ],\n",
" [ 0. , 0. , 1. , 0. ],\n",
" [ 0. , 0. , 0. , 1. ],\n",
" [ 0.707107, 0.707107, 0. , 0. ]]))"
]
},
"execution_count": 153,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.linalg.eig(ID/d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Its orthogonal complement is the $(d^2 -1)$-dimensional subspace of traceless operators. So in terms of $\\mathbf{I}= I_{n}$, we define:\n",
"\n",
"$$ \\Pi_{0} = \\mathbf{I} - \\frac{1}{d}\\mathcal{I}$$\n",
"\n",
"This operator projects onto the subspace of traceless operators."
]
},
{
"cell_type": "code",
"execution_count": 154,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.5, 0. , 0. , -0.5],\n",
" [ 0. , 1. , 0. , 0. ],\n",
" [ 0. , 0. , 1. , 0. ],\n",
" [-0.5, 0. , 0. , 0.5]])"
]
},
"execution_count": 154,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"PI0 = np.eye(d**2) - ID/d; PI0"
]
},
{
"cell_type": "code",
"execution_count": 155,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(array([1., 0., 1., 1.]),\n",
" array([[ 0.707107, 0.707107, 0. , 0. ],\n",
" [ 0. , 0. , 1. , 0. ],\n",
" [ 0. , 0. , 0. , 1. ],\n",
" [-0.707107, 0.707107, 0. , 0. ]]))"
]
},
"execution_count": 155,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.linalg.eig(PI0)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Therefore, this operator realizes the embedding into the \"Bloch body\":\n",
"\n",
"$$ \\Pi_{0} | \\rho ) = |\\rho - \\frac{1}{d}I)$$"
]
},
{
"cell_type": "code",
"execution_count": 156,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.752401+0.j , -0.104281+0.165283j],\n",
" [-0.104281-0.165283j, 0.247599+0.j ]])"
]
},
"execution_count": 156,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rho = rand_dm(2); rho"
]
},
{
"cell_type": "code",
"execution_count": 157,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.252401+0.j , -0.104281+0.165283j, -0.104281-0.165283j,\n",
" -0.252401+0.j ])"
]
},
"execution_count": 157,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"PI0 @ rho.reshape(d**2)"
]
},
{
"cell_type": "code",
"execution_count": 158,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([ 0.252401+0.j , -0.104281+0.165283j, -0.104281-0.165283j,\n",
" -0.252401+0.j ])"
]
},
"execution_count": 158,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(rho - np.eye(d)/d).reshape(d**2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We denote $ \\textbf{I}_{0}$ the left/right identity superoperator for the space of traceless Hermitian operators.\n",
"\n",
"Okay, so now for the punch line:\n",
"\n",
"A tight IC-POVM is one for which the elements $P_{i}-\\frac{1}{d}I$ form a tight operator frame *for the space of traceless Hermitian operators*. I.e.:\n",
"\n",
"$$ \\sum_{i} Tr[E_{i}] |P_{i} - \\frac{1}{d}I)(P_{i} - \\frac{1}{d}I| = a\\textbf{I}_{0}$$\n",
"\n",
"Or: $\\Pi_{0}F\\Pi_{0} = a\\Pi_{0}$ for some $a > 0$.\n",
"\n",
"Anticipating somewhat, let's try it out on the SIC we found before:"
]
},
{
"cell_type": "code",
"execution_count": 160,
"metadata": {},
"outputs": [],
"source": [
"E = [(d/n)*np.outer(r, r.conj()) for r in SIC.T]\n",
"P = [e/e.trace() for e in E]\n",
"F = sum([E[i].trace()*np.outer(P[i].reshape(d**2), P[i].reshape(d**2).conj()) for i in range(d**2)])"
]
},
{
"cell_type": "code",
"execution_count": 164,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.167+0.j, 0. +0.j, 0. -0.j, -0.167+0.j],\n",
" [ 0. -0.j, 0.333+0.j, -0. +0.j, -0. +0.j],\n",
" [ 0. +0.j, -0. -0.j, 0.333+0.j, -0. -0.j],\n",
" [-0.167+0.j, -0. -0.j, -0. +0.j, 0.167+0.j]])"
]
},
"execution_count": 164,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.round(PI0 @ F @ PI0, decimals=3)"
]
},
{
"cell_type": "code",
"execution_count": 162,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.5, 0. , 0. , -0.5],\n",
" [ 0. , 1. , 0. , 0. ],\n",
" [ 0. , 0. , 1. , 0. ],\n",
" [-0.5, 0. , 0. , 0.5]])"
]
},
"execution_count": 162,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"PI0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Proportionality looks good so far (up to numerical error!)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So: tight IC-POVM's are those with elements whose images under $\\Pi_{0}$ form a tight operator frame for the space of traceless Hermitian matrices. As such, they are \"as close as possible\" to being orthonormal bases for the space of quantum states.\n",
"\n",
"We can find the constant of proportionality $a$:\n",
"\n",
"$$a = \\frac{1}{d^2 -1}\\sum_{i} Tr[E_{i}](P_{i} - \\frac{1}{d}I|P_{i} - \\frac{1}{d}I)$$"
]
},
{
"cell_type": "code",
"execution_count": 165,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(0.33333332506703606+0j)"
]
},
"execution_count": 165,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = (1/(d**2 - 1))*sum([E[i].trace()*np.vdot((P[i] - np.eye(d)/d).reshape(d**2), (P[i] - np.eye(d)/d).reshape(d**2)) for i in range(d**2)]);a"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Behold:"
]
},
{
"cell_type": "code",
"execution_count": 166,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.166667, 0. , 0. , -0.166667],\n",
" [ 0. , 0.333333, 0. , 0. ],\n",
" [ 0. , 0. , 0.333333, 0. ],\n",
" [-0.166667, 0. , 0. , 0.166667]])"
]
},
"execution_count": 166,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/3)*PI0"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Simplifying things, we have for a tight IC-POVM:\n",
"\n",
"$$ F = \\frac{1}{d}\\mathcal{I} + a\\Pi_{0} = a\\textbf{I} + \\frac{1-a}{ad}\\mathcal{I}$$\n",
"\n",
"Recall: $ \\mathcal{I} = |I)(I|$, and $\\textbf{I} = I_{n}$."
]
},
{
"cell_type": "code",
"execution_count": 167,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667+0.j, 0. +0.j, 0. +0.j, 0.333333+0.j],\n",
" [0. +0.j, 0.333333+0.j, 0. +0.j, 0. +0.j],\n",
" [0. +0.j, 0. +0.j, 0.333333+0.j, 0. +0.j],\n",
" [0.333333+0.j, 0. +0.j, 0. +0.j, 0.666667+0.j]])"
]
},
"execution_count": 167,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"ID/d + a*PI0"
]
},
{
"cell_type": "code",
"execution_count": 168,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.667+0.j, 0. -0.j, 0. +0.j, 0.333+0.j],\n",
" [ 0. +0.j, 0.333+0.j, -0. +0.j, -0. +0.j],\n",
" [ 0. -0.j, -0. -0.j, 0.333+0.j, -0. -0.j],\n",
" [ 0.333+0.j, -0. -0.j, -0. +0.j, 0.666+0.j]], dtype=complex64)"
]
},
"execution_count": 168,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.round(F, decimals=3)"
]
},
{
"cell_type": "code",
"execution_count": 169,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667+0.j, 0. +0.j, 0. +0.j, 0.333333+0.j],\n",
" [0. +0.j, 0.333333+0.j, 0. +0.j, 0. +0.j],\n",
" [0. +0.j, 0. +0.j, 0.333333+0.j, 0. +0.j],\n",
" [0.333333+0.j, 0. +0.j, 0. +0.j, 0.666667+0.j]])"
]
},
"execution_count": 169,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a*np.eye(d**2) + ((1-a)/d)*ID"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Similarly, we have:\n",
"\n",
"$$ F^{-1} = \\frac{1}{a}\\textbf{I} - \\frac{1-a}{ad}\\mathcal{I} $$."
]
},
{
"cell_type": "code",
"execution_count": 170,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 2. +0.j , -0. +0.j , -0. -0.j , -1.001+0.j ],\n",
" [-0. -0.j , 2.999+0.j , 0.002-0.002j, 0. -0.001j],\n",
" [-0. +0.j , 0.002+0.002j, 2.999+0.j , 0. +0.001j],\n",
" [-1.001-0.j , 0. +0.001j, 0. -0.001j, 2.001+0.j ]],\n",
" dtype=complex64)"
]
},
"execution_count": 170,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Finv = np.linalg.inv(F); np.round(Finv, decimals=3)"
]
},
{
"cell_type": "code",
"execution_count": 172,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 2.+0.j, 0.+0.j, 0.+0.j, -1.+0.j],\n",
" [ 0.+0.j, 3.+0.j, 0.+0.j, 0.+0.j],\n",
" [ 0.+0.j, 0.+0.j, 3.+0.j, 0.+0.j],\n",
" [-1.+0.j, 0.+0.j, 0.+0.j, 2.+0.j]])"
]
},
"execution_count": 172,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.eye(d**2)/a - ((1-a)/(a*d))*ID"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And for the dual elements:\n",
"\n",
"$$ D_{i} = \\frac{1}{a}P_{i} - \\frac{1-a}{ad}I $$"
]
},
{
"cell_type": "code",
"execution_count": 173,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.478568+0.j , -1.109467+1.009989j],\n",
" [-1.109467-1.009989j, 0.520477+0.j ]], dtype=complex64)"
]
},
"execution_count": 173,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"D = [(Finv @ e.reshape(d**2)).reshape(d,d) for e in P]; D[0]"
]
},
{
"cell_type": "code",
"execution_count": 174,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.47899 +0.j , -1.108152+1.010721j],\n",
" [-1.108152-1.010721j, 0.52101 +0.j ]])"
]
},
"execution_count": 174,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"D2 = [e/a - ((1-a)/(a*d))*np.eye(d) for e in P]; D2[0]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And we can express some $\\rho$ as:\n",
"\n",
"$$\\rho = \\frac{1}{a}\\sum_{i} p_{i}P_{i} - \\frac{1-a}{ad}I$$"
]
},
{
"cell_type": "code",
"execution_count": 178,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([0.342437, 0.341537, 0.149521, 0.166767])"
]
},
"execution_count": 178,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"p = np.array([(e.conj().T @ rho).trace() for e in E]).real; p"
]
},
{
"cell_type": "code",
"execution_count": 179,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.752401+0.j , -0.104281+0.165283j],\n",
" [-0.104281-0.165283j, 0.247599+0.j ]])"
]
},
"execution_count": 179,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rho"
]
},
{
"cell_type": "code",
"execution_count": 180,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.752979+0.j , -0.104117+0.165952j],\n",
" [-0.104117-0.165952j, 0.247807+0.j ]])"
]
},
"execution_count": 180,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/a)*sum([p[i]*P[i] for i in range(d**2)]) - ((1-a)/(a*d))*np.eye(d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Simplifying even further, in the case of a tight *rank-one* IC-POVM, we have:\n",
"\n",
"$$ a = \\frac{1}{d+1} $$"
]
},
{
"cell_type": "code",
"execution_count": 181,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.3333333333333333"
]
},
"execution_count": 181,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1/(d+1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So that:\n",
"\n",
"$$F = \\frac{\\textbf{I}+\\mathcal{I}}{d+1}$$"
]
},
{
"cell_type": "code",
"execution_count": 182,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667, 0. , 0. , 0.333333],\n",
" [0. , 0.333333, 0. , 0. ],\n",
" [0. , 0. , 0.333333, 0. ],\n",
" [0.333333, 0. , 0. , 0.666667]])"
]
},
"execution_count": 182,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(np.eye(d**2) + ID)/(d+1)"
]
},
{
"cell_type": "code",
"execution_count": 183,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.667+0.j, 0. -0.j, 0. +0.j, 0.333+0.j],\n",
" [ 0. +0.j, 0.333+0.j, -0. +0.j, -0. +0.j],\n",
" [ 0. -0.j, -0. -0.j, 0.333+0.j, -0. -0.j],\n",
" [ 0.333+0.j, -0. -0.j, -0. +0.j, 0.666+0.j]], dtype=complex64)"
]
},
"execution_count": 183,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.round(F, decimals=3)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And:\n",
"\n",
"$$ \\rho = (d+1)\\sum_{i} p_{i}|\\psi_{i}\\rangle\\langle\\psi_{i}| - I $$"
]
},
{
"cell_type": "code",
"execution_count": 186,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.752979+0.j , -0.104117+0.165952j],\n",
" [-0.104117-0.165952j, 0.247807+0.j ]])"
]
},
"execution_count": 186,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(d+1)*sum([p[i]*P[i] for i in range(d**2)]) - np.eye(d)"
]
},
{
"cell_type": "code",
"execution_count": 187,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.752401+0.j , -0.104281+0.165283j],\n",
" [-0.104281-0.165283j, 0.247599+0.j ]])"
]
},
"execution_count": 187,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rho"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"We can rewrite $F = \\sum_{i} Tr[E_{i}]|P_{i})(P_{i}| = \\frac{1}{d+1} (\\textbf{I} + \\mathcal{I})$ in terms of the ordinary superoperator action as:\n",
"\n",
"$$ \\sum_{i} Tr[E_{i}]\\Pi_{i} \\odot \\Pi_{i} = \\frac{1}{d+1}(\\sum_{i} H_{i} \\odot H_{i}^{\\dagger} + I \\odot I) $$\n",
"\n",
"Where the $H_{i}$'s are some orthonormal operator basis."
]
},
{
"cell_type": "code",
"execution_count": 188,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.584326+0.j , -0.034706+0.055317j],\n",
" [-0.034706-0.055317j, 0.415936-0.j ]])"
]
},
"execution_count": 188,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([E[i].trace()*P[i] @ rho @ P[i] for i in range(d**2)])"
]
},
{
"cell_type": "code",
"execution_count": 189,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.584134+0.j , -0.03476 +0.055094j],\n",
" [-0.03476 -0.055094j, 0.415866+0.j ]])"
]
},
"execution_count": 189,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"H = operator_basis(d)\n",
"(1/(d+1))*(sum([ H[i] @ rho @ H[i].conj().T for i in range(d**2)]) + np.eye(d) @ rho @ np.eye(d))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"And then in terms of the left/right action:\n",
"\n",
"$$ \\sum_{i} Tr[E_{i}]\\Pi_{i} \\otimes \\Pi_{i} = \\frac{1}{d+1}(\\sum_{i} H_{i} \\otimes H_{i}^{\\dagger} + I \\otimes I) $$"
]
},
{
"cell_type": "code",
"execution_count": 192,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[ 0.667+0.j, 0. +0.j, 0. +0.j, -0. +0.j],\n",
" [ 0. -0.j, 0.333+0.j, 0.333+0.j, -0. +0.j],\n",
" [ 0. -0.j, 0.333+0.j, 0.333+0.j, -0. +0.j],\n",
" [-0. -0.j, -0. -0.j, -0. -0.j, 0.666+0.j]], dtype=complex64)"
]
},
"execution_count": 192,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.round(sum([E[i].trace()*np.kron(P[i], P[i]) for i in range(d**2)]), decimals=3)"
]
},
{
"cell_type": "code",
"execution_count": 191,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667, 0. , 0. , 0. ],\n",
" [0. , 0.333333, 0.333333, 0. ],\n",
" [0. , 0.333333, 0.333333, 0. ],\n",
" [0. , 0. , 0. , 0.666667]])"
]
},
"execution_count": 191,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/(d+1))*(sum([np.kron(H[i], H[i].conj().T) for i in range(d**2)]) + np.kron(np.eye(d), np.eye(d)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Using the fact that for any orthonormal basis, we can write:\n",
"\n",
"$$ \\sum_{i} E_{i} \\otimes E_{i}^{\\dagger} = T = \\sum_{i,j} |e_{i}\\rangle\\langle e_{j}| \\otimes |e_{j}\\rangle\\langle e_{i}|$$\n",
"\n",
"Where $|e_{i}\\rangle$ is some orthonormal basis, and $T$ is a swap operator, we have:\n",
"\n",
"$$ \\sum_{i} Tr[E_{i}]\\Pi_{i} \\otimes \\Pi_{i} = \\frac{1}{d+1}(T + I \\otimes I) = \\frac{2}{d+1}\\Pi_{sym}^{(2)}$$\n"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1., 0., 0., 0.],\n",
" [0., 0., 1., 0.],\n",
" [0., 1., 0., 0.],\n",
" [0., 0., 0., 1.]])"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"T = sum([np.kron(np.outer(basis(d, i), basis(d, j)), np.outer(basis(d, j), basis(d, i))) for j in range(d) for i in range(d)]); T"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667, 0. , 0. , 0. ],\n",
" [0. , 0.333333, 0.333333, 0. ],\n",
" [0. , 0.333333, 0.333333, 0. ],\n",
" [0. , 0. , 0. , 0.666667]])"
]
},
"execution_count": 79,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/(d+1))*(T + np.kron(np.eye(d), np.eye(d)))"
]
},
{
"cell_type": "code",
"execution_count": 198,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667, 0. , 0. , 0. ],\n",
" [0. , 0.333333, 0.333333, 0. ],\n",
" [0. , 0.333333, 0.333333, 0. ],\n",
" [0. , 0. , 0. , 0.666667]])"
]
},
"execution_count": 198,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(2/(d+1))*symmetric_projector(d, d)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So we've shown that a tight IC-POVM is a 2-design.\n",
"\n",
"And indeed, the unique minimal tight rank-one IC-POVM in each dimension has $d^2$ elements and corresponds to a SIC.\n",
"\n",
"$$ (\\Pi_{i}|\\Pi_{j}) = |\\langle \\psi_{i} | \\psi_{j} \\rangle|^2 = \\frac{d \\delta_{ij} + 1}{d+1}$$\n",
"\n",
"Embedded in $\\mathbb{R}^{d^2 -1}$ the elements of a SIC correspond to the vertices of a regular simplex:\n",
"\n",
"$$ \\frac{d}{d-1}(\\Pi_{i} - \\frac{1}{d}I | \\Pi_{j} - \\frac{1}{d}I) = \\frac{d^2 \\delta_{ij} - 1}{d^2 -1 }$$\n",
"\n",
"But not all simplices are POVM's. (The factor of $\\frac{d}{d-1}$ is due to embedding into a sphere of radius $\\sqrt{\\frac{d-1}{d}}$).\n",
"\n",
"A uniform POVM has weights $\\frac{d}{n}$, and equiangular when $(\\Pi_{i}|\\Pi_{j}) = c$, and SIC POVM's are uniquely picked out by these criteria.\n",
"\n",
"
\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Another example of a tight rank-one IC-POVM is a complete set of so-called mutually unbiased bases (MUB's): a set of $d+1$ othonormal bases for $\\mathbb{C}^d$ with constant overlap $\\frac{1}{d}$ between elements of different bases.\n",
"\n",
"$$\\begin{equation}\n",
"(\\Pi(e_{i}^{l}) | \\Pi(e_{j}^{m})) = \\left\\{\n",
" \\begin{array}{@{}ll@{}}\n",
" \\delta_{ij}, & \\text{if}\\ l=m \\\\\n",
" \\frac{1}{d}, & \\text{otherwise}\n",
" \\end{array}\\right.\n",
"\\end{equation}$$\n",
"\n",
"We should weight with $\\frac{d}{n} = \\frac{d}{d(d+1)} = \\frac{1}{d+1}$.\n",
"\n",
"For example, we can get one via the Pauli eigenstates:\n",
"\n",
"$$\\mathscr{B}_{Z} = \\{ \\begin{pmatrix} 1 \\\\ 0 \\end{pmatrix}, \\begin{pmatrix} 0 \\\\ 1 \\end{pmatrix} \\}, \\mathscr{B}_{Y} = \\{ \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ i \\end{pmatrix}, \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ -i \\end{pmatrix} \\}, \\mathscr{B}_{X} = \\{ \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ 1 \\end{pmatrix}, \\frac{1}{\\sqrt{2}}\\begin{pmatrix} 1 \\\\ -1 \\end{pmatrix} \\}$$\n"
]
},
{
"cell_type": "code",
"execution_count": 194,
"metadata": {},
"outputs": [],
"source": [
"X = [np.array([1,1])/np.sqrt(2), np.array([1,-1])/np.sqrt(2)]\n",
"Y = [np.array([1,1j])/np.sqrt(2), np.array([1,-1j])/np.sqrt(2)]\n",
"Z = [np.array([1,0]), np.array([0,1])]\n",
"\n",
"MUB = [np.outer(x, x.conj()) for x in X] + [np.outer(y, y.conj()) for y in Y] + [np.outer(z, z.conj()) for z in Z]"
]
},
{
"cell_type": "code",
"execution_count": 195,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[1. , 0. , 0.5, 0.5, 0.5, 0.5],\n",
" [0. , 1. , 0.5, 0.5, 0.5, 0.5],\n",
" [0.5, 0.5, 1. , 0. , 0.5, 0.5],\n",
" [0.5, 0.5, 0. , 1. , 0.5, 0.5],\n",
" [0.5, 0.5, 0.5, 0.5, 1. , 0. ],\n",
" [0.5, 0.5, 0.5, 0.5, 0. , 1. ]])"
]
},
"execution_count": 195,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"np.array([[(a.conj().T @ b).trace() for b in MUB] for a in MUB]).real"
]
},
{
"cell_type": "code",
"execution_count": 199,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667+0.j, 0. +0.j, 0. +0.j, 0. +0.j],\n",
" [0. +0.j, 0.333333+0.j, 0.333333+0.j, 0. +0.j],\n",
" [0. +0.j, 0.333333+0.j, 0.333333+0.j, 0. +0.j],\n",
" [0. +0.j, 0. +0.j, 0. +0.j, 0.666667+0.j]])"
]
},
"execution_count": 199,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(1/(d+1))*sum([np.kron(e, e) for e in MUB])"
]
},
{
"cell_type": "code",
"execution_count": 201,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"array([[0.666667+0.j, 0. +0.j, 0. +0.j, 0.333333+0.j],\n",
" [0. +0.j, 0.333333+0.j, 0. +0.j, 0. +0.j],\n",
" [0. +0.j, 0. +0.j, 0.333333+0.j, 0. +0.j],\n",
" [0.333333+0.j, 0. +0.j, 0. +0.j, 0.666667+0.j]])"
]
},
"execution_count": 201,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"F_MUB = (1/(d+1))*sum([np.outer(e.reshape(d**2), e.reshape(d**2).conj()) for e in MUB]); F_MUB"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"Finally, we have for an arbitrary POVM:\n",
"\n",
"$$ \\sum_{i,j} Tr[E_{i}]Tr[E_{j}] |(P_{i}|P_{j})|^2 \\ge 1 + \\frac{(Tr[F]-1)^2}{d^2 -1 }$$\n",
"\n",
"With equality if we have a tight IC-POVM."
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1.333333446217599+0j)"
]
},
"execution_count": 85,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([E[i].trace()*E[j].trace()*abs(np.vdot(P[i].reshape(d**2), P[j].reshape(d**2)))**2 for j in range(d**2) for i in range(d**2)])"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1.3333332538604783+0j)"
]
},
"execution_count": 86,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 + ((F.trace() - 1)**2)/(d**2 -1)"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1.3333333333333328+0j)"
]
},
"execution_count": 87,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1 + ((F_MUB.trace() - 1)**2)/(d**2 -1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"A POVM is rank-one if and only if $Tr[F] = d$."
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(1.9999999+0j)"
]
},
"execution_count": 88,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"F.trace()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So we can finagle this into:\n",
"\n",
"$$ \\sum_{i,j} Tr[E_{i}]Tr[E_{j}]|(P_{i}|P_{j})|^2 \\ge \\frac{2d}{d+1}$$\n",
"\n",
"With equality if F is a tight IC-POVM."
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.3333333333333333"
]
},
"execution_count": 89,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2*d/(d+1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Optimal Tomography\n",
"\n",
"Suppose we take $N$ random samples $s_{1}, \\dots s_{N}$ (i.e. perform our POVM $N$ times), and that outcome $i$ occurs with some \"unknown probability\" $p(i)$. Given the samples, our estimate for the probability could be written:\n",
"\n",
"$$ \\hat{p}(i) = \\hat{p}(i; s_{1}, \\dots s_{N}) = \\frac{1}{N} \\sum_{k=1}^{N} \\delta_{i, s_{k}}$$\n",
"\n",
"So that the expectation $E[\\hat{p}(i)] = p(i)$. \n",
"\n",
"Meanwhile, after some algebra, the expected covariance for $N$ samples can be written:\n",
"\n",
"$$ E[(p(i) - \\hat{p}(i))(p(j) - \\hat{p}(j))] = \\frac{1}{N}[p(i)\\delta_{i,j} - p(i)p(j)]$$\n",
"\n",
"Given the samples, our estimate for $\\rho$ is:\n",
"\n",
"$$ \\hat{\\rho} = \\sum_{i} \\frac{1}{Tr[E_{i}]}\\hat{p}(i)D_{i} $$\n",
"\n",
"The error of the estimate is:\n",
"\n",
"$$ ||\\rho - \\hat{\\rho}||^2 = (\\rho - \\hat{\\rho}|\\rho - \\hat{\\rho}) = \\sum_{i,j} \\frac{1}{Tr[E_{i}]Tr[E_{j}]}(p(i) - \\hat{p}(i))(p(j) - \\hat{p}(j))(D_{i}|D_{j})$$\n",
"\n",
"The expectation of the error:\n",
"\n",
"$$ E[||\\rho - \\hat{\\rho}||^2 ] = \\frac{1}{N} \\sum_{i,j} \\frac{1}{Tr[E_{i}]Tr[E_{j}]} (p(i)\\delta_{i,j} - p(i)p(j))(D_{i}|D_{j}) = \\frac{1}{N} (\\sum_{i} \\frac{1}{Tr[E_{i}]^2} p(i)(D_{i}|D_{i}) - Tr[\\rho^2])$$\n",
"\n",
"We therefore want to minimize $\\sum_{i} \\frac{1}{Tr[E_{i}]^2}p(i)(D_{i}|D_{i})$.\n",
"\n",
"The POVM which minimizes this quantity, however, will generally depend on the paticular quantum state. So we want to average over states. We'll set $\\rho = U\\sigma U^{\\dagger}$, and take the Haar average of $U = U(d)$, recalling that we have $p(i) = Tr[E_{i}\\rho]$.\n",
"\n",
"\n",
"$$ \\int_{U(d)} d\\mu_{U} (\\sum_{i} \\frac{1}{Tr[E_{i}]^2}Tr[E_{i}U\\sigma U^{\\dagger}](D_{i}|D_{i}) $$\n",
"\n",
"This works out to be:\n",
"\n",
"$$ \\frac{1}{d} (\\sum_{i} \\frac{1}{Tr[E_{i}]^2} Tr[E_{i}] Tr[\\sigma](D_{i}|D_{i}) $$\n",
"\n",
"But we know $Tr[\\sigma] = 1$, and so:\n",
"\n",
"$$ \\frac{1}{d} \\sum_{i} \\frac{1}{Tr[E_{i}]} (D_{i}|D_{i}) $$\n",
"\n",
"And if it isn't clear:\n",
"\n",
"$$ Tr[F^{-1}] = \\sum_{i} \\frac{1}{Tr[E_{i}]} (D_{i}|D_{i}) $$\n",
"\n",
"So we want to minimize $Tr[F^{-1}]$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"
\n",
"\n",
"Now we've been supposing that $\\{ D_{i} \\}$ is the canonical dual frame. Suppose it weren't, and instead we used some other dual: $\\{ B_{i} \\}$. \n",
"\n",
"Omitting the normalization, we can show that:\n",
"\n",
"$\\sum_{i} (D_{i}|D_{i}) \\le \\sum_{i} (B_{i}|B_{i}) $ \n",
"\n",
"Defining $C = B - D$, we have:\n",
"\n",
"$$ \\sum_{i} |D_{i})(C_{i}| = \\sum_{i}|D_{i})(B_{i}| - \\sum_{i} |D_{i})(D_{i}| = \\sum_{i} F^{-1}|E_{i})(B_{i}| - \\sum_{i} F^{-1}|E_{i})(E_{i}|F^{-1}$$\n",
"\n",
"Which amounts to:\n",
"\n",
"$$ F^{-1}\\textbf{I} - F^{-1}FF^{-1} = 0$$\n",
"\n",
"This means that $\\sum_{i} (C_{i}|D_{i}) = 0$, so:\n",
"\n",
"$$ \\sum_{i} (B_{i}|B_{i}) = \\sum_{i} (D_{i}|D_{i}) + \\sum_{i} (D_{i}|C_{i}) + \\sum_{i}(C_{i}|D_{i}) + \\sum_{i}(C_{i}|C_{i}) $$\n",
"\n",
"$$ = \\sum_{i} (D_{i}|D_{i}) + \\sum_{i}(C_{i}|C_{i}) $$\n",
"\n",
"So that $\\sum_{i} (D_{i}|D_{i}) \\le \\sum_{i} (B_{i}|B_{i}) $.\n",
"\n",
"Thus it suffices to minimize $ \\sum_{i} \\frac{1}{Tr[E_{i}]}(D_{i}|D_{i}) = Tr[F^{-1}]$.\n",
"\n",
"It turns out:\n",
"\n",
"$$ Tr[F^{-1}] \\ge d(d(d+1) -1)$$\n",
"\n",
"With equality for a tight rank-one IC-POVM.\n",
"\n",
"We have $Tr[F^{-1}] = \\sum_{k=1}^{d^2} \\frac{1}{\\lambda_{k}}$, where the $\\lambda_{k}$'s are the left/right eigenvalues of $F$.\n",
"\n",
"Now:\n",
"\n",
"$$ Tr[F] = \\sum_{k=1}^{d^2} \\lambda_{k} = \\sum_{i} Tr[E_{i}](P_{i}|P_{i}) \\leq d$$\n",
"\n",
"Since $Tr[P^2] \\leq 1$.\n",
"\n",
"But we know that the identity operator is a left/right eigenvector of $F$ with eigenvalue 1. So:\n",
"\n",
"$$\\sum_{k=2}^{d^2} \\lambda_{k} \\leq d-1$$\n",
"\n",
"Working the numbers, we'll get a minimum if and only if the other $\\lambda_{k}$'s are:\n",
"\n",
"$\\lambda_{k} = \\frac{d-1}{d^2 -1} = \\frac{1}{d+1}$, so that:\n",
"\n",
"$$ F = 1 \\cdot \\frac{1}{d}\\mathcal{I} + \\frac{1}{d+1}\\cdot\\Pi_{0} = \\frac{\\textbf{I} + \\mathcal{I}}{d+1}$$.\n",
"\n",
"So $Tr[F^{-1}]$ takes its minimum if and only if $F$ corresponds to a tight rank-one IC-POVM, and the minimum is $ 1 \\cdot 1 + (d+1)\\cdot(d^2 -1) = d(d(d+1) -1)$."
]
},
{
"cell_type": "code",
"execution_count": 202,
"metadata": {},
"outputs": [],
"source": [
"E = [(d/n)*np.outer(r, r.conj()) for r in SIC.T]\n",
"P = [e/e.trace() for e in E]\n",
"F = (d/n)*sum([np.outer(e.reshape(d**2), e.reshape(d**2).conj()) for e in P])\n",
"Finv = np.linalg.inv(F)\n",
"D = [(Finv @ e.reshape(d**2)).reshape(d,d) for e in E]"
]
},
{
"cell_type": "code",
"execution_count": 203,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(10.0000105-8.272215e-23j)"
]
},
"execution_count": 203,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"Finv.trace()"
]
},
{
"cell_type": "code",
"execution_count": 204,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"10"
]
},
"execution_count": 204,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"d*(d*(d+1)-1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"So we've shown that it's optimal to use tight rank-one IC-POVM's for (linear) quantum state tomography. (For more discussion of the assumptions here, check out the paper!)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Bibliography\n",
"\n",
"Symmetric Informationally Complete Quantum Measurements\n",
"\n",
"Tight informationally complete quantum measurements\n",
"\n",
"Spherical (t,t)-designs with a small number of vectors"
]
}
],
"metadata": {
"kernelspec": {
"display_name": "VPython",
"language": "python",
"name": "vpython"
},
"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.8.5"
}
},
"nbformat": 4,
"nbformat_minor": 4
}