diff --git a/examples/images/tomography-qpt-pauli.png b/examples/images/tomography-qpt-pauli.png new file mode 100644 index 0000000..d05579f Binary files /dev/null and b/examples/images/tomography-qpt-pauli.png differ diff --git a/examples/images/tomography-qpt.png b/examples/images/tomography-qpt.png new file mode 100644 index 0000000..83e32a9 Binary files /dev/null and b/examples/images/tomography-qpt.png differ diff --git a/examples/tomography-process-tomo-pls.ipynb b/examples/tomography-process-tomo-pls.ipynb new file mode 100644 index 0000000..6560aa5 --- /dev/null +++ b/examples/tomography-process-tomo-pls.ipynb @@ -0,0 +1,1427 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "76287416", + "metadata": {}, + "source": [ + "# Projected Least-Squares Quantum Process Tomography\n", + "\n", + "*Tutorial by*: Shahnawaz Ahmed\n", + "Email: shahnawaz.ahmed95gmail.com \n", + "GitHub: quantshah\n", + "\n", + "*Original implementation*: [Hyperplane Intersection Projection](https://github.com/Hannoskaj/Hyperplane_Intersection_Projection) by Trystan Surawy-Stepney, Jonas Kahn, \n", + "Richard Kueng and Madalin Guta ([arXiv:2107.01060](https://arxiv.org/abs/2107.01060)).\n", + "\n", + "In this notebook, we will demonstrate 4-qubit quantum process tomography (QPT)\n", + "using the projected least squares (PLS) method developed in [1]. We will use\n", + "the direct QPT method where the input states are Pauli eigenvectors with Pauli\n", + "measurements. The process chosen is the quantum fourier transform (QPT) represented\n", + "using a single Kraus operator and then converted to the Choi form.\n", + "\n", + "\"qpt\"\n", + "\n", + "Fig 2 from [[1](https://arxiv.org/abs/2107.01060)] showing the idea of projected\n", + "least squares process tomography.\n", + "\n", + "The main idea is to first find the least squares estimator for the Choi matrix \n", + "representing the process and then project it to a physical CPTP map. The projection\n", + "method in the paper is the [Hyperplane Intersection Projection](https://github.com/Hannoskaj/Hyperplane_Intersection_Projection) which was refactored into this\n", + "notebook for a simple demonstration.\n", + "\n", + "We will generate the data from a sampling of the true probabilities for various\n", + "input states and measurements on which the quantum channel C is applied.\n", + "\n", + "\"qpt\"\n", + "\n", + "Fig 4 from [[1](https://arxiv.org/abs/2107.01060)] direct QPT\n", + "\n", + "The channel is the quantum fourier transform for a $k$ qubit circuit.\n", + "\n", + "\n", + "Note:\n", + "----\n", + "The code is refactored from the repository [Hyperplane Intersection Projection](https://github.com/Hannoskaj/Hyperplane_Intersection_Projection)\n", + "commited by Jonas Kahn for the paper [arXiv:2107.01060](https://arxiv.org/abs/2107.01060).\n", + "\n", + "References\n", + "----------\n", + "\n", + "[1] Surawy-Stepney, T., Kahn, J., Kueng, R., & Guta, M. (2021). Projected Least-Squares Quantum Process Tomography. [arXiv:2107.01060](https://arxiv.org/abs/2107.01060).\n" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "926a5eaf", + "metadata": {}, + "outputs": [], + "source": [ + "# imports\n", + "\n", + "import numpy as np\n", + "\n", + "import scipy as sp\n", + "from scipy import stats\n", + "\n", + "\n", + "from qutip import Qobj, fidelity\n", + "from qutip.superop_reps import kraus_to_choi\n", + "\n", + "\n", + "from matplotlib import pyplot as plt\n", + "import matplotlib.colors as colors" + ] + }, + { + "cell_type": "markdown", + "id": "f190fa4a", + "metadata": {}, + "source": [ + "## The quantum fourier transform gate" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "119745a2", + "metadata": {}, + "outputs": [], + "source": [ + "def qft_kraus(k):\n", + " \"\"\"\n", + " Outputs the channel of the quantum Fourier transform for dimension $k$.\n", + "\n", + " Args:\n", + " k (int): The number of qubits.\n", + "\n", + " Returns:\n", + " kraus (np.array): The Kraus operator for the QFT unitary.\n", + " \"\"\"\n", + " mult = np.outer(np.arange(k), np.arange(k))\n", + " kraus = np.array([np.exp(2j * np.pi * mult / k)]) / np.sqrt(k)\n", + " return kraus\n", + "\n", + "\n", + "k = 3\n", + "kraus_true = qft_kraus(2**k)" + ] + }, + { + "cell_type": "markdown", + "id": "8c23fc14", + "metadata": {}, + "source": [ + "# The Choi matrix from the Kraus operator\n", + "\n", + "We can construct the Choi matrix from the Kraus operators (using QuTiP) or \n", + "by writing the conversion." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "56d445ae", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Is CPTP: False\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "def choi(kraus_ops):\n", + " \"\"\"Takes the rank-r Kraus reprensentation of a channel\n", + " and returns the Choi matrix of the channel.\n", + "\n", + " Args:\n", + " kraus_ops (np.ndarray): The (r, d, d)-array representing r Kraus ops\n", + "\n", + " Returns:\n", + " np.array: A (d^2, d^2) array representing the Choi matrix for the channel\n", + " \"\"\"\n", + " r, d, d = kraus_ops.shape\n", + " vectorized_kraus = kraus_ops.reshape(r, d ** 2)\n", + " return np.einsum(\"ij, il -> jl\", vectorized_kraus, vectorized_kraus.conj())\n", + "\n", + "\n", + "def plot_choi(choi, title=\"\", y=0.95, norm=None, cbar=False):\n", + " \"\"\"Plot the real and imaginary parts of the Choi matrix.\n", + "\n", + " Args:\n", + " choi (np.array): The Choi matrix for the process\n", + " title (str, optional): The title for the plot.\n", + " norm (colors.TwoSlopeNorm, optional): The normalization for the colorbar.\n", + " cbar (bool): Whether to plot a colorbar.\n", + " \"\"\"\n", + " fig, ax = plt.subplots(1, 2, sharex=True, sharey=True)\n", + " cmap = \"RdBu\"\n", + "\n", + " if norm is None:\n", + " norm = colors.TwoSlopeNorm(vmin=-np.max(np.abs(choi)),\n", + " vcenter=0,\n", + " vmax=np.max(np.abs(choi)))\n", + "\n", + " im = ax[0].matshow(choi.real, cmap=cmap, norm=norm)\n", + " im2 = ax[1].matshow(choi.imag, cmap=cmap, norm=norm)\n", + "\n", + " if cbar is True:\n", + " cbar_ax = plt.colorbar(im, ax=[ax[0], ax[1]], fraction=0.021, pad=0.04)\n", + "\n", + " ax[0].set_xlabel(\"Re\")\n", + " ax[1].set_xlabel(\"Im\")\n", + "\n", + " ax[0].set_xticks([0, int(choi.shape[0]/2), choi.shape[0]])\n", + " ax[0].set_yticks([0, int(choi.shape[0]/2), choi.shape[0]])\n", + "\n", + " ax[0].set_xticks([0, int(choi.shape[0]/2), choi.shape[0]])\n", + " ax[0].set_yticks([0, int(choi.shape[0]/2), choi.shape[0]])\n", + "\n", + " plt.suptitle(title, y=y)\n", + "\n", + "\n", + "choi_true = choi(kraus_true)/2**k\n", + "choi_qutip = kraus_to_choi([Qobj(kraus_true[0])])/2**k\n", + "\n", + "\n", + "# Plot the Choi matrix\n", + "plot_choi(choi_true, title=\"Choi (true) \\nCP {} Tr {}\".format(choi_qutip.iscp, choi_qutip.tr()), cbar = True)\n", + "\n", + "# Test our implementation of the Choi matrix conversion using QuTiP\n", + "np.testing.assert_array_almost_equal(choi_qutip.data.toarray(), choi_true)\n", + "print(\"Is CPTP:\", choi_qutip.iscptp)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "53995149", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(216, 216)\n" + ] + } + ], + "source": [ + "def prod_pauli_vecs(k, U2=None):\n", + " \"\"\"Outputs all the k-tensor products of Pauli vectors, as an array where the\n", + " vectors are the lines.\n", + "\n", + " Note:\n", + " This implementation works till k=8. It needs $12^k$ complex entries.\n", + " U2 allows to add a rotation to the Pauli vectors to avoid very special cases.\n", + "\n", + " TODO: There could be faster and more general way to do this.\n", + "\n", + " Args:\n", + " k (int): The number of qubits.\n", + " U2 (np.array, optional): A unitary of dimension 2**k. Defaults to None.\n", + "\n", + " Returns:\n", + " [type]: [description]\n", + " \"\"\"\n", + " s2 = np.sqrt(0.5)\n", + " frame_vecs = np.array(\n", + " ([1, 0], [0, 1], [s2, s2], [s2, -s2], [s2, s2 * 1j], [s2, -s2 * 1j])\n", + " )\n", + " if U2 is not None:\n", + " frame_vecs = np.dot(frame_vecs, U2)\n", + " einstein_indices = (\n", + " \"ai -> ai\",\n", + " \"ai, bj -> abij\",\n", + " \"ai, bj, ck -> abcijk\",\n", + " \"ai, bj, ck, dl -> abcdijkl\",\n", + " \"ai, bj, ck, dl, em -> abcdeijklm\",\n", + " \"ai, bj, ck, dl, em, fn -> abcdefijklmn\",\n", + " \"ai, bj, ck, dl, em, fn, go -> abcdefgijklmno\",\n", + " \"ai, bj, ck, dl, em, fn, go, hp -> abcdefghijklmnop\",\n", + " )\n", + " return np.einsum(einstein_indices[k - 1], *([frame_vecs] * k)).reshape(6 ** k, -1)\n", + "\n", + "\n", + "def probas_pauli(k, channel, optimize=\"optimal\"):\n", + " \"\"\"Yields the probability of each Pauli measurement result for direct\n", + " measurement method.\n", + " \n", + " For a given Pauli input state and measurement basis, sums to\n", + " one. Hence total sum is $18^k$.\n", + "\n", + " Input: k is the number of qubits,\n", + " channel are the Kraus operators of the channel.\n", + " Output array $(6^k, 6^k)$. First coordinate input state, second \n", + " coordinate measured output.\n", + "\n", + " Args:\n", + " k (int): Number of qubits\n", + " channel (np.ndarray): The channel represented by an (r, d, d) dim array\n", + " optimize (str, optional): Einsum optimization strategy.\n", + " Defaults to \"optimal\".\n", + "\n", + " Returns:\n", + " res (np.ndarray): The probabilities for all combinations of Pauli input\n", + " states and measurements as a (6**k, 6**k) matrix.\n", + " \"\"\"\n", + " res = 0\n", + " Pk = prod_pauli_vecs(k)\n", + " # Looping over kraus instead of doing everything in the einsum to\n", + " # avoid excessive memory usage if the rank is high.\n", + " for kraus in channel:\n", + " a = np.einsum(\"nj, ij, mi -> nm\", Pk, kraus, Pk.conj(), optimize=\"optimal\")\n", + " res += a.real ** 2 + a.imag ** 2\n", + " return res\n", + "\n", + "\n", + "probas = probas_pauli(k, kraus_true)\n", + "print(probas.shape)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "18d7e9b1", + "metadata": {}, + "outputs": [], + "source": [ + "def M_k(k):\n", + " \"\"\"Yields least-square estimators components for the input (or the output)\n", + " state.\n", + "\n", + " Args:\n", + " k (int): The number of qubits.\n", + "\n", + " Returns:\n", + " mkmat (np.ndarray) : A (6^k, 2^k, 2^k) matrix. The first index\n", + " represents the index of the input state. The rest\n", + " of the indices represent the corresponding matrix.\n", + " \"\"\"\n", + " P1 = prod_pauli_vecs(1)\n", + " # ALERT (original comment by Jonas Kahn)\n", + " #\n", + " # Here I do not understand the position of the conj(). I would have thought\n", + " # it is on the other P1.\n", + " # But it is this way that yields the right result.\n", + " M_1 = np.einsum(\"nd, ne -> nde\", 3 * P1, P1.conj()) - np.eye(2)\n", + " mkmat = np.copy(M_1)\n", + "\n", + " for i in range(2, k + 1):\n", + " mkmat = np.einsum(\"nde, mfg -> nmdfeg\", mkmat, M_1)\n", + " mkmat = mkmat.reshape(6 ** i, 2 ** i, 2 ** i)\n", + " return mkmat" + ] + }, + { + "cell_type": "markdown", + "id": "71703440", + "metadata": {}, + "source": [ + "# Generate the data for QPT\n", + "\n", + "There are 4 qubits and we consider state preparations for tensor products of \n", + "(+X, -X, +Y, -Y, +Z, -Z) on each qubit. The total number of such combinations\n", + "are give by $6^k$, e.g., (XXYX, -Z-ZYZ, ... ). Therefore in our data, the first\n", + "dimension is of size $6^k$ (1296).\n", + "Once these states are prepared, we measure the result again in all combinations\n", + "of the tensor products of the basis operators (+X, -X, +Y, -Y, +Z, -Z). Therefore\n", + "we have for each state preparation $6^k$ different measurements. \n", + "The final data is therefore a $6^k$, $6^k$ matrix for all state preparations and\n", + "measurements. \n", + "\n", + "Once we have all the probabilities for different state preparations and\n", + "measurements, we can simulate a sampling of the expectation values using a\n", + "Poissionian distribution by specifying the number of samples which determines\n", + "the number of cycles." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "e3586bef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Num shots for each measurement: 17146.776406035664\n", + "Data shape: (216, 216)\n" + ] + } + ], + "source": [ + "def sampling(probabilities, cycles=1):\n", + " \"\"\"Sampling of outcomes according to a Poisson distribution with parameter\n", + " $probabilities \\times cycles$, and normalization.\n", + "\n", + " Args:\n", + " probabilities (np.ndarray): An array of probabilities.\n", + " cycles (int, optional): The number of cycles in the experiment.\n", + "\n", + " Returns:\n", + " samples (np.ndarray): The samples (normalized).\n", + " \"\"\"\n", + " samples = stats.poisson.rvs(probabilities * cycles)\n", + " samples = samples * (probabilities.sum() / samples.sum())\n", + " return samples\n", + "\n", + "\n", + "num_samples = 1e8\n", + "cycles = num_samples/18**k\n", + "\n", + "data = sampling(probas, cycles)\n", + "print(\"Num shots for each measurement:\", cycles)\n", + "print(\"Data shape: \", data.shape)" + ] + }, + { + "cell_type": "markdown", + "id": "a9f3bb37", + "metadata": {}, + "source": [ + "# Comparing sampled data to the full probabilities\n", + "\n", + "Let us plot a randomly selected input probe and plot the sampled data against\n", + "the true probabilities.\n", + "\n", + "We can also show the error distribution for the data." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "526be995", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "idx = np.random.randint(6**k)\n", + "\n", + "fig, ax = plt.subplots(1, 2, figsize=(10, 4))\n", + "ax[0].plot(data[idx], label=\"Sampled data\")\n", + "ax[0].plot(probas[idx], label=\"Probabilities\")\n", + "\n", + "ax[1].hist(data[idx] - probas[idx], bins = 30)\n", + "ax[0].set_xlabel(\"Measurement index\")\n", + "ax[0].set_ylabel(\"P(measurement) for input {}\".format(idx))\n", + "\n", + "ax[1].set_xlabel(\"Error\")\n", + "ax[1].set_ylabel(\"# data\".format(idx))\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "5fba9130", + "metadata": {}, + "source": [ + "# Finding the least squares estimate directly (Eq (6))\n", + "\n", + "The least squares (unbiased) estimate is given in Eq(6) of [1]. Since this is\n", + "the direct analytical estimate, there is no need for an optimization algorithm.\n", + "\n", + "The code below is a refactoring of [https://github.com/Hannoskaj/Hyperplane_Intersection_Projection](https://github.com/Hannoskaj/Hyperplane_Intersection_Projection)\n", + "from the original implementation. \n", + "\n", + "I tried to keep the original code as it is and did not refactor the implementation." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "ea634e71", + "metadata": {}, + "outputs": [], + "source": [ + "# Mk = M_k(k)\n", + "\n", + "# def choi_ls_pauli(est, data, input_config_slice, output_config_slice, optimize='optimal'):\n", + "# \"\"\"Least squares estimator for direct QPT with inputs and measurements\n", + "# determined by Pauli matrices.\n", + " \n", + "# We consider all combinations of the Pauli operators\n", + "# (+X, -X, +Y, -Y, +Z, -Z) that can act on each qubit. Since there are k qubits\n", + "# the number of input and output configurations are 6**k. \n", + "\n", + "# Args:\n", + "# est (array): The current estimate of the Choi matrix.\n", + "# data (array [float]): The array of data of shape (m, n) for m inputs and n measurements.\n", + "# input_indices (array [int]): The indices specifying the Pauli operators that are used to prepare the input probes\n", + "# output_indices (array [int]): The indices specifying the Pauli operators that are measured.\n", + "# \"\"\"\n", + "# # Strange order of indices\n", + "# est += np.einsum(\n", + "# \"nm, nde, mfg -> fegd\",\n", + "# data,\n", + "# Mk[input_config_slice],\n", + "# Mk[output_config_slice],\n", + "# optimize=optimize,\n", + "# )\n", + "# return est\n", + "\n", + "\n", + "def Choi_LS_from_Pauli_freq(k, freq, optimize='optimal'):\n", + " \"\"\"\n", + " Direct version, when memory is not a problem. If it is, \n", + " Choi_LS_Pauli_from_channel_mem will have a lighter load.\n", + " \n", + " Yields the least-square estimator of the Choi matrix in a Pauli setting without\n", + " ancilla, when the result of the measurements have frequency freq.\n", + " Input: k is the number of qubits.\n", + " freq is the frequency of each result. Shape $(6^k, 6^k)$. Sums to the \n", + " number of measurement settings $18^k$.\n", + " Output: Matrix $(4^k, 4^k)$. Trace one. Not completely positive, \n", + " nor trace-preserving.\n", + " \n", + " \"\"\"\n", + " Pk = prod_pauli_vecs(k) \n", + " Mk = M_k(k) \n", + " Choi_est = np.einsum('nm, nde, mfg -> fegd', freq, Mk, Mk, optimize=optimize) # Ordre des indices étrange \n", + " return Choi_est.reshape(4**k, 4**k) / 18**k" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "eb7aad1f", + "metadata": {}, + "outputs": [], + "source": [ + "choi_ls_est = Choi_LS_from_Pauli_freq(k, data)" + ] + }, + { + "cell_type": "markdown", + "id": "0c87fd20", + "metadata": {}, + "source": [ + "# Visualize the predicted Choi matrix from the simple least sq. estimate" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "85ff6b7f", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/shahnawaz/Dropbox/dev/qutip/qutip/qobj.py:519: UserWarning: Multiplying superoperators with different representations\n", + " warnings.warn(msg)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "choi_ls_est_qutip = Qobj(choi_ls_est, dims=choi_qutip.dims, superrep='choi')\n", + "\n", + "plot_choi(choi_ls_est_qutip.full(),\n", + " title=\"Choi (LS)\\nFidelity {}\\nIs CP {}: Trace {}\".format(fidelity(choi_ls_est_qutip, choi_qutip), choi_ls_est_qutip.iscp, choi_ls_est_qutip.tr()),\n", + " cbar=True)" + ] + }, + { + "cell_type": "markdown", + "id": "ee9015b1", + "metadata": {}, + "source": [ + "# CPTP projection \n", + "\n", + "The state is very close to our ideal Choi matrix and is almost TP but to get\n", + "a proper CPTP projection, we use the Hyperplane Intersection Projection algorithm" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "e27c2043", + "metadata": {}, + "outputs": [], + "source": [ + "depo_rtol = 1e-16\n", + "depo_tol = 1e-16\n", + "\n", + "\n", + "options_proj={\n", + " \"maxiter\": 300,\n", + " \"HIP_to_alt_switch\": \"first\",\n", + " \"missing_w\": 3,\n", + " \"min_part\": 0.1,\n", + " \"HIP_steps\": 10,\n", + " \"alt_steps\": 4,\n", + " \"alt_to_HIP_switch\": \"cos\",\n", + " \"min_cos\": 0.99,\n", + " \"max_mem_w\": 30,\n", + " \"genarg_alt\": (1, 3, 20),\n", + " \"genarg_HIP\": (5,),\n", + " }\n", + "\n", + "all_dists=False\n", + "first_CP_threshold_least_ev=True,\n", + "all_dists=False,\n", + "dist_L2=True,\n", + "with_evs=False,\n", + "keep_key_channels=False,\n", + "keep_main_eigenvectors=0,\n", + "save_intermediate=True\n", + "\n", + "proj = \"HIPswitch\"\n", + "\n", + "\n", + "def ensure_trace(eigvals):\n", + " \"\"\"\n", + " Ensures that the sum of eigvals is at least one.\n", + "\n", + " Finds the value l so that $\\sum (\\lambda_i - l)_+ = 1$\n", + " and set the eigenvalues $\\lambda_i$ to $(\\lambda_i - l)_+$.\n", + "\n", + " Args:\n", + " eigvals (array): The set of eigenvalues.\n", + "\n", + " Returns:\n", + " (array): The modified set of eigenvalues such that the sum is 1.\n", + " \"\"\"\n", + " trace = eigvals.sum()\n", + " while trace > 1:\n", + " indices_positifs = eigvals.nonzero()\n", + " l = len(indices_positifs[0]) # Number of (still) nonzero eigenvalues\n", + " eigvals[indices_positifs] += (1 - trace) / l \n", + " eigvals = eigvals.clip(0)\n", + " trace = eigvals.sum() \n", + " return eigvals\n", + "\n", + "\n", + "def proj_CP_threshold(rho, free_trace=True, full_output=False, thres_least_ev=False):\n", + " \"\"\"\n", + " If thres_least_ev=False and free_trace=False, then projects rho on CP\n", + " trace_one operators.\n", + " \n", + " More generally, changes the eigenvalues without changing the eigenvectors:\n", + " * if free_trace=True and thres_least_ev=False, then projects on CP operators,\n", + " with no trace condition.\n", + " * if thres_least_ev=True, free_trace is ignored. Then we bound from below all \n", + " eigenvalues by their original value plus the least eigenvalue (which is negative).\n", + " Then all the lower eigenvalues take the lower bound (or zero if it is negative),\n", + " all the higher eigenvalues are unchanged, and there is one eigenvalue in the middle\n", + " that gets a value between its lower bound and its original value, to ensure the\n", + " trace is one.\n", + " \"\"\"\n", + " eigvals, eigvecs = sp.linalg.eigh(rho) # Assumes hermitian; sorted from lambda_min to lambda_max\n", + " \n", + " least_ev = eigvals[0]\n", + " \n", + " if thres_least_ev:\n", + " threshold = - least_ev # > 0\n", + " evlow = (eigvals - threshold).clip(0)\n", + " toadd = eigvals - evlow\n", + " missing = 1 - evlow.sum()\n", + " if missing < 0: # On this rare event, revert to usual projection\n", + " eigvals = eigvals.clip(0)\n", + " eigvals = ensure_trace(eigvals)\n", + " else:\n", + " inv_cum_toadd = toadd[::-1].cumsum()[::-1]\n", + " last_more_missing = np.where(inv_cum_toadd >= missing)[0][-1]\n", + " eigvals[:last_more_missing] = evlow[:last_more_missing]\n", + " eigvals[last_more_missing] = eigvals[last_more_missing] + missing - inv_cum_toadd[last_more_missing] \n", + " else:\n", + " eigvals = eigvals.clip(0)\n", + " if not free_trace:\n", + " eigvals = ensure_trace(eigvals)\n", + " # \n", + " indices_positifs = eigvals.nonzero()[0] \n", + " rho_hat_TLS = (eigvecs[:,indices_positifs] * eigvals[indices_positifs]) @ eigvecs[:,indices_positifs].T.conj()\n", + " \n", + " if full_output==2:\n", + " return rho_hat_TLS, least_ev, len(indices_positifs)\n", + " elif full_output:\n", + " return rho_hat_TLS, least_ev\n", + " else:\n", + " return rho_hat_TLS\n", + "\n", + "\n", + "def proj_TP(rho):\n", + " \"\"\"\n", + " Projects the Choi matrix rho of a channel on trace-preserving channels.\n", + " \"\"\"\n", + " d = np.sqrt(len(rho)).astype(int)\n", + " partial_mixed = np.eye(d) / d\n", + " \n", + " # np.trace on the axes corresponding to the system\n", + " correction = np.einsum('de, fg -> dfeg',partial_mixed, (partial_mixed - np.trace(rho.reshape(4 * [d]), axis1=0, axis2=2)))\n", + " return rho + correction.reshape(d**2, d**2)\n", + "\n", + " \n", + "def step2(XW, target):\n", + " \"\"\"\n", + " Finds a (big) subset of hyperplanes, including the last one, such that\n", + " the projection of the current point on the intersection of the corresponding\n", + " half-spaces is the projection on the intersection of hyperplanes.\n", + "\n", + " Input: XW is the matrix of the scalar products between the different \n", + " non-normalized normal directions projected on the subspace TP, written w_i\n", + " in the main functions.\n", + " target is the intercept of the hyperplanes with respect to the starting point,\n", + " on the scale given by w_i.\n", + "\n", + " Outputs which hyperplanes are kept in subset, and the coefficients on their\n", + " respective w_i in coeffs.\n", + " \"\"\"\n", + " nb_active = XW.shape[0]\n", + " subset = np.array([nb_active - 1])\n", + " coeffs = [target[-1] / XW[-1, -1]] # Always positive\n", + " for i in range(nb_active - 2, -1, -1):\n", + " test = (XW[i, subset].dot(coeffs) < target[i])\n", + " # The condition to project on the intersection of the hyperplanes is that \n", + " # all the coefficients are non-negative. This is equivalent to belonging\n", + " # to the normal cone to the facet.\n", + " if test:\n", + " subset = np.r_[i, subset]\n", + " coeffs = sp.linalg.inv(XW[np.ix_(subset, subset)]).dot(target[subset]) \n", + " # Adding a new hyperplane might generate negative coefficients.\n", + " # We remove the corresponding hyperplanes, except if it is the last \n", + " # hyperplane, in which case we do not add the hyperplane.\n", + " if coeffs[-1] < 0: \n", + " subset = subset[1:]\n", + " coeffs = sp.linalg.inv(XW[np.ix_(subset, subset)]).dot(target[subset]) \n", + " elif not np.all(coeffs >= 0):\n", + " subset = subset[np.where(coeffs >= 0)]\n", + " coeffs = sp.linalg.inv(XW[np.ix_(subset, subset)]).dot(target[subset])\n", + " \n", + " return subset, coeffs\n", + "\n", + "\n", + "def hyperplane_intersection_projection_switch(\n", + " rho,\n", + " true_Choi,\n", + " maxiter=100,\n", + " free_trace=True,\n", + " least_ev_x_dim2_tol=1e-2,\n", + " all_dists=False,\n", + " dist_L2=True,\n", + " with_evs=False,\n", + " save_intermediate=False,\n", + " HIP_to_alt_switch=\"first\",\n", + " alt_to_HIP_switch=\"counter\",\n", + " min_cos=0.99,\n", + " alt_steps=4,\n", + " missing_w=1,\n", + " min_part=0.3,\n", + " HIP_steps=10,\n", + " max_mem_w=30,\n", + " **kwargs,\n", + "):\n", + " \"\"\" Switches between alternate projections and HIP, with the following rules:\n", + " * starts in alternate projections.\n", + " * stays in alternate depending on alt_to_HIP_switch:\n", + " ** if 'counter': uses an iterator (alt_steps) of the iteration number to determine the \n", + " number of consecutive steps before switching. If alt_steps\n", + " is a number, yields this number. If a list cycles on the list.\n", + " ** if 'cos': switching when two\n", + " successive steps are sufficiently colinear, namely if the cosinus of\n", + " the vectors is at least min_cos.\n", + " * stays in HIP depending on HIP_to_alt_switch:\n", + " ** if 'first': stops HIP when the first active hyperplane\n", + " of the sequence gets discarded. (ex: enter at iteration 7, then leaves when \n", + " the hyperplane of iteration 7 is not in w_act anymore).\n", + " ** if 'missing', stops when a total of missing_w (default 1) hyperplanes are \n", + " deemed unnecessary. (ie w_act has lost missing_w member).\n", + " ** if 'part': ends the loop if the length coeff_first * w_first is less than min_part \n", + " times the step size, ie the length of \\sum coeffs_i w_i. This includes the case when\n", + " the first hyperplane is deemed unnecessary, like in 'first'.\n", + " ** if 'counter': uses an iterator (HIP_steps) of the iteration number to determine the \n", + " number of consecutive steps before switching. Iterator in input iter_choice. If \n", + " HIP_steps is a number, yields this number. If a list cycles on the list.\n", + " \"\"\"\n", + "\n", + " # loops = group.loops\n", + " dim2 = len(rho)\n", + " comp_time = 0\n", + " # x_sq, xiwi = -1, 1 # For the first entry in the loop. Yields the impossible -1.\n", + " sel = \"alternate\" # Selector for the step; 'alternate' or 'HIP'.\n", + " if alt_to_HIP_switch == \"cos\":\n", + " w_norm_ancien = np.zeros(\n", + " (dim2, dim2)\n", + " ) # Not normalized to ensure at least two steps are takenp.\n", + " elif alt_to_HIP_switch == \"counter\":\n", + " past_al = 0 # number of steps already made in 'alternate' mode.\n", + " alt_step_gen = step_generator(alt_steps)\n", + " current_alt_step = next(alt_step_gen)\n", + " else:\n", + " raise ValueError('Unknown alt_to_HIP_switch. Must be \"cos\" or \"counter\".')\n", + "\n", + " if HIP_to_alt_switch == \"counter\":\n", + " HIP_step_gen = step_generator(HIP_steps)\n", + " past_HIP = 0\n", + " elif HIP_to_alt_switch == \"part\":\n", + " pass\n", + " elif HIP_to_alt_switch == \"first\":\n", + " pass\n", + " elif HIP_to_alt_switch == \"missing\":\n", + " missed = 0\n", + " else:\n", + " raise ValueError(\n", + " 'Unknown HIP_to_alt_switch. Must be \"first\", \"missing\", \"part\" or \"counter\".'\n", + " )\n", + "\n", + " dims = (dim2, dim2)\n", + "\n", + " active = np.array([])\n", + " nb_actives = 0\n", + " XW = np.zeros((0, 0))\n", + " w_act = np.zeros([0, dim2, dim2])\n", + " target = np.array([])\n", + " coeffs = np.array([])\n", + "\n", + " # rho is on CP, we first project on TP. Outside the loop because we also end on TP.\n", + " rho = proj_TP(rho)\n", + "\n", + " if save_intermediate:\n", + " rhoTP = [np.expand_dims(rho, 0)]\n", + "\n", + " least_ev_list = []\n", + "\n", + " for m in range(maxiter):\n", + " rho_after_CP, least_ev = proj_CP_threshold(rho, free_trace, full_output=True)\n", + "\n", + " if save_intermediate:\n", + " rhoTP.append(np.expand_dims(rho, 0))\n", + " least_ev_list.append(least_ev)\n", + "\n", + " # Breaks here because the (- least_ev) might increase on the next rho\n", + " if (sel == \"alternate\") or (m >= (maxiter - 2)): # Ensures last ones are AP.\n", + " print(\"Alternate projections mode\")\n", + " # On TP and intersection with hyperplane\n", + " if alt_to_HIP_switch == \"cos\":\n", + " w_new = proj_TP(rho_after_CP) - rho\n", + " norm_w = sp.linalg.norm(w_new)\n", + " change = np.vdot(w_new / norm_w, w_norm_ancien).real > min_cos\n", + " w_norm_ancien = w_new / norm_w\n", + "\n", + " # If change with alt_steps, the current projection is transformed into\n", + " # the first HIP step.\n", + " if change:\n", + " active = np.array([m])\n", + " nb_actives = 1\n", + " XW = np.array([[norm_w ** 2]])\n", + " w_act = np.array([w_new])\n", + " coeffs = np.array([sp.linalg.norm(rho - rho_after_CP) ** 2 / norm_w ** 2])\n", + " target = np.array([0.0])\n", + " rho += coeffs[0] * w_new\n", + " else:\n", + " rho += w_new\n", + "\n", + " elif alt_to_HIP_switch == \"counter\":\n", + " rho = proj_TP(rho_after_CP)\n", + " past_al += 1\n", + " change = past_al >= current_alt_step\n", + "\n", + " if change:\n", + " active = np.array([])\n", + " nb_actives = 0\n", + " XW = np.zeros((0, 0))\n", + " w_act = np.zeros([0, dim2, dim2])\n", + " target = np.array([])\n", + " coeffs = np.array([])\n", + "\n", + " if change:\n", + " if HIP_to_alt_switch == \"missing\":\n", + " missed = 0\n", + " elif HIP_to_alt_switch == \"counter\":\n", + " past_HIP = 0\n", + " current_HIP_step = next(HIP_step_gen)\n", + " sel = \"HIP\"\n", + "\n", + " elif sel == \"HIP\": # No other possibility\n", + " print(f\"HIP mode. Active hyperplanes: {1 + nb_actives}\")\n", + "\n", + " sq_norm_x_i = sp.linalg.norm(rho - rho_after_CP) ** 2\n", + " w_i = proj_TP(rho_after_CP) - rho\n", + " xiwi = sp.linalg.norm(w_i) ** 2\n", + "\n", + " XW = np.column_stack([XW, np.zeros(nb_actives)])\n", + " XW = np.row_stack([XW, np.zeros(nb_actives + 1)])\n", + " new_xw = np.einsum(\n", + " \"ij, kij -> k\", w_i.conj(), w_act\n", + " ).real # Notice that the scalar product are all real\n", + " # since the matrices are self-adjoint.\n", + " XW[-1, :-1] = new_xw\n", + " XW[:-1, -1] = new_xw\n", + " XW[-1, -1] = xiwi\n", + " target = np.r_[target, sq_norm_x_i]\n", + "\n", + " active = np.concatenate((active, [m]))\n", + " w_act = np.concatenate([w_act, [w_i]])\n", + "\n", + " subset, coeffs = step2(XW, target)\n", + "\n", + " if HIP_to_alt_switch == \"missing\":\n", + " missed += len(active) - len(\n", + " subset\n", + " ) # Don't move this after the update to active !!!\n", + "\n", + " XW = XW[np.ix_(subset, subset)]\n", + " active = active[subset]\n", + " nb_actives = len(active)\n", + " w_act = w_act[subset]\n", + " target = np.zeros((nb_actives,))\n", + " rho += np.einsum(\"k, kij -> ij\", coeffs, w_act)\n", + "\n", + " if HIP_to_alt_switch in [\"first\", \"part\"]:\n", + " if (\n", + " subset[0] != 0\n", + " ) or nb_actives > max_mem_w: # max_mem_w limits memory usage\n", + " change = True\n", + " elif HIP_to_alt_switch == \"part\":\n", + " step_size = np.sqrt(np.einsum(\"i, ij, j\", coeffs, XW, coeffs))\n", + " w_first_contrib = coeffs[0] * np.sqrt(XW[0, 0])\n", + " change = min_part * step_size >= w_first_contrib\n", + " else:\n", + " change = False\n", + " elif HIP_to_alt_switch in [\"counter\", \"missing\"]:\n", + "\n", + " # Limits memory usage\n", + " if nb_actives > max_mem_w:\n", + " nb_actives -= 1\n", + " active = active[1:]\n", + " w_act = w_act[1:]\n", + " target = target[1:]\n", + " XW = XW[1:, 1:]\n", + " if HIP_to_alt_switch == \"missing\":\n", + " missed += 1\n", + " # End max_mem_w case\n", + "\n", + " if HIP_to_alt_switch == \"missing\":\n", + " change = missed >= missing_w\n", + " elif HIP_to_alt_switch == \"counter\":\n", + " past_HIP += 1\n", + " change = past_HIP >= current_HIP_step\n", + "\n", + " if change:\n", + " if alt_to_HIP_switch == \"cos\":\n", + " w_norm_ancien = np.zeros(\n", + " (dim2, dim2)\n", + " ) # Ensures two alternate steps. Also possible to\n", + " # use w_norm_ancien = w_i / sqrt(xiwi)\n", + " elif alt_to_HIP_switch == \"counter\":\n", + " past_al = 0\n", + " current_alt_step = next(alt_step_gen)\n", + " sel = \"alternate\"\n", + "\n", + " else:\n", + " raise ValueError('How did I get there? Typo on \"HIP\" or \"alternate\"?')\n", + "\n", + " return rhoTP, least_ev_list, m\n", + "\n", + "\n", + "\n", + "def final_CPTP_by_mixing(rho, full_output=False):\n", + " \"\"\"\n", + " Assumed to be in TP.\n", + " \"\"\"\n", + " d = len(rho)\n", + " abs_least_ev = - sp.linalg.eigvalsh(rho, subset_by_index=[0,0])[0]\n", + " if full_output:\n", + " return (rho + abs_least_ev * np.eye(d)) / (1 + d * abs_least_ev), - abs_least_ev\n", + " else:\n", + " return (rho + abs_least_ev * np.eye(d)) / (1 + d * abs_least_ev)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "ccd5def0", + "metadata": {}, + "outputs": [], + "source": [ + "first_CP_threshold_least_ev=True,\n", + "\n", + "rho = choi_ls_est\n", + "# CP estimator: first projection on CP matrices\n", + "rhoCP, LS_least_ev = proj_CP_threshold(rho, full_output=True, thres_least_ev=first_CP_threshold_least_ev)\n", + "ls_rel = -LS_least_ev * depo_rtol\n", + "least_ev_x_dim2_tol = np.maximum(ls_rel, depo_tol)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "744899ee", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "HIP mode. Active hyperplanes: 3\n", + "HIP mode. Active hyperplanes: 3\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "HIP mode. Active hyperplanes: 2\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n", + "Alternate projections mode\n" + ] + } + ], + "source": [ + "rho_list, least_ev_pls, iterations = hyperplane_intersection_projection_switch(\n", + " rhoCP,\n", + " choi_true,\n", + " **options_proj,\n", + " least_ev_x_dim2_tol=least_ev_x_dim2_tol,\n", + " all_dists=all_dists,\n", + " with_evs=with_evs,\n", + " dist_L2=dist_L2,\n", + " save_intermediate=save_intermediate,\n", + " )\n", + "\n", + "choi_pred = final_CPTP_by_mixing(rho_list[-1][0])" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "eec93ff6", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/shahnawaz/miniconda3/lib/python3.7/site-packages/ipykernel_launcher.py:1: RuntimeWarning: invalid value encountered in log10\n", + " \"\"\"Entry point for launching an IPython kernel.\n", + "WARNING:matplotlib.legend:No handles with labels found to put in legend.\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(np.log10(-np.array(least_ev_pls)))\n", + "plt.legend()\n", + "plt.xlabel(\"Iterations\")\n", + "plt.ylabel(r\"log ($-\\lambda_{min}$)\")\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "0ac5218a", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/shahnawaz/Dropbox/dev/qutip/qutip/qobj.py:519: UserWarning: Multiplying superoperators with different representations\n", + " warnings.warn(msg)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plot_choi(choi_true, title=\"Choi (true)\", cbar=True)\n", + "plt.show()\n", + "\n", + "choi_pls_cptp = Qobj(choi_pred, dims=choi_qutip.dims, superrep='choi')\n", + "\n", + "plot_choi(choi_pls_cptp.full(),\n", + " title=\"Choi (LS)\\nFidelity {}\\nIs CP {}: Trace {}\".format(fidelity(choi_pls_cptp, choi_qutip), choi_pls_cptp.iscp, choi_pls_cptp.tr()),\n", + " cbar=True)" + ] + } + ], + "metadata": { + "interpreter": { + "hash": "383c5c00937595a71b70c28deded6c82313774eab0af53a7bbcdcf71bc0a4cad" + }, + "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.6" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}