{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# QOSF screening challenge\n",
"https://www.qosf.org/"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"2020-09-10"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"by [Kunal Marwaha](https://kunalmarwaha.com/about)"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"Task 2\n",
"Implement a circuit that returns |01> and |10> with equal probability.\n",
"Requirements :\n",
"The circuit should consist only of CNOTs, RXs and RYs. \n",
"Start from all parameters in parametric gates being equal to 0 or randomly chosen. \n",
"You should find the right set of parameters using gradient descent (you can use more advanced optimization methods if you like). \n",
"Simulations must be done with sampling - i.e. a limited number of measurements per iteration and noise. \n",
"\n",
"Compare the results for different numbers of measurements: 1, 10, 100, 1000. \n",
"\n",
"Bonus question:\n",
"How to make sure you produce state |01> + |10> and not |01> - |10> ?"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Getting started"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is my first time using qiskit, but I'll give it a go."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I know how to turn $|00\\rangle$ into an equal combination of $|01\\rangle$ and $|10\\rangle$, but it uses a Hadamard gate."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [],
"source": [
"from qiskit import *\n",
"from qiskit.visualization import plot_histogram\n",
"import matplotlib.pyplot as plt"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
" ┌───┐┌───┐ \n",
"q_0: ┤ X ├┤ H ├──■──\n",
" ├───┤└───┘┌─┴─┐\n",
"q_1: ┤ X ├─────┤ X ├\n",
" └───┘ └───┘ "
],
"text/plain": [
" ┌───┐┌───┐ \n",
"q_0: ┤ X ├┤ H ├──■──\n",
" ├───┤└───┘┌─┴─┐\n",
"q_1: ┤ X ├─────┤ X ├\n",
" └───┘ └───┘"
]
},
"execution_count": 2,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc_with_h = QuantumCircuit(2)\n",
"qc_with_h.x(0)\n",
"qc_with_h.x(1)\n",
"qc_with_h.h(0)\n",
"qc_with_h.cx(0, 1)\n",
"qc_with_h.draw()"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"name": "stderr",
"output_type": "stream",
"text": [
"/home/kunal/anaconda3/lib/python3.7/site-packages/matplotlib/transforms.py:796: ComplexWarning: Casting complex values to real discards the imaginary part\n",
" points = np.array(args, dtype=float).reshape(2, 2)\n"
]
},
{
"data": {
"text/plain": [
"Text(0.5, 1.0, 'Probability weights in state vector')"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
},
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"metadata": {
"needs_background": "light"
},
"output_type": "display_data"
}
],
"source": [
"backend = Aer.get_backend('statevector_simulator')\n",
"final_state = execute(qc_with_h,backend).result().get_statevector()\n",
"plt.bar(['00', '01', '10', '11'], final_state.conj()*final_state)\n",
"plt.title(\"Probability weights in state vector\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I can show this with qiskit's sampling tools."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
" ┌───┐┌───┐ ┌─┐ \n",
"q_0: ┤ X ├┤ H ├──■──┤M├───\n",
" ├───┤└───┘┌─┴─┐└╥┘┌─┐\n",
"q_1: ┤ X ├─────┤ X ├─╫─┤M├\n",
" └───┘ └───┘ ║ └╥┘\n",
"c: 2/════════════════╩══╩═\n",
" 0 1 "
],
"text/plain": [
" ┌───┐┌───┐ ┌─┐ \n",
"q_0: ┤ X ├┤ H ├──■──┤M├───\n",
" ├───┤└───┘┌─┴─┐└╥┘┌─┐\n",
"q_1: ┤ X ├─────┤ X ├─╫─┤M├\n",
" └───┘ └───┘ ║ └╥┘\n",
"c: 2/════════════════╩══╩═\n",
" 0 1 "
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc_with_h_measured = QuantumCircuit(2, 2)\n",
"qc_with_h_measured.x(0)\n",
"qc_with_h_measured.x(1)\n",
"qc_with_h_measured.h(0)\n",
"qc_with_h_measured.cx(0, 1)\n",
"qc_with_h_measured.measure([0, 1], [0, 1])\n",
"qc_with_h_measured.draw()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"backend = BasicAer.get_backend('qasm_simulator')\n",
"counts = execute(qc_with_h_measured, backend, shots=100).result().get_counts()\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This is sampling between two values with 50% chance each. This is like a scaled binomial distribution (with mean $1/2$ and standard deviation $1/(2\\sqrt{N})$. By Chebyshev's inequality, the chance of three standard deviations above mean is at most 1/9 (and even smaller if I consider the distribution approximately normal). With good probability I expect the two values to be within $3/(\\sqrt{N})$ of each other. For example, with $N=100$, I only expect values within $0.35-0.65$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Avoiding the Hadamard"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"One way I can remove the Hadamard is by inserting $R_x$ and $R_y$ gates in its place. Since the spirit of the problem seems to be \"optimize for these parameters\", I will insert an $R_y$ and $R_x$ in place of the Hadamard. (I also replace the $X$ gates for $R_x$ gates.) Then I allow all gates except CNOT to take any parameter."
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [],
"source": [
"import numpy as np\n",
"from numpy import pi"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [],
"source": [
"def gen_circuit(thetas):\n",
" qc = QuantumCircuit(2, 2)\n",
" qc.rx(thetas[0], 0)\n",
" qc.rx(thetas[1], 1)\n",
" qc.ry(thetas[2], 0)\n",
" qc.rx(thetas[3], 0)\n",
" qc.cx(0, 1)\n",
" qc.measure([0, 1], [0, 1])\n",
" return qc"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here's a random example."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
" ┌────────────┐┌────────────┐┌────────────┐ ┌─┐ \n",
"q_0: ┤ RX(2.4479) ├┤ RY(1.7707) ├┤ RX(3.2658) ├──■──┤M├───\n",
" ├────────────┤└────────────┘└────────────┘┌─┴─┐└╥┘┌─┐\n",
"q_1: ┤ RX(3.8473) ├────────────────────────────┤ X ├─╫─┤M├\n",
" └────────────┘ └───┘ ║ └╥┘\n",
"c: 2/════════════════════════════════════════════════╩══╩═\n",
" 0 1 "
],
"text/plain": [
" ┌────────────┐┌────────────┐┌────────────┐ ┌─┐ \n",
"q_0: ┤ RX(2.4479) ├┤ RY(1.7707) ├┤ RX(3.2658) ├──■──┤M├───\n",
" ├────────────┤└────────────┘└────────────┘┌─┴─┐└╥┘┌─┐\n",
"q_1: ┤ RX(3.8473) ├────────────────────────────┤ X ├─╫─┤M├\n",
" └────────────┘ └───┘ ║ └╥┘\n",
"c: 2/════════════════════════════════════════════════╩══╩═\n",
" 0 1 "
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"rands = np.random.random(4)*2*pi\n",
"qc_rand = gen_circuit(rands)\n",
"qc_rand.draw()"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [],
"source": [
"def get_counts(qc, shots):\n",
" backend = BasicAer.get_backend('qasm_simulator')\n",
" return execute(qc, backend, shots=shots).result().get_counts()"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"shots = 1000\n",
"counts = get_counts(qc_rand, shots)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Optimizing over parameters"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I define a loss function by seeing how much the probabilities differ from expected (50% each for $|01\\rangle$ and $|10\\rangle$):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$$\n",
"L = (prob_10 - 0.5)^2 + (prob_01 - 0.5)^2\n",
"$$"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [],
"source": [
"def loss_from_counts(counts, shots):\n",
" prob_01 = counts.get('01', 0)/shots\n",
" prob_10 = counts.get('10', 0)/shots\n",
" return (prob_10 - 0.5)**2 + (prob_01 - 0.5)**2"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.009140000000000006"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"loss_from_counts(counts, shots)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Now I try to find the best parameters!"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [],
"source": [
"def input_to_loss(inputs, shots):\n",
" qc = gen_circuit(inputs)\n",
" counts = get_counts(qc, shots)\n",
" return loss_from_counts(counts, shots)"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [],
"source": [
"from scipy.optimize import minimize"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" direc: array([[ 1. , 0. , 0. , 0. ],\n",
" [ 0. , 0. , 0. , 1. ],\n",
" [ 0. , 0. , 1. , 0. ],\n",
" [-0.08315777, 0.09256503, -0.00465645, -0.00135926]])\n",
" fun: array(0.0017)\n",
" message: 'Optimization terminated successfully.'\n",
" nfev: 168\n",
" nit: 2\n",
" status: 0\n",
" success: True\n",
" x: array([2.59751634, 2.99042514, 4.76234905, 3.09845965])"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"shots = 1000\n",
"res = minimize(input_to_loss, np.random.rand(4)*2*pi, method='Powell', args=(shots,))\n",
"res"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Best input: [2.59751634 2.99042514 4.76234905 3.09845965]\n",
"Loss: 0.0016999999999999995\n"
]
}
],
"source": [
"print(\"Best input:\", res.x)\n",
"print(\"Loss:\", input_to_loss(res.x, shots))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"This result is not bad. I plot the circuit probabilities when measuring 1, 10, 100, 1000 times."
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [],
"source": [
"qc = gen_circuit(res.x)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 18,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"counts = get_counts(qc, 1)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"counts = get_counts(qc, 10)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"counts = get_counts(qc, 100)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"counts = get_counts(qc, 1000)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Analysis"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Because I initialize from random inputs, the final circuit seems to change on each run. This probably means I have a whole class of solutions. I could probably re-run this with fewer parameters and find a simpler result."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I'm not discouraged by the plots for very few number of measurements. I expect the distributions to vary widely (at least between $|01\\rangle$ and $|10\\rangle$)."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"There were this many evaluations: 168\n",
"That corresponds to this many total experiments: 168000\n"
]
}
],
"source": [
"print(\"There were this many evaluations:\", res.nfev)\n",
"print(\"That corresponds to this many total experiments:\", res.nfev*shots)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"I worked out analytically that a simple $[\\pi, \\pi, \\pi/2, 0]$ should work just fine, since $\\sqrt{Y}$ behaves close to a Hadamard.\n",
"But there may be other inputs that are also optimal."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"The optimization algorithm will work much better with higher amounts of measurements per iteration, because the loss will be noisy (on the order of $0.5/\\sqrt{N}$ as discussed before. For example, even the optimal result has a nonzero loss."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.0013520000000000025"
]
},
"execution_count": 23,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"input_to_loss([pi, pi, pi/2, 0], shots)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Bonus"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"To produce $|01\\rangle + |10\\rangle$ instead of $|01\\rangle - |10\\rangle$, I could also penalize the phase difference. But I don't have access to a state vector. I could instead measure in the Bell basis and optimize for $|\\Psi^+\\rangle \\propto |01\\rangle + |10\\rangle$."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"If I don't have access to a Bell basis, I could apply a $CNOT$ then $R_y(\\pi/2)\\otimes I$ to look for the result in the standard basis (at $|01\\rangle$). I penalize any probability weight that is not in $|01\\rangle$."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [],
"source": [
"def gen_bonus_circuit(thetas):\n",
" qc = QuantumCircuit(2, 2)\n",
" qc.rx(thetas[0], 0)\n",
" qc.rx(thetas[1], 1)\n",
" qc.ry(thetas[2], 0)\n",
" qc.rx(thetas[3], 0)\n",
" # the CNOTs cancel each other!\n",
"# qc.cx(0, 1)\n",
"# qc.cx(0, 1) \n",
" qc.ry(pi/2, 0)\n",
" qc.measure([0, 1], [0, 1])\n",
" return qc"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Here's an example."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [],
"source": [
"c = gen_bonus_circuit([pi, pi, pi/2, 0])"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/html": [
" ┌────────┐┌──────────┐┌───────┐┌──────────┐┌─┐\n",
"q_0: ┤ RX(pi) ├┤ RY(pi/2) ├┤ RX(0) ├┤ RY(pi/2) ├┤M├\n",
" ├────────┤└───┬─┬────┘└───────┘└──────────┘└╥┘\n",
"q_1: ┤ RX(pi) ├────┤M├───────────────────────────╫─\n",
" └────────┘ └╥┘ ║ \n",
"c: 2/═══════════════╩════════════════════════════╩═\n",
" 1 0 "
],
"text/plain": [
" ┌────────┐┌──────────┐┌───────┐┌──────────┐┌─┐\n",
"q_0: ┤ RX(pi) ├┤ RY(pi/2) ├┤ RX(0) ├┤ RY(pi/2) ├┤M├\n",
" ├────────┤└───┬─┬────┘└───────┘└──────────┘└╥┘\n",
"q_1: ┤ RX(pi) ├────┤M├───────────────────────────╫─\n",
" └────────┘ └╥┘ ║ \n",
"c: 2/═══════════════╩════════════════════════════╩═\n",
" 1 0 "
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"c.draw()"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"{'10': 100}"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"get_counts(c, 100)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Notice that the \"optimal\" result from before does produce the state we are looking for!"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [],
"source": [
"def input_to_bonus_loss(inputs, shots):\n",
" qc = gen_bonus_circuit(inputs)\n",
" counts = get_counts(qc, shots)\n",
" # something I learned: qiskit orders its qubits upside-down from the picture!\n",
" return 1 - counts.get('10', 0)/shots"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.0"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"input_to_bonus_loss([pi, pi, pi/2, 0], 100)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"But we can \"simulate\" this process:"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
" direc: array([[ 0.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n",
" 1.00000000e+00],\n",
" [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00,\n",
" 0.00000000e+00],\n",
" [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00,\n",
" 0.00000000e+00],\n",
" [ 1.50640275e-04, 1.78873203e-05, -1.05366640e-05,\n",
" 1.00562098e-03]])\n",
" fun: array(0.)\n",
" message: 'Optimization terminated successfully.'\n",
" nfev: 193\n",
" nit: 3\n",
" status: 0\n",
" success: True\n",
" x: array([ 3.09980025, 3.13055976, 1.57828926, 13.3309928 ])"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"shots = 1000\n",
"res = minimize(input_to_bonus_loss, np.random.rand(4)*2*pi, method='Powell', args=(shots,))\n",
"res"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Best input: [ 3.09980025 3.13055976 1.57828926 13.3309928 ]\n",
"Loss: 0.0023120000000000003\n"
]
}
],
"source": [
"print(\"Best input:\", res.x)\n",
"print(\"Loss:\", input_to_loss(res.x, shots))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Let's confirm this still gives us equal probability in $|01\\rangle$ and $|10\\rangle$."
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"data": {
"image/png": "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\n",
"text/plain": [
""
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"qc = gen_circuit(res.x)\n",
"counts = get_counts(qc, 1000)\n",
"plot_histogram(counts)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## And that's a wrap!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Thanks for reading. This was an interesting project for me! I enjoyed trying out a quantum circuit library, and I am thankful for all of it being open-source."
]
}
],
"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.7.4"
}
},
"nbformat": 4,
"nbformat_minor": 4
}