{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "## Project 4: Amplitude damping\n", "\n", "In Chapter 7, we introduced the Jaynes-Cummings model. In this project, we will simulate it along with the Markovianity of the dynamics depending on the coupling strength.\n", "\n", "You can find the circuit decomposition for the amplitude damping below." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [], "source": [ "from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit\n", "import numpy as np" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "

" ], "image/svg+xml": "\n\n\n\n", "image/png": "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\n" }, "metadata": {}, "execution_count": 2 } ], "source": [ "###########################################\n", "# Amplitude damping channel on IBMQ_VIGO #\n", "###########################################\n", "\n", "# Quantum register\n", "q = QuantumRegister(5, name='q')\n", "\n", "# Quantum circuit\n", "ad = QuantumCircuit(q)\n", "\n", "# Amplitude damping channel acting on system qubit\n", "## Qubit identification\n", "system = 1\n", "environment = 2\n", "\n", "# Define rotation angle\n", "theta = 0.0\n", "\n", "# Construct circuit\n", "ad.x(q[system])\n", "# Notice the extra factor 2 due to how qiskit defines the unitary angles\n", "ad.cu(theta, 0.0, 0.0, 0.0, q[system], q[environment])\n", "ad.cx(q[environment], q[system])\n", "\n", "# Draw circuit\n", "ad.draw(output='mpl')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Recall that, in the above circuit, $\\theta = \\arccos{c_1(t)}$ with\n", "\\begin{equation}\n", "c_{1}(t)=e^{-\\lambda t/2}\\left[\\cosh\\left(\\frac{\\lambda t}{2}\\sqrt{1-2R}\\right)+\\frac{1}{\\sqrt{1-2R}}\\sinh\\left(\\frac{\\lambda t}{2}\\sqrt{1-2R}\\right)\\right].\n", "\\end{equation}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 1\n", "\n", "Write a function that returns $c_1(t)$. The function should admit an extra parameter $R$ and return the correct value for $R > 1/2$ and $R < 1/2$.\n", "\n", "Here is the suggested structure:" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "def c1(R,t):\n", " \"\"\"Returns the coherence factor in the amplitude damping channel\n", " \n", " Args:\n", " R (float): value of R = \\gamma_0/\\lambda\n", " t (float): value of the time variable\n", " \n", " Returns:\n", " A float number\n", " \"\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 2\n", "\n", "Write a function that returns the amplitude damping channel given the values of $R$ and $t$. You can choose to include the initial state of the system ($|1\\rangle$) into the function or to initialize its state elsewhere later.\n", "\n", "The suggested structure is" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "def amplitude_damping_channel(q, c, sys, env, R, t):\n", " \"\"\"Returns a QuantumCircuit implementing the amplitude damping channel on the system qubit\n", " \n", " Args:\n", " q (QuantumRegister): the register to use for the circuit\n", " c (ClassicalRegister): the register to use for the measurement of the system qubit\n", " sys (int): index for the system qubit\n", " env (int): index for the environment qubit\n", " R (float): value of R = \\gamma_0/\\lambda\n", " t (float): value of the time variable\n", " \n", " Returns:\n", " A QuantumCircuit object\n", " \"\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 3\n", "\n", "Choose some (at least 2) values of $R$. There should be values above and below $1/2$. For each value, simulate the amplitude damping channel at several values of $t$ and measure the probability for the atom to be in the excited state ($|1\\rangle$)." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 4\n", "\n", "We now turn our attention towards the Markovianity of the dynamics. To that end, we will simulate the channel introducing the non-Markovianity witness (you can find the circuit below). " ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "output_type": "execute_result", "data": { "text/plain": [ "

" ], "image/svg+xml": "\n\n\n", "image/png": "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\n" }, "metadata": {}, "execution_count": 4 } ], "source": [ "#######################################\n", "# Amplitude damping channel #\n", "# with non-M. witness on IBMQ_VIGO #\n", "#######################################\n", "\n", "# Quantum and classical register\n", "q = QuantumRegister(5, name='q')\n", "c = ClassicalRegister(2, name='c')\n", "\n", "# Quantum circuit\n", "ad = QuantumCircuit(q, c)\n", "\n", "# Amplitude damping channel acting on system qubit\n", "# with non-Markovianity witness\n", "## Qubit identification\n", "system = 1\n", "environment = 2\n", "ancilla = 3\n", "\n", "# Define rotation angle\n", "theta = 0.0\n", "\n", "# Construct circuit\n", "## Bell state between system and ancilla\n", "ad.h(q[system])\n", "ad.cx(q[system], q[ancilla])\n", "\n", "## Channel acting on system qubit\n", "ad.cu3(theta, 0.0, 0.0, q[system], q[environment])\n", "ad.cx(q[environment], q[system])\n", "\n", "## Local measurement for the witness\n", "### Choose observable\n", "observable = 'YY'\n", "### Change to the corresponding basis\n", "if observable == 'XX':\n", " ad.h(q[system])\n", " ad.h(q[ancilla])\n", "elif observable == 'YY':\n", " ad.sdg(q[system])\n", " ad.h(q[system])\n", " ad.sdg(q[ancilla])\n", " ad.h(q[ancilla])\n", "### Measure\n", "ad.measure(q[system], c[0])\n", "ad.measure(q[ancilla], c[1])\n", "\n", "# Draw circuit\n", "ad.draw(output='mpl')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "The witness is given by the probability of measuring the system and the ancilla in state $| \\phi^{+} \\rangle \\langle \\phi^{+} | = (\\mathbb{I}\\otimes \\mathbb{I} + \\sigma_{x}\\otimes \\sigma_{x} - \\sigma_{y}\\otimes \\sigma_{y} + \\sigma_{z}\\otimes \\sigma_{z})/4$, and the above circuit allows for the measurement of the corresponding observables.\n", "\n", "Write a function returning, for a given witness observable, $R$ and $t$, the corresponding circuit.\n", "\n", "Suggested structure below." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [], "source": [ "def amplitude_damping_channel_witness(q, c, sys, env, anc, observable, R, t):\n", " \"\"\"Returns a QuantumCircuit implementing the amplitude damping channel on the system qubit with non-Markovianity witness\n", " \n", " Args:\n", " q (QuantumRegister): the register to use for the circuit\n", " c (ClassicalRegister): the register to use for the measurement of the system and ancilla qubits\n", " sys (int): index for the system qubit\n", " env (int): index for the environment qubit\n", " anc (int): index for the ancillary qubit\n", " observable (str): the observable to be measured. Possible values \"XX\", \"YY\", \"ZZ\"\n", " R (float): value of R = \\gamma_0/\\lambda\n", " t (float): value of the time variable\n", " \n", " Returns:\n", " A QuantumCircuit object\n", " \"\"\"" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Task 5\n", "\n", "Simulate the dynamics with the witness for the same values of $R$ and $t$ as in Task 3. To do so, run the circuits for the three observables, $\\sigma_{x}\\otimes \\sigma_{x}$, $\\sigma_{y}\\otimes \\sigma_{y}$, and $\\sigma_{z}\\otimes \\sigma_{z}$ and compute their expected values. This allows to compute the value of the witness as $1 + \\left\\langle \\sigma_{x}\\otimes \\sigma_{x} \\right\\rangle - \\left\\langle\\sigma_{y}\\otimes \\sigma_{y} \\right\\rangle + \\left\\langle\\sigma_{z}\\otimes \\sigma_{z} \\right\\rangle)/4$. Plot the results as a function of $t$." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Homework\n", "\n", "Run the circuits on the IBM Q Experience with noise mitigation and plot the results." ] } ], "metadata": { "kernelspec": { "name": "python3", "display_name": "Python 3.8.5 64-bit ('base': conda)" }, "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": 2 }