From 5b598b54041ec0cdf708e6782516549e8df7d337 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 13:03:10 +1000 Subject: [PATCH 01/20] plotting a state and process in the Pauli-Liouville basis --- .../plotting/process_and_state.py | 60 +++++++++++++++++++ 1 file changed, 60 insertions(+) create mode 100644 forest/benchmarking/plotting/process_and_state.py diff --git a/forest/benchmarking/plotting/process_and_state.py b/forest/benchmarking/plotting/process_and_state.py new file mode 100644 index 00000000..c17ba8de --- /dev/null +++ b/forest/benchmarking/plotting/process_and_state.py @@ -0,0 +1,60 @@ +import matplotlib.pyplot as plt +import numpy as np + +def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): + """ + Visualize a quantum state in the Pauli-Liouville basis. + + Example: + + from forest.benchmarking.superoperator_tools import * + from forest.benchmarking.utils import n_qubit_pauli_basis + + # zero state in the (Z) computational basis + rho_std_basis = np.array([[1, 0], [0, 0]]) + + # change to Pauli-Liouville basis + n_qubits = 1 + pl_basis = n_qubit_pauli_basis(n_qubits) + c2p = computational2pauli_basis_matrix(2*n_qubits) + rho_pl_basis = np.real(c2p@vec(rho_std_basis)) + + #plot + fig, ax = plt.subplots(1) + plot_pauli_rep_of_state(rho_pl_basis, ax, pl_basis.labels, 'Zero state |0>') + + + :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot. + """ + if len(state_pl_basis.shape)==1: + raise ValueError("You must pass in a (N by 1) or a (1 by N) numpy.ndarray") + if np.iscomplexobj(rho_std_basis): + raise ValueError("You must pass in a real vector") + + im = ax.imshow(state_pl_basis, interpolation="nearest", cmap="RdBu", vmin=-1/2, vmax=1/2) + dim = len(labels) + # make the colorbar ticks look pretty + rows, cols = state_pl_basis.shape + if rows>cols: + cb = plt.colorbar(im, ax=ax,ticks=[-1/2,-1/4, 0, 1/4, 1/2]) + ticklabs = cb.ax.get_yticklabels() + cb.ax.set_yticklabels(ticklabs,ha='right') + cb.ax.yaxis.set_tick_params(pad=35) + # axis labels etc + ax.set_xlabel("Coefficient") + ax.set_xticks([]) + ax.set_yticks(range(dim)) + ax.set_ylabel("Pauli Operator") + ax.set_yticklabels(labels) + else: + cb = plt.colorbar(im, ax=ax,ticks=[-1/2,-1/4, 0, 1/4, 1/2],orientation="horizontal", pad=0.23) + ax.set_ylabel("Coefficient") + ax.set_yticks([]) + ax.set_xticks(range(dim)) + ax.set_xlabel("Pauli Operator") + ax.set_xticklabels(labels) + ax.set_title(title) + ax.grid(False) From 6bb3584a12583516703e541005fa700eeaf7e74b Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 13:04:18 +1000 Subject: [PATCH 02/20] edits --- .../plotting/process_and_state.py | 61 +++++++++++++------ 1 file changed, 43 insertions(+), 18 deletions(-) diff --git a/forest/benchmarking/plotting/process_and_state.py b/forest/benchmarking/plotting/process_and_state.py index c17ba8de..9f264d88 100644 --- a/forest/benchmarking/plotting/process_and_state.py +++ b/forest/benchmarking/plotting/process_and_state.py @@ -1,47 +1,44 @@ import matplotlib.pyplot as plt import numpy as np + def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): """ Visualize a quantum state in the Pauli-Liouville basis. - Example: + :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot. + Examples + -------- from forest.benchmarking.superoperator_tools import * from forest.benchmarking.utils import n_qubit_pauli_basis - # zero state in the (Z) computational basis rho_std_basis = np.array([[1, 0], [0, 0]]) - # change to Pauli-Liouville basis n_qubits = 1 pl_basis = n_qubit_pauli_basis(n_qubits) c2p = computational2pauli_basis_matrix(2*n_qubits) rho_pl_basis = np.real(c2p@vec(rho_std_basis)) - - #plot + # plot fig, ax = plt.subplots(1) plot_pauli_rep_of_state(rho_pl_basis, ax, pl_basis.labels, 'Zero state |0>') - - - :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. - :param ax: The matplotlib axes. - :param labels: The labels for the operator basis states. - :param title: The title for the plot. """ - if len(state_pl_basis.shape)==1: + if len(state_pl_basis.shape) == 1: raise ValueError("You must pass in a (N by 1) or a (1 by N) numpy.ndarray") - if np.iscomplexobj(rho_std_basis): + if np.iscomplexobj(state_pl_basis): raise ValueError("You must pass in a real vector") - im = ax.imshow(state_pl_basis, interpolation="nearest", cmap="RdBu", vmin=-1/2, vmax=1/2) + im = ax.imshow(state_pl_basis, interpolation="nearest", cmap="RdBu", vmin=-1 / 2, vmax=1 / 2) dim = len(labels) # make the colorbar ticks look pretty rows, cols = state_pl_basis.shape - if rows>cols: - cb = plt.colorbar(im, ax=ax,ticks=[-1/2,-1/4, 0, 1/4, 1/2]) + if rows > cols: + cb = plt.colorbar(im, ax=ax, ticks=[-1 / 2, -1 / 4, 0, 1 / 4, 1 / 2]) ticklabs = cb.ax.get_yticklabels() - cb.ax.set_yticklabels(ticklabs,ha='right') + cb.ax.set_yticklabels(ticklabs, ha='right') cb.ax.yaxis.set_tick_params(pad=35) # axis labels etc ax.set_xlabel("Coefficient") @@ -50,7 +47,9 @@ def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): ax.set_ylabel("Pauli Operator") ax.set_yticklabels(labels) else: - cb = plt.colorbar(im, ax=ax,ticks=[-1/2,-1/4, 0, 1/4, 1/2],orientation="horizontal", pad=0.23) + cb = plt.colorbar(im, ax=ax, ticks=[-1 / 2, -1 / 4, 0, 1 / 4, 1 / 2], + orientation="horizontal", + pad=0.22) ax.set_ylabel("Coefficient") ax.set_yticks([]) ax.set_xticks(range(dim)) @@ -58,3 +57,29 @@ def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): ax.set_xticklabels(labels) ax.set_title(title) ax.grid(False) + + +def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): + """ + Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer + Matrix) of the process. + + :param numpy.ndarray ptransfermatrix: The Pauli Transfer Matrix + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot + """ + im = ax.imshow(ptransfermatrix, interpolation="nearest", cmap="RdBu", vmin=-1, vmax=1) + dim = len(labels) + cb = plt.colorbar(im, ax=ax, ticks=[-1, -3 / 4, -1 / 2, -1 / 4, 0, 1 / 4, 1 / 2, 3 / 4, 1]) + ticklabs = cb.ax.get_yticklabels() + cb.ax.set_yticklabels(ticklabs, ha='right') + cb.ax.yaxis.set_tick_params(pad=35) + ax.set_xticks(range(dim)) + ax.set_xlabel("Input Pauli Operator") + ax.set_yticks(range(dim)) + ax.set_ylabel("Output Pauli Operator") + ax.set_title(title) + ax.set_xticklabels(labels, rotation=45) + ax.set_yticklabels(labels) + ax.grid(False) From 9c15e7d9bfd89f4e75375f7cea5ef3ec94da0249 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 13:45:04 +1000 Subject: [PATCH 03/20] include computational basis --- forest/benchmarking/utils.py | 30 +++++++++++++++++++++++------- 1 file changed, 23 insertions(+), 7 deletions(-) diff --git a/forest/benchmarking/utils.py b/forest/benchmarking/utils.py index d7c94e61..8a509ae1 100644 --- a/forest/benchmarking/utils.py +++ b/forest/benchmarking/utils.py @@ -432,21 +432,27 @@ def __repr__(self): pauli_label_ops = [('I', np.eye(2)), ('X', X), ('Y', Y), ('Z', Z)] +PAULI_BASIS = OperatorBasis(pauli_label_ops) -def pauli_basis_measurements(qubit): +def n_qubit_pauli_basis(n): """ - Generates the Programs required to measure the expectation values of the pauli operators. + Construct the tensor product operator basis of `n` PAULI_BASIS's. - :param qubit: Required argument (so that the caller has a reference). + :param int n: The number of qubits. + :return: The product Pauli operator basis of `n` qubits + :rtype: OperatorBasis """ - pauli_label_meas_progs = [Program(), Program(RY(-np.pi / 2, qubit)), Program(RX(-np.pi / 2, qubit)), Program()] - return pauli_label_meas_progs + if n >= 1: + return PAULI_BASIS ** n + else: + raise ValueError("n = {} should be at least 1.".format(n)) -PAULI_BASIS = OperatorBasis(pauli_label_ops) +computational_label_ops = [('0', np.array([[1], [0]])), ('1', np.array([[0], [1]]))] +COMPUTATIONAL_BASIS = OperatorBasis(computational_label_ops) -def n_qubit_pauli_basis(n): +def n_qubit_computational_basis(n): """ Construct the tensor product operator basis of `n` PAULI_BASIS's. @@ -458,6 +464,16 @@ def n_qubit_pauli_basis(n): return PAULI_BASIS ** n else: raise ValueError("n = {} should be at least 1.".format(n)) + + +def pauli_basis_measurements(qubit): + """ + Generates the Programs required to measure the expectation values of the pauli operators. + + :param qubit: Required argument (so that the caller has a reference). + """ + pauli_label_meas_progs = [Program(), Program(RY(-np.pi / 2, qubit)), Program(RX(-np.pi / 2, qubit)), Program()] + return pauli_label_meas_progs def transform_pauli_moments_to_bit(mean_p, var_p): From e0205eeccfbf1029f99a93265b9992b41042b187 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 13:46:41 +1000 Subject: [PATCH 04/20] minor format --- forest/benchmarking/utils.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/forest/benchmarking/utils.py b/forest/benchmarking/utils.py index 8a509ae1..9e63d15a 100644 --- a/forest/benchmarking/utils.py +++ b/forest/benchmarking/utils.py @@ -434,6 +434,7 @@ def __repr__(self): PAULI_BASIS = OperatorBasis(pauli_label_ops) + def n_qubit_pauli_basis(n): """ Construct the tensor product operator basis of `n` PAULI_BASIS's. @@ -452,6 +453,7 @@ def n_qubit_pauli_basis(n): COMPUTATIONAL_BASIS = OperatorBasis(computational_label_ops) + def n_qubit_computational_basis(n): """ Construct the tensor product operator basis of `n` PAULI_BASIS's. From 68861e71fea51f923810a7970b0443333edf3ec4 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 13:48:44 +1000 Subject: [PATCH 05/20] rookie mistake --- forest/benchmarking/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/forest/benchmarking/utils.py b/forest/benchmarking/utils.py index 9e63d15a..3669056d 100644 --- a/forest/benchmarking/utils.py +++ b/forest/benchmarking/utils.py @@ -463,7 +463,7 @@ def n_qubit_computational_basis(n): :rtype: OperatorBasis """ if n >= 1: - return PAULI_BASIS ** n + return COMPUTATIONAL_BASIS ** n else: raise ValueError("n = {} should be at least 1.".format(n)) From 543879c1ccc2d6cc89415f3a8f8564a7252134e2 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 16:39:07 +1000 Subject: [PATCH 06/20] bar like plot --- .../plotting/process_and_state.py | 20 +++++++++++++++++++ 1 file changed, 20 insertions(+) diff --git a/forest/benchmarking/plotting/process_and_state.py b/forest/benchmarking/plotting/process_and_state.py index 9f264d88..4c375e81 100644 --- a/forest/benchmarking/plotting/process_and_state.py +++ b/forest/benchmarking/plotting/process_and_state.py @@ -59,6 +59,26 @@ def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): ax.grid(False) +def plot_pauli_bar_rep_of_state(state_pl_basis, ax, labels, title): + """ + Visualize a quantum state in the Pauli-Liouville basis. The magnitude of the operator + coeffiences are represent by the height of a bar in the bargraph. + + :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot. + """ + dim = len(labels) + im = ax.bar(np.arange(dim) - .4, np.real(state_pl_basis), width=.8) + ax.set_xticks(range(dim)) + ax.set_xlabel("Pauli Operator") + ax.set_ylabel("Coefficient") + ax.set_title(title) + ax.set_xticklabels(labels, rotation=45) + ax.grid(False) + + def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): """ Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer From 2324c7e05aef82b07dc188fbe6624bf5cbac67fc Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Mon, 6 May 2019 16:39:58 +1000 Subject: [PATCH 07/20] plot a real matrix using a Hinton diagram --- forest/benchmarking/plotting/hinton.py | 98 +++++++++++++++++++++++++- 1 file changed, 97 insertions(+), 1 deletion(-) diff --git a/forest/benchmarking/plotting/hinton.py b/forest/benchmarking/plotting/hinton.py index 3be293f9..0fb17a63 100644 --- a/forest/benchmarking/plotting/hinton.py +++ b/forest/benchmarking/plotting/hinton.py @@ -1,11 +1,14 @@ -import matplotlib.pyplot as plt import numpy as np +from typing import List +import matplotlib.pyplot as plt from matplotlib import cm +import matplotlib as mpl from matplotlib.colors import Normalize ANGLE_MAPPER = cm.ScalarMappable(norm=Normalize(vmin=-np.pi, vmax=np.pi)) +# Modified from the SciPy Cookbook. def hinton(matrix, max_weight=1.0, ax=None): """Draw Hinton diagram for visualizing a weight matrix.""" ax = ax if ax is not None else plt.gca() @@ -30,3 +33,96 @@ def hinton(matrix, max_weight=1.0, ax=None): ax.set_ylim((-max_weight / 2, matrix.shape[1] - max_weight / 2)) ax.autoscale_view() ax.invert_yaxis() + + + +# From QuTiP which in turn modified the code from the SciPy Cookbook. +def _blob(x, y, w, w_max, area, cmap=None): + """ + Draws a square-shaped blob with the given area (< 1) at the given coordinates. + """ + hs = np.sqrt(area) / 2 + xcorners = np.array([x - hs, x + hs, x + hs, x - hs]) + ycorners = np.array([y - hs, y - hs, y + hs, y + hs]) + + plt.fill(xcorners, ycorners, + color=cmap(int((w + w_max) * 256 / (2 * w_max)))) + + +# From QuTip (see https://bit.ly/2LrbayH ) which in turn modified the code from the SciPy Cookbook. +def hinton_real(matrix: np.ndarray, + max_weight: float = None, + xlabels: List[str] = None, + ylabels: List[str] = None, + title: str = None, + ax=None, + cmap=None, + label_top: bool = True): + ''' + Draw Hinton diagram for visualizing a real valued weight matrix. + + In the traditional Hinton diagram positive and negative values are represented by white and + black squares respectively. The size of each square represents the magnitude of each value. + The traditional Hinton diagram can be recovered by setting cmap = cm.Greys_r. + + :param matrix: The matrix to be visualized. + :param max_weight: normalize size to this scalar. + :param xlabels: The labels for the operator basis. + :param ylabels: The labels for the operator basis. + :param title: The title for the plot. + :param ax: The matplotlib axes. + :param cmap: A matplotlib colormap to use when plotting. + :param label_top: If True, x-axis labels will be placed on top, otherwise they will appear + below the plot. + :return: A tuple of the matplotlib figure and axes instances used to produce the figure. + ''' + if ax is None: + fig, ax = plt.subplots(1, 1, figsize=(8, 6)) + if cmap is None: + cmap = cm.RdBu + + if title and fig: + ax.set_title(title) + + ax.set_aspect('equal', 'box') + ax.set_frame_on(False) + + height, width = matrix.shape + if max_weight is None: + max_weight = 1.25 * max(abs(np.diag(np.matrix(matrix)))) + if max_weight <= 0.0: + max_weight = 1.0 + + ax.fill(np.array([0, width, width, 0]), np.array([0, 0, height, height]), color=cmap(128)) + for x in range(width): + for y in range(height): + _x = x + 1 + _y = y + 1 + if np.real(matrix[x, y]) > 0.0: + _blob(_x - 0.5, height - _y + 0.5, np.abs(matrix[x, y]), max_weight, + np.min(1, np.abs(matrix[x, y]) / max_weight), cmap=cmap) + else: + _blob(_x - 0.5, height - _y + 0.5, -np.abs(matrix[x, y]), max_weight, + np.min(1, np.abs(matrix[x, y]) / max_weight), cmap=cmap) + + # color axis + if max_weight is None: + norm = mpl.colors.Normalize(-np.abs(matrix).max(), np.abs(matrix).max()) + else: + norm = mpl.colors.Normalize(-np.abs(max_weight), max_weight) + cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1) + mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap) + # x axis + ax.xaxis.set_major_locator(plt.IndexLocator(1, 0.5)) + if xlabels: + ax.set_xticklabels(xlabels) + if label_top: + ax.xaxis.tick_top() + ax.tick_params(axis='x', labelsize=14) + # y axis + ax.yaxis.set_major_locator(plt.IndexLocator(1, 0.5)) + if ylabels: + ax.set_yticklabels(list(reversed(ylabels))) + ax.tick_params(axis='y', labelsize=14) + + return fig, ax From 2706c0e64019f669e8b6c7344ee0232021557247 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 08:26:05 +1000 Subject: [PATCH 08/20] what? --- .../plotting/{process_and_state.py => state_and_process1.py} | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) rename forest/benchmarking/plotting/{process_and_state.py => state_and_process1.py} (99%) diff --git a/forest/benchmarking/plotting/process_and_state.py b/forest/benchmarking/plotting/state_and_process1.py similarity index 99% rename from forest/benchmarking/plotting/process_and_state.py rename to forest/benchmarking/plotting/state_and_process1.py index 4c375e81..8da18083 100644 --- a/forest/benchmarking/plotting/process_and_state.py +++ b/forest/benchmarking/plotting/state_and_process1.py @@ -3,7 +3,7 @@ def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): - """ + r""" Visualize a quantum state in the Pauli-Liouville basis. :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. From b4abc11514e1425bff2c30e671c320aae84fa4bd Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 12:09:09 +1000 Subject: [PATCH 09/20] rename and tweak --- forest/benchmarking/plotting/hinton.py | 16 +-- .../plotting/state_and_process1.py | 105 ------------------ 2 files changed, 8 insertions(+), 113 deletions(-) delete mode 100644 forest/benchmarking/plotting/state_and_process1.py diff --git a/forest/benchmarking/plotting/hinton.py b/forest/benchmarking/plotting/hinton.py index 0fb17a63..36035843 100644 --- a/forest/benchmarking/plotting/hinton.py +++ b/forest/benchmarking/plotting/hinton.py @@ -45,11 +45,11 @@ def _blob(x, y, w, w_max, area, cmap=None): xcorners = np.array([x - hs, x + hs, x + hs, x - hs]) ycorners = np.array([y - hs, y - hs, y + hs, y + hs]) - plt.fill(xcorners, ycorners, - color=cmap(int((w + w_max) * 256 / (2 * w_max)))) + plt.fill(xcorners, ycorners, color=cmap(int((w + w_max) * 256 / (2 * w_max)))) -# From QuTip (see https://bit.ly/2LrbayH ) which in turn modified the code from the SciPy Cookbook. +# Modified from QuTip (see https://bit.ly/2LrbayH ) which in turn modified the code from the +# SciPy Cookbook. def hinton_real(matrix: np.ndarray, max_weight: float = None, xlabels: List[str] = None, @@ -82,7 +82,7 @@ def hinton_real(matrix: np.ndarray, cmap = cm.RdBu if title and fig: - ax.set_title(title) + ax.set_title(title,y=1.1) ax.set_aspect('equal', 'box') ax.set_frame_on(False) @@ -99,11 +99,11 @@ def hinton_real(matrix: np.ndarray, _x = x + 1 _y = y + 1 if np.real(matrix[x, y]) > 0.0: - _blob(_x - 0.5, height - _y + 0.5, np.abs(matrix[x, y]), max_weight, - np.min(1, np.abs(matrix[x, y]) / max_weight), cmap=cmap) + _blob(_x - 0.5, height - _y + 0.5, abs(matrix[x, y]), max_weight, + min(1, abs(matrix[x, y]) / max_weight), cmap=cmap) else: - _blob(_x - 0.5, height - _y + 0.5, -np.abs(matrix[x, y]), max_weight, - np.min(1, np.abs(matrix[x, y]) / max_weight), cmap=cmap) + _blob(_x - 0.5, height - _y + 0.5, -abs(matrix[x, y]), max_weight, + min(1, abs(matrix[x, y]) / max_weight), cmap=cmap) # color axis if max_weight is None: diff --git a/forest/benchmarking/plotting/state_and_process1.py b/forest/benchmarking/plotting/state_and_process1.py deleted file mode 100644 index 8da18083..00000000 --- a/forest/benchmarking/plotting/state_and_process1.py +++ /dev/null @@ -1,105 +0,0 @@ -import matplotlib.pyplot as plt -import numpy as np - - -def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): - r""" - Visualize a quantum state in the Pauli-Liouville basis. - - :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. - :param ax: The matplotlib axes. - :param labels: The labels for the operator basis states. - :param title: The title for the plot. - - Examples - -------- - from forest.benchmarking.superoperator_tools import * - from forest.benchmarking.utils import n_qubit_pauli_basis - # zero state in the (Z) computational basis - rho_std_basis = np.array([[1, 0], [0, 0]]) - # change to Pauli-Liouville basis - n_qubits = 1 - pl_basis = n_qubit_pauli_basis(n_qubits) - c2p = computational2pauli_basis_matrix(2*n_qubits) - rho_pl_basis = np.real(c2p@vec(rho_std_basis)) - # plot - fig, ax = plt.subplots(1) - plot_pauli_rep_of_state(rho_pl_basis, ax, pl_basis.labels, 'Zero state |0>') - """ - if len(state_pl_basis.shape) == 1: - raise ValueError("You must pass in a (N by 1) or a (1 by N) numpy.ndarray") - if np.iscomplexobj(state_pl_basis): - raise ValueError("You must pass in a real vector") - - im = ax.imshow(state_pl_basis, interpolation="nearest", cmap="RdBu", vmin=-1 / 2, vmax=1 / 2) - dim = len(labels) - # make the colorbar ticks look pretty - rows, cols = state_pl_basis.shape - if rows > cols: - cb = plt.colorbar(im, ax=ax, ticks=[-1 / 2, -1 / 4, 0, 1 / 4, 1 / 2]) - ticklabs = cb.ax.get_yticklabels() - cb.ax.set_yticklabels(ticklabs, ha='right') - cb.ax.yaxis.set_tick_params(pad=35) - # axis labels etc - ax.set_xlabel("Coefficient") - ax.set_xticks([]) - ax.set_yticks(range(dim)) - ax.set_ylabel("Pauli Operator") - ax.set_yticklabels(labels) - else: - cb = plt.colorbar(im, ax=ax, ticks=[-1 / 2, -1 / 4, 0, 1 / 4, 1 / 2], - orientation="horizontal", - pad=0.22) - ax.set_ylabel("Coefficient") - ax.set_yticks([]) - ax.set_xticks(range(dim)) - ax.set_xlabel("Pauli Operator") - ax.set_xticklabels(labels) - ax.set_title(title) - ax.grid(False) - - -def plot_pauli_bar_rep_of_state(state_pl_basis, ax, labels, title): - """ - Visualize a quantum state in the Pauli-Liouville basis. The magnitude of the operator - coeffiences are represent by the height of a bar in the bargraph. - - :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. - :param ax: The matplotlib axes. - :param labels: The labels for the operator basis states. - :param title: The title for the plot. - """ - dim = len(labels) - im = ax.bar(np.arange(dim) - .4, np.real(state_pl_basis), width=.8) - ax.set_xticks(range(dim)) - ax.set_xlabel("Pauli Operator") - ax.set_ylabel("Coefficient") - ax.set_title(title) - ax.set_xticklabels(labels, rotation=45) - ax.grid(False) - - -def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): - """ - Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer - Matrix) of the process. - - :param numpy.ndarray ptransfermatrix: The Pauli Transfer Matrix - :param ax: The matplotlib axes. - :param labels: The labels for the operator basis states. - :param title: The title for the plot - """ - im = ax.imshow(ptransfermatrix, interpolation="nearest", cmap="RdBu", vmin=-1, vmax=1) - dim = len(labels) - cb = plt.colorbar(im, ax=ax, ticks=[-1, -3 / 4, -1 / 2, -1 / 4, 0, 1 / 4, 1 / 2, 3 / 4, 1]) - ticklabs = cb.ax.get_yticklabels() - cb.ax.set_yticklabels(ticklabs, ha='right') - cb.ax.yaxis.set_tick_params(pad=35) - ax.set_xticks(range(dim)) - ax.set_xlabel("Input Pauli Operator") - ax.set_yticks(range(dim)) - ax.set_ylabel("Output Pauli Operator") - ax.set_title(title) - ax.set_xticklabels(labels, rotation=45) - ax.set_yticklabels(labels) - ax.grid(False) From d0b4f4466af89efe60a2ee6886a8ca0bc5c344a7 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 12:09:39 +1000 Subject: [PATCH 10/20] the file --- forest/benchmarking/plotting/state_process.py | 105 ++++++++++++++++++ 1 file changed, 105 insertions(+) create mode 100644 forest/benchmarking/plotting/state_process.py diff --git a/forest/benchmarking/plotting/state_process.py b/forest/benchmarking/plotting/state_process.py new file mode 100644 index 00000000..28ce4dcb --- /dev/null +++ b/forest/benchmarking/plotting/state_process.py @@ -0,0 +1,105 @@ +import matplotlib.pyplot as plt +import numpy as np + + +def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): + """ + Visualize a quantum state in the Pauli-Liouville basis. + + :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot. + + Examples + -------- + from forest.benchmarking.superoperator_tools import * + from forest.benchmarking.utils import n_qubit_pauli_basis + # zero state in the (Z) computational basis + rho_std_basis = np.array([[1, 0], [0, 0]]) + # change to Pauli-Liouville basis + n_qubits = 1 + pl_basis = n_qubit_pauli_basis(n_qubits) + c2p = computational2pauli_basis_matrix(2*n_qubits) + rho_pl_basis = np.real(c2p@vec(rho_std_basis)) + # plot + fig, ax = plt.subplots(1) + plot_pauli_rep_of_state(rho_pl_basis, ax, pl_basis.labels, 'Zero state |0>') + """ + if len(state_pl_basis.shape) == 1: + raise ValueError("You must pass in a (N by 1) or a (1 by N) numpy.ndarray") + if np.iscomplexobj(state_pl_basis): + raise ValueError("You must pass in a real vector") + + im = ax.imshow(state_pl_basis, interpolation="nearest", cmap="RdBu", vmin=-1 / 2, vmax=1 / 2) + dim = len(labels) + # make the colorbar ticks look pretty + rows, cols = state_pl_basis.shape + if rows > cols: + cb = plt.colorbar(im, ax=ax, ticks=[-1 / 2, -1 / 4, 0, 1 / 4, 1 / 2]) + ticklabs = cb.ax.get_yticklabels() + cb.ax.set_yticklabels(ticklabs, ha='right') + cb.ax.yaxis.set_tick_params(pad=35) + # axis labels etc + ax.set_xlabel("Coefficient") + ax.set_xticks([]) + ax.set_yticks(range(dim)) + ax.set_ylabel("Pauli Operator") + ax.set_yticklabels(labels) + else: + cb = plt.colorbar(im, ax=ax, ticks=[-1 / 2, -1 / 4, 0, 1 / 4, 1 / 2], + orientation="horizontal", + pad=0.22) + ax.set_ylabel("Coefficient") + ax.set_yticks([]) + ax.set_xticks(range(dim)) + ax.set_xlabel("Pauli Operator") + ax.set_xticklabels(labels) + ax.set_title(title) + ax.grid(False) + + +def plot_pauli_bar_rep_of_state(state_pl_basis, ax, labels, title): + """ + Visualize a quantum state in the Pauli-Liouville basis. The magnitude of the operator + coeffiences are represent by the height of a bar in the bargraph. + + :param numpy.ndarray state_pl_basis: The quantum state represented in the Pauli-Liouville basis. + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot. + """ + dim = len(labels) + im = ax.bar(np.arange(dim) - .4, np.real(state_pl_basis), width=.8) + ax.set_xticks(range(dim)) + ax.set_xlabel("Pauli Operator") + ax.set_ylabel("Coefficient") + ax.set_title(title) + ax.set_xticklabels(labels, rotation=45) + ax.grid(False) + + +def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): + """ + Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer + Matrix) of the process. + + :param numpy.ndarray ptransfermatrix: The Pauli Transfer Matrix + :param ax: The matplotlib axes. + :param labels: The labels for the operator basis states. + :param title: The title for the plot + """ + im = ax.imshow(ptransfermatrix, interpolation="nearest", cmap="RdBu", vmin=-1, vmax=1) + dim = len(labels) + cb = plt.colorbar(im, ax=ax, ticks=[-1, -3 / 4, -1 / 2, -1 / 4, 0, 1 / 4, 1 / 2, 3 / 4, 1]) + ticklabs = cb.ax.get_yticklabels() + cb.ax.set_yticklabels(ticklabs, ha='right') + cb.ax.yaxis.set_tick_params(pad=35) + ax.set_xticks(range(dim)) + ax.set_xlabel("Input Pauli Operator") + ax.set_yticks(range(dim)) + ax.set_ylabel("Output Pauli Operator") + ax.set_title(title) + ax.set_xticklabels(labels, rotation=45) + ax.set_yticklabels(labels) + ax.grid(False) \ No newline at end of file From 78d5194949453753d65b89bd64cbc9e2ec5bc1ff Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 12:10:07 +1000 Subject: [PATCH 11/20] an example notebook --- examples/state_and_process_plots.ipynb | 624 +++++++++++++++++++++++++ 1 file changed, 624 insertions(+) create mode 100644 examples/state_and_process_plots.ipynb diff --git a/examples/state_and_process_plots.ipynb b/examples/state_and_process_plots.ipynb new file mode 100644 index 00000000..76d9d8a3 --- /dev/null +++ b/examples/state_and_process_plots.ipynb @@ -0,0 +1,624 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# State and Process Plots" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Some states" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# python related things\n", + "import numpy as np\n", + "from matplotlib import pyplot as plt\n", + "\n", + "# quantum related things\n", + "from pyquil.gate_matrices import X, Y, Z, H, CNOT, CZ\n", + "from forest.benchmarking.superoperator_tools import *\n", + "from forest.benchmarking.utils import n_qubit_pauli_basis\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define some quantum states" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Single qubit quantum states" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "ZERO = np.array([[1, 0], [0, 0]])\n", + "ONE = np.array([[0, 0], [0, 1]])\n", + "\n", + "plus = np.array([[1], [1]]) / np.sqrt(2)\n", + "minus = np.array([[1], [-1]]) / np.sqrt(2)\n", + "PLUS = plus @ plus.T.conj()\n", + "MINUS = minus @ minus.T.conj()\n", + "\n", + "plusy = np.array([[1], [1j]]) / np.sqrt(2)\n", + "minusy = np.array([[1], [-1j]]) / np.sqrt(2)\n", + "PLUSy = plusy @ plusy.T.conj()\n", + "MINUSy = minusy @ minusy.T.conj()\n", + "\n", + "MIXED = np.eye(2)/2\n", + "\n", + "single_qubit_states = [('0',ZERO),('1',ONE),('+',PLUS),('-',MINUS),('+i',PLUSy),('-i',MINUSy)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Two qubit quantum states" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "P00 = np.kron(ZERO, ZERO)\n", + "P01 = np.kron(ZERO, ONE)\n", + "P10 = np.kron(ONE, ZERO)\n", + "P11 = np.kron(ONE, ONE)\n", + "\n", + "bell = 1/np.sqrt(2) * np.array([[1, 0, 0, 1]])\n", + "BELL = np.outer(bell, bell)\n", + "\n", + "two_qubit_states = [('00',P00), ('01',P01), ('10',P10), ('11',P11),('BELL',BELL)]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Two types of Pauli Representation of a quantum state" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# convert to pauli basis\n", + "n_qubits = 1\n", + "pl_basis_oneq = n_qubit_pauli_basis(n_qubits)\n", + "c2p_oneq = computational2pauli_basis_matrix(2*n_qubits)\n", + "oneq_states_pl = [ (state[0], np.real(c2p_oneq@vec(state[1]))) for state in single_qubit_states]\n", + "\n", + "n_qubits = 2\n", + "pl_basis_twoq = n_qubit_pauli_basis(n_qubits)\n", + "c2p_twoq = computational2pauli_basis_matrix(2*n_qubits)\n", + "twoq_states_pl = [ (state[0], np.real(c2p_twoq@vec(state[1]))) for state in two_qubit_states]" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "from forest.benchmarking.plotting.state_process import plot_pauli_rep_of_state, plot_pauli_bar_rep_of_state" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Single Qubit states" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# can plot vertically\n", + "fig, ax = plt.subplots(1)\n", + "plot_pauli_rep_of_state(oneq_states_pl[0][1], ax, pl_basis_oneq.labels, 'State is |0>')" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAADDCAYAAAB57FEpAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAFRlJREFUeJzt3XuYHFWZx/HvbyaEW5AkBlmEQMgKBMxqRERhoyCCEH0WREFUXEHxAsjjsqwXWHYV4VFW1NUVV8EriMtFUHejrEAggeWqRAMJiNyCBiFyCQRIgCjT7/5Rp2dqenpmuqerp2dqfp/nabrOqTqn3jrpfqk5XV2tiMDMzMqlq9MBmJlZ8ZzczcxKyMndzKyEnNzNzErIyd3MrISc3M3MSsjJ3cyshJzcbcKRtL2kdZK6m2w3S9Lv2xSWWaGc3G1USJov6SZJT0l6QtKNkl6T1h0t6YYm+polKSRNGkksEbEqIqZERM9I2puNB07u1naSXgT8HDgbmA5sC3wW2NDJuIo01Fm9pOmSNhrlkGyCc3K30bAzQERcFBE9EfFcRFwVEcsl7QqcA+yVpkrWAkh6q6Rlkp6W9KCk03L9/V96Xpva7JXafEDSXZKelHSlpB3qBVN75p/+clgp6RlJD0g6suDjPwD4o6QvS5pbcN9mdTm522i4B+iRdL6kBZKmVVdExF3AscDNaapkalq1HngfMBV4K3CcpLeldW9Iz1NTm5slHQL8M/B2YCvgeuCi4QKTtDnwNWBBRGwB7A3c1uLx9hMRlwBvAirAVZJulXR8fhzMiubkbm0XEU8D84EAvg08JmmhpK2HaHNtRKyIiEpELCdL1PsMsZtjgTMj4q6IeAH4PDBvsLP3GhVgrqRNI2J1RNzZ6LE1KiLuiIhPADOB04B9gQckXZymrcwK5eRuoyIl3aMjYjtgLvBS4KuDbS/ptZKWSHpM0lNkyXvGELvYAfgPSWvT1M4TgMjm94eKaz1wROp/taTLJc1p5JgkvSe3v+XA9tVyemxfZ389wArg9hTjXMDz8VY4J3cbdRHxO+A8ssQG2Rl9rQuBhcDMiNiSbF5eQ2z/IPCRiJiae2waETc1EM+VEXEAsA3wO7K/Lho5jgur+wJeAayq2f+q6raSpqS5/cXAb8j+p3NERMyNiDWN7M+sGU7u1naS5kj6J0nbpfJM4N3ALWmTR4DtJE3ONdsCeCIinpe0J/Ce3LrHyKZSZufqzgFOkfTytI8tJR3eQGxbSzokzb1vANalvgsj6SDgYbK/EM4Fto2I4yPi1iL3Y5Y3ouuEzZr0DPBa4CRJU4G1ZJdGfiKtXwzcCfxJUiUiZgDHA1+W9HXgOuBHZB+uEhHPSvoccGO6xPCgiPippCnAxWme/SlgEXDpMLF1AScBPyD7i+A24LiCjrvqbmBORDxccL9mg5J/icmsMZJmAddGxKzORmI2PE/LmJmVkJO7WePWMsQVPmZjiadlzMxKyGfuZmYl1LarZTRpk9DkKe3q3mzE5s0Z8N0iszFj2bJlj0fEVq32077kPnkKk3Y5uF3dm43YjTf+Z6dDMBvUZptt9oci+vG0jJlZCTm5m5mVkJO7mVkJObmbmZWQk7uZWQk5uZuZlZCTu5lZCTm5m5mVkJO7mVkJObmbmZWQk7uZWQk5uZuZlZCTu5lZCTm5m5mVkJO7mVkJNZzcJX2hkTozM+u8Zs7cD6hTt6CoQMzMrDjD/hKTpOOA44HZkpbnVm0B3NiuwMzMbOQa+Zm9C4FfAGcCJ+fqn4mIJ9oSlZmZtWTY5B4RTwFPAe+W1A1sndpNkTQlIla1OUYzM2tSwz+QLekE4DTgEaCSqgN4RfFhmZlZKxpO7sCJwC4RsaZdwZiZWTGauVrmQbLpGTMzG+OaOXNfCVwr6XJgQ7UyIv698KjMzKwlzST3VekxOT3MzGyMaji5R8RnASRtFhHPti8kMzNrVTO3H9hL0m+B36XyKyV9o22RmZnZiDXzgepXgQOBNQARcTvwhnYEZWZmrWnqrpAR8WBNVU+BsZiZWUGa+UD1QUl7AyFpI+AfgLvaE5aZmbWimTP3Y4GPAtsCDwHzUtnMzMaYZq6WeRw4so2xmJlZQRq55e8nI+IsSWeT3Uumn4j4WFsiMzOzEWvkzL06r760nYGYmVlxGrnl78/S8/ntD8fMzIrQzJeYFkmamitPk3Rle8IyM7NWNHO1zFYRsbZaiIgngZcUH5KZmbWqmeTeI2n7akHSDtT5gNXMzDqvmS8xnQrcIOk6QMDrgQ+3JSozM2tJM9e5XyFpd+B1qerEdO27mZmNMcNOy0iak553B7YHHk6P7VOdmZmNMY2cuZ9ENv3y5TrrAtiv0IjMzKxljST3Ren5mIhY2c5gzMysGI1cLXNKer6snYGYmVlxGjlzf0LSVcBsSQtrV0bEwcWHZWZmrWgkub8F2B24gPrz7mZmNsY0kty/GxF/L+nbEXFd2yMyM7OWNTLn/mpJLwWOTPeTmZ5/tDtAMzNrXiNn7ucA1wCzgV+TfTu1KlK9mZmNIcOeuUfE1yJiV+B7ETE7InbMPZzYzczGoIZvHBYRx0maL+n9AJJmSNqxfaGZmdlINXM/988An6LvuvfJwA/bEZSZmbWmmVv+HgocDKwHiIiHgS3aEZSZmbWmmeT+54gI0j3cJW3enpDMzKxVzST3H0k6F5gq6UPA1cC32xOWmZm1opn7uX9J0gHA08AuwKcjYtEwzczMrAOa+SUmgOXAxmn59oJjMTOzgjRztcw7gV8BhwPvBH4p6bB2BWZmZiPX7G+oviYiHgWQtBXZvLtvBWxmNsY084FqVzWxJ2uabG9mZqOkmTP3KyRdCVyUykcA/1t8SGZm1qphk7uklwFbR8QnJL0dmJ9W3Qz8VzuDMzOzkWnkzP2rpFsORMRPgJ8ASPqbtO7v2hadmZmNSCNz5ltHxIraylQ3q/CIzMysZY0k96lDrNu0qEDMzKw4jST3pel2A/1I+iDZj3eYmdkY08ic+4nATyUdSV8y34Pslr+HtiswMzMbuWGTe0Q8Auwt6Y3A3FR9eUQsbmtkZmY2Ys3cOGwJsKSNsZiZWUH8DVMzsxJycjczKyEndzOzEnJyNzMrISd3M7MScnI3MyshJ3czsxJycjczKyEndzOzEnJyNzMrISd3M7MScnI3MyshRUR7OpYeA/7Qls6LNQN4vNNBlIjHs1gez+KMl7HcISK2arWTtiX38ULS0ojYo9NxlIXHs1gez+JMtLH0tIyZWQk5uZuZlZCTO3yr0wGUjMezWB7P4kyosZzwc+5mZmXkM3czsxJycjczK6EJn9wlret0DOOdpJmSHpA0PZWnpfKszkY2Pilzg6QFubrDJV3RybjGI0mHSrqt5lHJj21ZTfg5d0nrImJKp+MY7yR9EnhZRHxY0rnA7yPizE7HNV5JmgtcCrwKmAQsAw6KiPs7Gtg4J+nDwJHAGyOi0ul42snJ3cm9EJI2An4NfA/4EDAvIv7S2ajGN0lnAeuBzYFnIuKMDoc0rknaGVgM7B0RqzodT7s5uTu5F0bSgcAVwJsjYlGn4xnvJG0O/Ab4M7BHRGzocEjjVjr5uBn4YkRc0ul4RsOkTgdgpbIAWA3MBZzcWxQR6yVdAqxzYm/ZGcCdEyWxg5O7FUTSPOAA4HXADZIujojVHQ6rDCrpYSMkaV/gHcDuHQ5lVE34q2WsdZIEfBM4Mc1lfhH4UmejMsuu3AK+D7wvIp7pdDyjycndivAhYFVunv0bwK6S9ulgTGYAxwIvAb5ZcznkEZ0OrN0m/AeqZmZl5DN3M7MScnI3MyshJ3czsxJycjczKyEndzOzEnJyt1EjqSddhnaHpEslbTbCfk6T9PG0fLqk/etsI0n/IuleSfdIWiLp5a0eQwOxzZP0lnbvx2w4Tu42mp6LiHkRMZfsfinHttphRHw6Iq6us+qjwN7AKyNiZ+BMYKGkTVrdp6Shvtk9D2gquQ/Tn9mIOLlbp1wPvAxA0n9L+rWkO9MtWUn163LLh0k6r7YTSedJOqxO/58CToiIZwEi4irgJrLbvSJpnaSvpH1eI2mrVP/Xkq5I8VwvaU5uP+dI+iVwlqQ9Jd0saZmkmyTtImkycDpwRPWLMpKmp+NbLukWSa9I/Z0m6QJJNwIXtD6cZv35jMFGXTpTXUB2B0mAD0TEE5I2BW6V9OOIWNNC/y8CNo+IlTWrlgLVqZnNgaUR8Y+SPg18BjiB7EeUj42IeyW9luzbtvulNtuR3S62J+3j9RHxQpoW+nxEvCP1tUdEnJBiORtYFhFvk7Qf8AOys3uA3YD5EfHcSI/VbDBO7jaaNpV0W1q+HvhuWv6YpEPT8kxgJ2DEyb1BFaB6h8AfAj+RNIVsKufS7HY5AGyca3NpRPSk5S2B8yXtBASw0SD7mU920yoiYrGkF6f/MQAsdGK3dnFyt9H0XETMy1ekO/btD+wVEc9Kuhaozovn743R8Fx5RDwtab2k2TVn768GrhusGdk05draGHPW55bPAJZExKHp5wSvbTS+QfozK5Tn3K3TtgSeTIl9Dtktg6sekbSrpC7g0PrNB/VF4Gtpqoc0dTIfuDCt7wKqc/XvAW6IiKeBByQdntpI0iuHiPuhtHx0rv4ZYItc+Xr65vn3BR5P+zFrKyd367QrgEmS7gL+Dbglt+5k4OdkH4Q2e2/4s4FbgRWS7gb+FTgkNw2yHthT0h1kc+qnp/ojgWMk3Q7cCRwySP9nAWdKWkb/v4CXALvl7jx4GvBqScvT8R3V5HGYjYjvCmkTkn9e0crOZ+5mZiXkM3czsxLymbuZWQk5uZuZlZCTu5lZCTm5m5mVkJO7mVkJObmbmZWQk7uZWQk5uZuZlZCTu5lZCTm5m5mVkJO7mVkJObmbmZWQk7uZWQk5uZuZlZCTu5lZCbXtB7JnatPYQAWA6u/IK1dQ76L6b9P7o/P5bfqv6+tPg9TXtunboLeY25FqGuSbVBsNvU2q61fui6/vQPLxitoBUW9dzX6qjfJj03vQqlPXF4RqjrVOkIPEUNsm37f67aN/v6pzLANj7d9//3LU9penmnJtXHW37V8f1fro/Q/5pX6/cBB16oDan0EY7FcRghi8j9xC5GqiXx01dTGgrm7sEYO0Hxhb9DXpq89tnz/WIPqXa9pE7bGmOPrV1x5H9H+uPaja6t7Wtf8GNf8oUWcABvY1sF21Yd+/XQys73cw0e94+++8Gmv/Qeu/fU3/z625MiIOokVtS+7PU+Gd2gaAbolu9T3X1kH2J8RQ6/PtG9mmur5LQqmiq1uouwt1i65Up66uVJ/K3ancVW2Tbd/XR2rflfXV129NuUt0pXJ1nbq6cn109atTd3e2795y7fquFFtXb9y123SlPlRnm95yVzd0dWcD1NWFuvPl7qyv3DYDyt3dUK2D1F/qN/UxZL9ZI1AXoa5cWVm/kNXnH/3q1Nsm1NXbZsjta+qqyT0CKrk3WiWyN3ol997trUvbZG36EkIl10//NqnPlAzr12UVPZVsuafaZ0RvHUBPiqmnErm66na5Nrk+K5X+5Z6IunU9lb4+qsvDlV+orYt6bSoD2tT2mW8TlSy+bIxrypX0b9BbTuvTdtW6SiV6/12iko1Bv/WDbF+ty7bvISo9aZseoqemXLO+UlvXM3CbqFQGtukZ2Gd1m7/c9v0ZFMDTMmZmJeTkbmZWQk7uZmYl5ORuZlZCTu5mZiXk5G5mVkJO7mZmJeTkbmZWQk7uZmYl5ORuZlZCTu5mZiXk5G5mVkJO7mZmJeTkbmZWQk7uZmYlpAE3qi+qY+kO4Pm2dD4xzQAe73QQJeLxLJbHszibRMTcVjtp2491AM9HxB5t7H9CkbTU41kcj2exPJ7FkbS0iH48LWNmVkJO7mZmJdTO5P6tNvY9EXk8i+XxLJbHsziFjGXbPlA1M7PO8bSMmVkJtZTcJU2XtEjSvel52iDb9Ui6LT0W5up3lPRLSfdJukTS5FbiGe8aGU9J8yTdLOlOScslHZFbd56kB3JjPW90j6DzJB0k6e70mjq5zvqN02vtvvTam5Vbd0qqv1vSgaMZ91jVwHieJOm36bV4jaQdcuvqvu8nsgbG82hJj+XG7YO5dUel3HCvpKOG3VlEjPgBnAWcnJZPBr4wyHbrBqn/EfCutHwOcFwr8Yz3RyPjCewM7JSWXwqsBqam8nnAYZ0+jg6OXzdwPzAbmAzcDuxWs83xwDlp+V3AJWl5t7T9xsCOqZ/uTh/TOBjPNwKbpeXjquOZynXf9xP10eB4Hg18vU7b6cDK9DwtLU8ban+tTsscApyfls8H3tZoQ0kC9gMuG0n7khp2PCPinoi4Ny0/DDwKbDVqEY5tewL3RcTKiPgzcDHZmOblx/gy4E3ptXgIcHFEbIiIB4D7Un8T2bDjGRFLIuLZVLwF2G6UYxxPGnl9DuZAYFFEPBERTwKLgIOGatBqct86Ilan5T8BWw+y3SaSlkq6RVI1Yb0YWBsRL6TyH4FtW4xnvGt0PAGQtCfZGcD9uerPpT+RvyJp4zbFOVZtCzyYK9d7TfVuk157T5G9FhtpO9E0OybHAL/Ileu97yeyRsfzHek9fJmkmU227TXsN1QlXQ38VZ1Vp+YLERGSBrv0ZoeIeEjSbGCxpBVkb6oJp6DxRNI2wAXAURFRSdWnkP1PYTLZ5VSfAk4vIm6zoUh6L7AHsE+uesD7PiLur9+DJT8DLoqIDZI+QvZX5n4j6WjY5B4R+w+2TtIjkraJiNUp2Tw6SB8PpeeVkq4FXgX8GJgqaVI6g9oOeGgExzCuFDGekl4EXA6cGhG35PqunvVvkPR94OMFhj4ePATMzJXrvaaq2/xR0iRgS2BNg20nmobGRNL+ZCcn+0TEhmr9IO/7iZzchx3PiFiTK36H7HO4att9a9peO9TOWp2WWQhUP7U9Cvif2g0kTatOD0iaAfwt8NvIPiVYAhw2VPsJppHxnAz8FPhBRFxWs26b9Cyy+fo72hrt2HMrsFO6Cmsy2QemtVdp5Mf4MGBxei0uBN6VrqbZEdgJ+NUoxT1WDTuekl4FnAscHBGP5urrvu9HLfKxqZHx3CZXPBi4Ky1fCbw5jes04M2pbnAtfvr7YuAa4F7gamB6qt8D+E5a3htYQfbJ8ArgmFz72WRvoPuAS4GNO/2JdicfDY7ne4G/ALflHvPSusVpjO8AfghM6fQxdWAM3wLcQ3aGeGqqO50s+QBskl5r96XX3uxc21NTu7uBBZ0+lrHwaGA8rwYeyb0WF6b6Qd/3E/nRwHieCdyZxm0JMCfX9gPpdXsf8P7h9uVvqJqZlZC/oWpmVkJO7mZmJeTkbmZWQk7uZmYl5ORuZlZCTu5mZiXk5G5mVkJO7mZmJfT/2WikiNeoiFUAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# or can plot horizontally\n", + "for state in oneq_states_pl:\n", + " fig, ax = plt.subplots(1)\n", + " plot_pauli_rep_of_state(state[1].transpose(), ax, pl_basis_oneq.labels, 'State is |'+state[0]+'>')" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "for state in oneq_states_pl:\n", + " fig, ax = plt.subplots(1)\n", + " plot_pauli_bar_rep_of_state(state[1].flatten(), ax, pl_basis_oneq.labels, 'State is |'+state[0]+'>')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Two qubit states" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# can plot vertically \n", + "fig, ax = plt.subplots(1)\n", + "plot_pauli_rep_of_state(twoq_states_pl[0][1], ax, pl_basis_twoq.labels, 'State is |0>')\n", + "# can plot horizontially\n", + "fig, ax = plt.subplots(1)\n", + "plot_pauli_rep_of_state(twoq_states_pl[0][1].transpose(), ax, pl_basis_twoq.labels, 'State is |0>')\n", + "fig, ax = plt.subplots(1)\n", + "plot_pauli_rep_of_state(twoq_states_pl[-1][1].transpose(), ax, pl_basis_twoq.labels, 'State is BELL')" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Also bar plots \n", + "fig, ax = plt.subplots(1)\n", + "plot_pauli_bar_rep_of_state(twoq_states_pl[-1][1].flatten(), ax, pl_basis_twoq.labels, 'State is BELL')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Plot a Quantum Process as a Pauli Transfer Matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "Xpl = kraus2pauli_liouville(X)\n", + "Hpl = kraus2pauli_liouville(H)\n", + "from forest.benchmarking.plotting.state_process import plot_pauli_transfer_matrix" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "f, (ax1) = plt.subplots(1, 1, figsize=(5, 4.2))\n", + "plot_pauli_transfer_matrix(np.real(Xpl), ax1, pl_basis_oneq.labels, 'X gate')\n", + "\n", + "f, (ax1) = plt.subplots(1, 1, figsize=(5, 4.2))\n", + "plot_pauli_transfer_matrix(np.real(Hpl), ax1, pl_basis_oneq.labels, 'H gate')" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "CNOTpl = kraus2pauli_liouville(CNOT)\n", + "CZpl = kraus2pauli_liouville(CZ)\n", + "\n", + "f, (ax1) = plt.subplots(1, 1, figsize=(5, 4.2))\n", + "plot_pauli_transfer_matrix(np.real(CNOTpl), ax1, pl_basis_twoq.labels, 'CNOT')\n", + "f, (ax1) = plt.subplots(1, 1, figsize=(5, 4.2))\n", + "plot_pauli_transfer_matrix(np.real(CZpl), ax1, pl_basis_twoq.labels, 'CZ')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Hinton Plots for states and processes" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The warning here is the `hinton_real` function only works for plotting a real matrix so the user has to be careful. It will take the absolute value of complex numbers." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize a real state in the computational basis" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from forest.benchmarking.utils import n_qubit_computational_basis\n", + "from forest.benchmarking.plotting.hinton import hinton_real\n", + "oneq = n_qubit_computational_basis(1)\n", + "oneq_latex_labels = [r'$|{}\\rangle$'.format(''.join(j)) for j in oneq.labels]\n", + "\n", + "_ = hinton_real(ZERO, max_weight=1.0, xlabels=oneq_latex_labels, ylabels=oneq_latex_labels, ax=None, title='|0>')\n", + "_ = hinton_real(PLUS, max_weight=1.0, xlabels=oneq_latex_labels, ylabels=oneq_latex_labels, ax=None, title='|+>')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Visualize a Process Pauli basis\n", + "The Pauli representation is real so we can plot any process" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "_ = hinton_real(Xpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels, ax=None, title='X gate')\n", + "_ = hinton_real(Hpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels, ax=None, title='H gate')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "So far things look the same as the `plot_pauli_transfer_matrix` but we can plot using the traditional Hinton diagram colors, now the size of the squares makes a difference." + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from matplotlib import cm\n", + "_ = hinton_real(Hpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels,cmap = cm.Greys_r, ax=None, title='Good H gate')\n", + "_ = hinton_real(Hpl-0.3, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels, cmap = cm.Greys_r, ax=None, title='Bad H gate')" + ] + } + ], + "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.6.3" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} From 2de6c06dcb8df46b067856d1bd278ba85dc89475 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 15:57:34 +1000 Subject: [PATCH 12/20] delete code from tomography module --- forest/benchmarking/tomography.py | 29 ----------------------------- 1 file changed, 29 deletions(-) diff --git a/forest/benchmarking/tomography.py b/forest/benchmarking/tomography.py index 2e81f7b6..5e2d2f17 100644 --- a/forest/benchmarking/tomography.py +++ b/forest/benchmarking/tomography.py @@ -802,32 +802,3 @@ def estimate_variance(results: List[ExperimentResult], return np.mean(sample_estimate), np.var(sample_estimate) - -THREE_COLOR_MAP = ['#48737F', '#FFFFFF', '#D6619E'] -rigetti_3_color_cm = LinearSegmentedColormap.from_list("Rigetti", THREE_COLOR_MAP[::-1], N=100) - - -def plot_pauli_transfer_matrix(ptransfermatrix, ax, title = ''): - """ - Visualize the Pauli Transfer Matrix of a process. - :param numpy.ndarray ptransfermatrix: The Pauli Transfer Matrix - :param ax: The matplotlib axes. - :param labels: The labels for the operator basis states. - :param title: The title for the plot - :return: The modified axis object. - :rtype: AxesSubplot - """ - im = ax.imshow(np.real(ptransfermatrix), interpolation="nearest", cmap=rigetti_3_color_cm, vmin=-1,vmax=1) - dim_squared = ptransfermatrix.shape[0] - num_qubits = np.int(np.log2(np.sqrt(dim_squared))) - labels = [''.join(x) for x in itertools.product('IXYZ', repeat=num_qubits)] - plt.colorbar(im, ax=ax) - ax.set_xticks(range(dim_squared)) - ax.set_xlabel("Input Pauli Operator", fontsize=20) - ax.set_yticks(range(dim_squared)) - ax.set_ylabel("Output Pauli Operator", fontsize=20) - ax.set_title(title, fontsize=25) - ax.set_xticklabels(labels, rotation=45) - ax.set_yticklabels(labels) - ax.grid(False) - return ax From f9803b6a08b31839bd77a46fd8a44999aa2958ec Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 15:58:43 +1000 Subject: [PATCH 13/20] *harmonized the best of the old plotting code with the best for the new plotting code * include rigetti color map in the plotting module --- forest/benchmarking/plotting/state_process.py | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) diff --git a/forest/benchmarking/plotting/state_process.py b/forest/benchmarking/plotting/state_process.py index 28ce4dcb..72db05d9 100644 --- a/forest/benchmarking/plotting/state_process.py +++ b/forest/benchmarking/plotting/state_process.py @@ -1,6 +1,9 @@ import matplotlib.pyplot as plt import numpy as np +THREE_COLOR_MAP = ['#48737F', '#FFFFFF', '#D6619E'] +rigetti_3_color_cm = LinearSegmentedColormap.from_list("Rigetti", THREE_COLOR_MAP[::-1], N=100) + def plot_pauli_rep_of_state(state_pl_basis, ax, labels, title): """ @@ -79,7 +82,7 @@ def plot_pauli_bar_rep_of_state(state_pl_basis, ax, labels, title): ax.grid(False) -def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): +def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title, fontsizes: int = 20): """ Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer Matrix) of the process. @@ -88,6 +91,9 @@ def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): :param ax: The matplotlib axes. :param labels: The labels for the operator basis states. :param title: The title for the plot + :param fontsizes: Font size for axis labels + :return: The modified axis object. + :rtype: AxesSubplot """ im = ax.imshow(ptransfermatrix, interpolation="nearest", cmap="RdBu", vmin=-1, vmax=1) dim = len(labels) @@ -96,10 +102,11 @@ def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title): cb.ax.set_yticklabels(ticklabs, ha='right') cb.ax.yaxis.set_tick_params(pad=35) ax.set_xticks(range(dim)) - ax.set_xlabel("Input Pauli Operator") + ax.set_xlabel("Input Pauli Operator", fontsize=fontsizes) ax.set_yticks(range(dim)) - ax.set_ylabel("Output Pauli Operator") - ax.set_title(title) + ax.set_ylabel("Output Pauli Operator", fontsize=fontsizes) + ax.set_title(title, int(floor(1.2*fontsizes)) ax.set_xticklabels(labels, rotation=45) ax.set_yticklabels(labels) - ax.grid(False) \ No newline at end of file + ax.grid(False) + return ax \ No newline at end of file From 809658113f61a0b95e080f9f713e6b8215b534a0 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 16:00:43 +1000 Subject: [PATCH 14/20] one braket to rule them all --- forest/benchmarking/plotting/state_process.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/forest/benchmarking/plotting/state_process.py b/forest/benchmarking/plotting/state_process.py index 72db05d9..3ddf3732 100644 --- a/forest/benchmarking/plotting/state_process.py +++ b/forest/benchmarking/plotting/state_process.py @@ -105,7 +105,7 @@ def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title, fontsizes: in ax.set_xlabel("Input Pauli Operator", fontsize=fontsizes) ax.set_yticks(range(dim)) ax.set_ylabel("Output Pauli Operator", fontsize=fontsizes) - ax.set_title(title, int(floor(1.2*fontsizes)) + ax.set_title(title, int(floor(1.2*fontsizes))) ax.set_xticklabels(labels, rotation=45) ax.set_yticklabels(labels) ax.grid(False) From d1102e5f2605e633cb8d9efddf1758c8e5a0139c Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 16:18:30 +1000 Subject: [PATCH 15/20] small improvements --- forest/benchmarking/plotting/state_process.py | 17 ++++++++++++----- forest/benchmarking/tomography.py | 3 --- 2 files changed, 12 insertions(+), 8 deletions(-) diff --git a/forest/benchmarking/plotting/state_process.py b/forest/benchmarking/plotting/state_process.py index 3ddf3732..e1b52e95 100644 --- a/forest/benchmarking/plotting/state_process.py +++ b/forest/benchmarking/plotting/state_process.py @@ -1,5 +1,6 @@ import matplotlib.pyplot as plt import numpy as np +from matplotlib.colors import LinearSegmentedColormap THREE_COLOR_MAP = ['#48737F', '#FFFFFF', '#D6619E'] rigetti_3_color_cm = LinearSegmentedColormap.from_list("Rigetti", THREE_COLOR_MAP[::-1], N=100) @@ -82,7 +83,7 @@ def plot_pauli_bar_rep_of_state(state_pl_basis, ax, labels, title): ax.grid(False) -def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title, fontsizes: int = 20): +def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels=None, title='', fontsizes: int = 20): """ Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer Matrix) of the process. @@ -96,16 +97,22 @@ def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels, title, fontsizes: in :rtype: AxesSubplot """ im = ax.imshow(ptransfermatrix, interpolation="nearest", cmap="RdBu", vmin=-1, vmax=1) - dim = len(labels) + if labels is None: + dim_squared = ptransfermatrix.shape[0] + num_qubits = np.int(np.log2(np.sqrt(dim_squared))) + labels = [''.join(x) for x in itertools.product('IXYZ', repeat=num_qubits)] + else: + dim_squared = len(labels) + cb = plt.colorbar(im, ax=ax, ticks=[-1, -3 / 4, -1 / 2, -1 / 4, 0, 1 / 4, 1 / 2, 3 / 4, 1]) ticklabs = cb.ax.get_yticklabels() cb.ax.set_yticklabels(ticklabs, ha='right') cb.ax.yaxis.set_tick_params(pad=35) - ax.set_xticks(range(dim)) + ax.set_xticks(range(dim_squared)) ax.set_xlabel("Input Pauli Operator", fontsize=fontsizes) - ax.set_yticks(range(dim)) + ax.set_yticks(range(dim_squared)) ax.set_ylabel("Output Pauli Operator", fontsize=fontsizes) - ax.set_title(title, int(floor(1.2*fontsizes))) + ax.set_title(title, fontsize= int(np.floor(1.2*fontsizes))) ax.set_xticklabels(labels, rotation=45) ax.set_yticklabels(labels) ax.grid(False) diff --git a/forest/benchmarking/tomography.py b/forest/benchmarking/tomography.py index 5e2d2f17..093bb6cf 100644 --- a/forest/benchmarking/tomography.py +++ b/forest/benchmarking/tomography.py @@ -4,9 +4,7 @@ from operator import mul from typing import Callable, Tuple, List, Optional, Union, Sequence -import matplotlib.pyplot as plt import numpy as np -from matplotlib.colors import LinearSegmentedColormap from scipy.linalg import logm, pinv, eigh import forest.benchmarking.distance_measures as dm @@ -801,4 +799,3 @@ def estimate_variance(results: List[ExperimentResult], sample_estimate.append(np.real(functional(target_state, rho))) return np.mean(sample_estimate), np.var(sample_estimate) - From 4fdcddbe87b90c94ce3bd3fda7dbe42cd6216075 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Tue, 7 May 2019 16:26:41 +1000 Subject: [PATCH 16/20] more tweaks --- examples/tomography_process.ipynb | 28 +++++++++++++++++-- forest/benchmarking/plotting/state_process.py | 6 ++-- 2 files changed, 28 insertions(+), 6 deletions(-) diff --git a/examples/tomography_process.ipynb b/examples/tomography_process.ipynb index 0eb40952..1cd7116e 100644 --- a/examples/tomography_process.ipynb +++ b/examples/tomography_process.ipynb @@ -130,13 +130,35 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'process_choi_ideal' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m--------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 5\u001b[0m \u001b[0mfig\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0max1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msubplots\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mfigsize\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m12\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 6\u001b[0;31m \u001b[0mplot_pauli_transfer_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchoi2pauli_liouville\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocess_choi_ideal\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Ideal'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 7\u001b[0m \u001b[0mplot_pauli_transfer_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mchoi2pauli_liouville\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mprocess_choi_est\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0max2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtitle\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;34m'Estimate'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 8\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtight_layout\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'process_choi_ideal' is not defined" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "import matplotlib.pyplot as plt\n", "from forest.benchmarking.superoperator_tools import choi2pauli_liouville\n", - "from forest.benchmarking.tomography import plot_pauli_transfer_matrix\n", + "from forest.benchmarking.plotting.state_process import plot_pauli_transfer_matrix\n", "\n", "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12,5))\n", "plot_pauli_transfer_matrix(choi2pauli_liouville(process_choi_ideal), ax1, title='Ideal')\n", diff --git a/forest/benchmarking/plotting/state_process.py b/forest/benchmarking/plotting/state_process.py index e1b52e95..9ac64fe6 100644 --- a/forest/benchmarking/plotting/state_process.py +++ b/forest/benchmarking/plotting/state_process.py @@ -83,7 +83,7 @@ def plot_pauli_bar_rep_of_state(state_pl_basis, ax, labels, title): ax.grid(False) -def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels=None, title='', fontsizes: int = 20): +def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels=None, title='', fontsizes: int = 16): """ Visualize a quantum process using the Pauli-Liouville representation (aka the Pauli Transfer Matrix) of the process. @@ -113,7 +113,7 @@ def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels=None, title='', fonts ax.set_yticks(range(dim_squared)) ax.set_ylabel("Output Pauli Operator", fontsize=fontsizes) ax.set_title(title, fontsize= int(np.floor(1.2*fontsizes))) - ax.set_xticklabels(labels, rotation=45) - ax.set_yticklabels(labels) + ax.set_xticklabels(labels, rotation=45, fontsize=int(np.floor(0.7*fontsizes))) + ax.set_yticklabels(labels, fontsize=int(np.floor(0.7*fontsizes))) ax.grid(False) return ax \ No newline at end of file From dad3abdc67c8de798a31cf46654f1f99c27d1fb0 Mon Sep 17 00:00:00 2001 From: Kyle Date: Wed, 8 May 2019 12:56:21 -0400 Subject: [PATCH 17/20] Strip notebook, whitespace edits. --- examples/state_and_process_plots.ipynb | 347 ++---------------- forest/benchmarking/plotting/hinton.py | 1 - forest/benchmarking/plotting/state_process.py | 2 +- 3 files changed, 28 insertions(+), 322 deletions(-) diff --git a/examples/state_and_process_plots.ipynb b/examples/state_and_process_plots.ipynb index 76d9d8a3..2be341f0 100644 --- a/examples/state_and_process_plots.ipynb +++ b/examples/state_and_process_plots.ipynb @@ -16,7 +16,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -46,7 +46,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -77,7 +77,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -101,7 +101,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -119,7 +119,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -135,20 +135,9 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# can plot vertically\n", "fig, ax = plt.subplots(1)\n", @@ -157,70 +146,9 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# or can plot horizontally\n", "for state in oneq_states_pl:\n", @@ -230,70 +158,9 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "for state in oneq_states_pl:\n", " fig, ax = plt.subplots(1)\n", @@ -309,40 +176,9 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# can plot vertically \n", "fig, ax = plt.subplots(1)\n", @@ -356,20 +192,9 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "# Also bar plots \n", "fig, ax = plt.subplots(1)\n", @@ -385,7 +210,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "metadata": {}, "outputs": [], "source": [ @@ -396,30 +221,9 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUkAAAEeCAYAAAAHAefnAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4wLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvpW3flQAAIABJREFUeJzt3Xm4HVWd7vHvewIBaUTAIDIECBoHUDpCBBVbEVHxqoAt2igiIlxahVbxikDTF2kUiFPj1UY0rQwqCopT6MbmMiqCCkEQZWoiY9IoBpBBZEjy9h9VG4vD2XvXGfbeZ+/9fp6nnlO1alirTuB31lpVa5VsExERYxvpdQEiIqazBMmIiBYSJCMiWkiQjIhoIUEyIqKFBMmIiBYSJCMiWkiQHGKS1pZ0q6S9K2lPlXS7pD07kN+pkj4x1deN6KQEySFm+0Hg74HPSdqgTP4UsNj2Wb0rWcT0kSA55GyfC/wH8HlJOwFvA97f7HhJcyT9RNIDks6XdKKkb1T2f0fS7yTdVx63dZl+ILA38FFJD0o6u0zfWNJ3Jf1B0i2SPtDB240YtwTJADgE2Ak4C/iI7d+1OPabwOXA04GjgX1G7f8RMBd4BvBL4HQA2wvL9U/ZXtv2mySNAGcDvwI2AV4NfEjS66bmtiImTxm7HQCSzgdeBmxk+74mx2wG3AysY/uhMu0bALbfOcbx6wL3Auvavk/SqcBS2/9U7t8B+I7tzSrnHAE8x/Z+U3l/EROVmmQg6Z3AFsD5wCdbHLoxcE8jQJbuqFxnhqQFkn4r6X7g1nLXrCbX2xzYWNIfGwvwj8CGE7uTiKm3Wq8LEL0l6RnACRR9kTcA10o63fYlYxx+J7C+pLUqgXJ2Zf87gN2BXSgC5NMoapIq949uttwB3GJ77lTcS0QnpCYZ/wr8wPZFtu8EPgr8m6Q1Rh9o+zZgMXC0pJmSXgq8qXLIU4FHgLuBtYDjRl3i98CWle3LgQckHSbpKWVN9AWSXjxldxcxSQmSQ0zSHsDLgUMbaba/Avw3cFST0/YGXkoRCD8BnEkRGAG+BtwGLAOuA34+6tyvAluVTesf2F4JvBGYB9wCLAe+QlEDjZgW8uAmJkXSmcANtj/W67LEcJB0MsUf17tsv2CM/QL+H/C/gIeAd9v+ZblvX+CfykM/Yfu0dvmlJhnjIunFkp4laUTSrhR9kD/odbliqJwK7Npi/+spXkObCxwInAQgaX3gY8AOwPbAxySt1y6zBMkYr2cCFwMPAp8H3mf7qp6WKIaK7Z8A97Q4ZHfgay78HFhX0kbA64DzbN9j+17gPFoHWyBPt2OcbJ9N8QJ4BCPrbGpWPFz7eP/57muB6gkLy4EGU2kTKq+mAUvLtGbpLSVIRsTErXiY1Z67W+3DH7v6lIdtz+9giaZcgmRETJzEyGoze12K0ZbxxPd3Ny3TllEMv62mX9zuYtMqSGq1Na2Za/e6GB0z73mbtT8oogduv/12li9frvZHjiY0MmPqCzQ5i4CDJZ1B8ZDmPtt3SjoXOK7ysOa1wBHtLja9guTMtcdVde83l156Yq+LEDGmHXfccWInqvtBUtK3KGqEsyQtpXhivTqA7S8B51C8/rOE4hWg/cp990j6OHBFealjbLd6AARMsyAZEf1FgGZ0N0jafnub/QYOarLvZODk8eSXIBkREycxMv2a21MqQTIiJmUa9klOqQTJiJi4HvRJdluCZERMmACNDPbAvQTJiJg4jUzH9ySnVIJkRExKmtsREc1IXX8FqNsSJCNiwoo+yQTJiIix5el2REQreZk8IqI5pbkdEdGUpucsQFMqQTIiJm56zic5pRIkI2ISUpOMiGhO3Z8qrdsSJCNiwtInGRHRSt6TjIhoLUEyIqKFkZEJfD+sjwz2RHAR0VGS0Ej9ZQrz3VXSjZKWSDp8jP0nSLq6XP5L0h8r+1ZW9i1ql1dqkhExKTNmdLeuJWkGcCLwGmApcIWkRbavaxxj+5DK8f8AvKhyiT/bnlc3v67dnaQHu5VXRHSJ6EVNcntgie2bbT8KnAHs3uL4twPfmmhmaW5HxIQVU6V1PUhuAtxR2V5apj25fNLmwBzgwkrympIWS/q5pD3aZZbmdkRMghjRuILfLEmLK9sLbS+c4kJV7QWcZXtlJW1z28skbQlcKOnXtn/b7AIJkhExcWVzexyW254/yVyXAbMr25uWaWPZCziommB7WfnzZkkXU/RXNg2SPW9uSzqwrPou9oqHe12ciBinHjS3rwDmSpojaSZFIHzSU2pJzwPWA35WSVtP0hrl+ixgR+C60edW9bwmWVa1FwKMrDXLPS5ORIyD1P33JG2vkHQwcC4wAzjZ9rWSjgEW224EzL2AM2xX48rzgS9LWkVRSVxQfSo+lp4HyYjob+pBe9T2OcA5o9KOGrV99BjnXQa8cDx5JUhGxIRJ6vp7kt3WtSBpe+1u5RUR3TOVI2mmo9QkI2JSEiQjIpoR431Psu8kSEbEhDVG3AyyBMmImISpnd1nOkqQjIiJ68F7kt2WIBkRk6L0SUZEjK3ok+x1KTorQTIiJk4wY7XBjpIJkhExCUpzOyKimV5McNFtCZIRMSl5BSgiogkJZiRIRkQ0lyAZEdGEUIJkRERTaW5HRDQ3Ilgj70lGRIxNpCYZEdGcBr9PcrDryRHRUUVNcqT2MmX5SrtKulHSEkmHj7H/3ZL+IOnqcjmgsm9fSTeVy77t8kpNMiImpds1SUkzgBOB1wBLgSskLRrj07Bn2j541LnrAx8D5gMGrizPvbdZfqlJRsSENV4mr7tMke2BJbZvtv0ocAawe81zXwecZ/ueMjCeB+za6oQEyYiYsMZ7kuMIkrMkLa4sB04g202AOyrbS8u00d4i6RpJZ0maPc5zHzetmtvznrcZl156Yq+L0TFPe9lBvS5CR9132eD+20VzM8Y3C9By2/M7VZaKs4Fv2X5E0t8DpwE7T+RCqUlGxIRJMHO1kdrLFFkGzK5sb1qmPc723bYfKTe/AmxX99zRWpZa0oikt9UodEQMIQlWG1HtZYpcAcyVNEfSTGAvYNETy6WNKpu7AdeX6+cCr5W0nqT1gNeWaU21bG7bXiXpo8C3x3cPETEMejF22/YKSQdTBLcZwMm2r5V0DLDY9iLgA5J2A1YA9wDvLs+9R9LHKQItwDG272mVX50+yfMlfQQ4E/hTpaAtLxwRw6EXL5PbPgc4Z1TaUZX1I4Ajmpx7MnBy3bzqBMm/K39WnzoY2LJuJhExmDKfJGB7TjcKEhH9J2O3AUmrA+8DXlEmXQx82fZjHSxXRPSD1CQBOAlYHfhiub1PmXZA0zMiYihk0t3Ci23/dWX7Qkm/6lSBIqJ/NN6THGR1guRKSc+y/VsASVsCKztbrIjoB+mTLBwKXCTpZorfyebAezpaqojoD+mTBOCnwFzgueX2jZ0rTkT0E6Hxjt3uO3WC5M9sbwtc00iQ9Etg246VKiL6xsiwBklJz6SYQugpkl5E0dQGWAdYqwtli4hpTsCMwY6RLWuSr6MY77gp8C+V9AeAf+xgmSKiXwhGhrVP0vZpwGmS3mL7u10sU0T0iaImOaRBssH2dyW9AdgaWLOSfkwnCxYR/WFo+yQbJH2Jog/yVRSTV+4JXN7hckVEH5DE6gPeKVnnVfmX2X4XcK/tfwZeCjyns8WKiH4gippk3aUf1XkF6OHy50OSNgbuBjZqcXxEDJEBr0jWCpJnS1oX+DTwS4q5JP+to6WKiL7QqEkOspZBUtIIcIHtPwLflfTvwJq27+tK6SJiehuCYYkt+yRtrwJOrGw/kgAZEQ3D0CdZ58HNBZLeIvXpHUZER81Q/WWqSNpV0o2Slkg6fIz9H5Z0naRrJF0gafPKvpWSri6XRaPPHa1OkPx74DvAo5Lul/SApPvb3MBsSbdIWr/cXq/c3qJGfhHRJ0T9WuRU1SQlzaBo4b4e2Ap4u6StRh12FTDf9jbAWcCnKvv+bHteuezWLr+2QdL2U22P2F7d9jrl9jptzrmDYvbyBWXSAmCh7Vvb5RcR/UOC1Weo9jJFtgeW2L7Z9qPAGcDu1QNsX2T7oXLz5xTDqyekbZBU4Z2S/m+5PVvS9jWufQLwEkkfAl4OfGaihYyI6WuGVHuZIpsAd1S2l5ZpzewP/KiyvaakxZJ+LmmPdpnVeQXoi8AqYGfg48CDFFXdF7c6yfZjkg4F/hN4bbMPh0k6EDgQYPbs2TWKExHTxQReAZolaXFle6HthVNbqr+Q9E5gPvDKSvLmtpeVX1m4UNKvG19eGEudILmD7W0lXQVg+15JM2uW8fXAncALgPPGOqD8BS0E2HbbbV3zuhExHQhmjO8TN8ttz59krsuAao1q0zLtCSTtAhwJvNL2I41028vKnzdLuhh4EdA0SNa5vcfKjlKXGW9AUbNsSdI84DXAS4BDJGWUTsSA6dErQFcAcyXNKStsewFPeEpdzoH7ZWA323dV0teTtEa5PgvYEbiuVWZ1guTnge8DG0o6luJzDse1OqF8Xegk4EO2b6cYrZM+yYiBU78/cqr6JG2vAA4GzgWuB75t+1pJx0hqPK3+NLA28J1Rr/o8H1hcfvH1ImCB7ZZBss5UaadLuhJ4dZm0h+3r25z2v4HbbTea2F8E9pP0Sts/bpdnRPSHXg1LtH0OcM6otKMq67s0Oe8y4IXjyatOnyQUU6U1mtxPaXdwtZ+x3F5JvokTMXjG3yfZd+q8AnQUcBqwPjALOEXSP3W6YBEx/TW+u1136Ud1apJ7A39t+2EASQuAq4FPdLJgEdEfRujP4FdXnSD53xSfbWjMK7kGYzxuj4jhI4pRN4OsTpC8D7hW0nkUfZKvAS6X9HkA2x/oYPkiYprr01Z0bXWC5PfLpeHizhQlIvqOUpMEOBN4drm+pNE3GREhNLx9kpJWo3hp/D3AbRTdD7MlnQIc2WwsdkQMl0GvSbZ6BejTFK/9zLG9ne1tgWcB65LRMxFRGlH9pR+1am6/EXiO7ccnnbB9v6T3ATcAH+x04SJiehNM5RRo01KrIOlqgKwkrpSU2XoiAhju5vZ1kt41OrGcn+2GzhUpIvrJyDiWftSqJnkQ8D1J7wGuLNPmU4zdfnOnCxYR058Eg/6NwKZBspyYcgdJOwNbl8nn2L6gKyWLiL7Qrw9k6qozVdqFwIVdKEtE9KEBr0jWniotIuJJRP/2NdaVIBkRkzK0fZIREW318UvidbUalvhT2y+X9ADlR8AauyjeoVyn46WLiGmteJm816XorFZPt19e/nxq94oTEf1m0JvbTftcJa3faulmISNieio+BNb9sduSdpV0o6Qlkg4fY/8aks4s9/9C0haVfUeU6TdKel27vFr1SV5J0cwe69YMbNn2TiJi4HW7HilpBnAixQTgS4ErJC0a9WnY/YF7bT9b0l7AJ4G/k7QVxXe6twY2Bs6X9JzyY4VjatXcnjP524mIwaZefFJ2e4q5bW8GkHQGsDtQDZK7A0eX62cB/6qiX2B34AzbjwC3SFpSXu9nzTJr+3Rb0ivGSrf9k7a3Ek9w32Un9roIHXXIWs/vdRE66oSH2n1ufgiNf2byWZIWV7YXlp+gHo9NgDsq20uBHZodY3uFpPuAp5fpPx917iatMqvzCtChlfU1KaLulcDONc6NiAEmGz15srBWltue36nydEKdYYlvqm5Lmg18rmMlioj+4lXdznEZMLuyvSlP/oJr45il5VcWngbcXfPcJ5jIiKKlwGC3qyKiJqNVK2ovU+QKYK6kOZJmUjyIWTTqmEXAvuX6nsCF5fy4i4C9yqffc4C5wOWtMqvTJ/kF/vIy+QgwD/hlzZuJiEE3vub2FGTnFZIOBs4FZgAn275W0jHAYtuLgK8CXy8fzNxDEUgpj/s2xUOeFcBBrZ5sQ70+yWon6wrgW7YvHe+NRcQAsnvR3Mb2OcA5o9KOqqw/DLy1ybnHAsfWzatOn+RpdS8WEcNHPQiS3VSnuT0XOB7YiuLpNgC28zJ5RPSkJtlNdR7cnAKcRNHUfhXwNeAbnSxURPSLsrldd+lDdYLkU8pPNsj2bbaPBt7Q2WJFRF8wAx8k6zy4eUTSCHBT+URpGbB2Z4sVEf3BsKo/g19ddYLkB4G1gA8AH6docu/b8oyIGBpT+P7jtNQySEragKJCvZrtpcB+XSlVRPQHu+vvSXZbq/kkDwCuBb4A3CBpt66VKiL6xxD3SX4I2Nr2HyRtCZzOk4f+RMSQG+b3JB+1/QcA2zdLWqNLZYqIvtGbETfd1CpIbirp8822bX+gc8WKiL4xxEHy0FHbV3ayIBHRh3o0drubWn2+IWO2I6IlMdx9khERbRhWtpxprO8lSEbExDWGJQ6wtmO3Je1YJy0ihpO8qvbSj+pMcPGFmmkRMXQGfxagps1tSS8FXgZsIOnDlV3rUEyZHhHRt8GvrlZ9kjMpZvtZDXhqJf1+ig/rRMSws2HVkD64sf1j4MeSTrV923gvLEnAJcCxtn9Upr0V2N/2rhMtcERML+7iVGmS1gfOBLYAbgXeZvveUcfMo5gofB1gJUUMOrPcdyrwSuC+8vB32766VZ51nm6fKulJ03zY3rnVSbYt6b3AdyRdVOZ1HJAAGTEwul6TPBy4wPYCSYeX24eNOuYh4F22b5K0MXClpHNt/7Hcf6jts+pmWCdIfqSyvibwFopPObRl+zeSzqa4ib8Cvmb7t3ULFxHTnOl2kNwd2KlcPw24mFFB0vZ/Vdb/W9JdwAbAH5mAOl9LHD0c8VJJLT/mPco/U3yn+1Fg/uidkg4EDgSYPXv2OC4bEb1mGz/2WDez3ND2neX674ANWx0saXuK5yvVytmxko4CLgAOt/1Iq2vU+Vri+pXNEWA74Gntzmuw/SdJZwIPjlUY2wuBhQDbbrvtYM/eGTFwxt3cniVpcWV7YRkDHifpfOCZY5x75BNyLrr0msYMSRsBXwf2tR9/BH8ERXCdSRF3DgOOaVXgOs3tKykq1aJoZt8C7F/jvKpV5RIRg8TG4wuSy20/qUX5xEt6l2b7JP1e0ka27yyD4F1NjlsH+A/gSNs/r1y7UQt9RNIpPLE7cUx1mttz2h0TEUOsux8CW0Txja0F5c8fjj5A0kzg+xTPQM4ata8RYAXsAfymXYZ1mttrAu8HXk5Ro7wE+JLth9veTkQMuHHXJCdrAfBtSfsDtwFvA5A0H3iv7QPKtFcAT5f07vK8xqs+p5ff7hJwNfDedhnWaW5/DXiAvwxFfAdFO/+tNW+K8lvdETFouvx02/bdwKvHSF8MHFCufwP4RpPzW766OJY6QfIFtreqbF8k6brxZhQRgyjf3Qb4paSXNDo/Je0ALG5zTkQMA4MznyTbAZdJur3c3gy4UdKvKZ7Cb9Ox0kXE9OZVsOLRXpeio+oEyQwjjIimujl2uxfqBMlP2N6nmiDp66PTImIYDfEsQBVbVzckrUbRBI+IYdf9sdtd12rS3SOAfwSeIul+iveKoBiDvbDZeRExPIyHt7lt+3jgeEnH2z6ii2WKiH4xzDXJih9JesXoRNs/6UB5IqKvpE8S4NDK+prA9hSTXoz7zfWIGDB5TxJsv6m6LWk28LmOlSgi+ohhRVfnk+y6OjXJ0ZYCz5/qgkREHxr/VGl9p84sQF+g6J6FYtLdeRQzjUdEDO/T7YrqOO0VwLdsX9qh8kREP7HxygTJM4Fnl+tLMo9kRDTYDG+QLEfWHAe8h2JySwGzyynPj7Q92L21EVHD4L9MPtJi36eB9YE5trezvS3wLGBd4DPdKFxETHNlTbLu0o9aNbffCDzH9uNfI7N9v6T3ATcAH+x04SJi+uvX4FdXqyDpaoCsJK5s9RnHiBgetlnZ3e9ud12r5vZ1kt41OlHSOylqkhEx7Mqn28Pa3D4I+J6k91AMQwSYDzwFeHOnCxYR/aGbwU/S+hRv3GwB3Aq8zfa9Yxy3Evh1uXm77d3K9DnAGcDTKeLaPrZbTq3etCZpe5ntHYBjysLcChxje3vby8ZzYxExmOzi6XbdZQocDlxgey5wQbk9lj/bnlcuu1XSPwmcYPvZwL3A/u0yrDN2+0LgwrZFj6F3wkPX97oIHXXIWoM7GvcO7pzwuau624zeHdipXD8NuBg4rM6JkkQxMc87KucfDZzU6ryJjN2OiCiM/2XyWZKqo/gW2h7PJN4b2m5E9N8BGzY5bs0ynxXAAts/oGhi/9H2ivKYpcAm7TJMkIyIiRv/sMTltue3OkDS+cAzx9h15BOztlu8abO57WWStgQuLL/uet94CtqQIBkRE2amfoIL27s02yfp95I2sn2npI2Au5pcY1n582ZJFwMvAr4LrCtptbI2uSnQ9vlKq1eAIiJa6/4rQIuAfcv1fYEfjj5A0nqS1ijXZwE7AteV731fBOzZ6vzREiQjYuIMKx9bUXuZAguA10i6Cdil3EbSfElfKY95PrBY0q8oguIC29eV+w4DPixpCUUf5VfbZZjmdkRMmOnuVGm27wZePUb6YuCAcv0y4IVNzr+Z4hM0tSVIRsTE5Rs3ERGtDP5UaQmSETFxwzzpbkREe/l8Q0REU3bXhyV2XYJkRExC+iQjIppbBasezdPtiIgxGae5HRHRlMGrBvtrLgmSETEpq1YmSEZEjMl5TzIiogUbpyYZEdFcmtsREc2kuR0R0ZxtVj6WIBkR0VTek4yIaKJ4up0+yQmR9GbgY6OStwHeYPtHnco3IrooQXLibH8f+H5jW9KBwN7AuZ3KMyK6bfCHJXblQ2CSngMcBexje7B/oxHDpByWWHeZLEnrSzpP0k3lz/XGOOZVkq6uLA9L2qPcd6qkWyr75rXLs+NBUtLqwDeB/2P79k7nFxHdY4r3JOsuU+Bw4ALbc4ELyu0nlsm+yPY82/OAnYGHgP9fOeTQxn7bV7fLsBs1yY8D19o+c6ydkg6UtFjS4uXLl3ehOBExZbr/3e3dgdPK9dOAPdocvyfwI9sPTTTDjgZJSTsBbwEObnaM7YW259ueP2vWrE4WJyKmmA0rH11Ve5kCG9q+s1z/HbBhm+P3Ar41Ku1YSddIOkHSGu0y7OTT7fWAU4B32H6gU/lERG+Nc2byWZIWV7YX2l5YPUDS+cAzxzj3yCfka1tS0za8pI0ovr9dfVh8BEVwnQksBA4DjmlV4E6+J/le4BnASZKq6cc3a3pHRJ/xuPsal9ue3/qS3qXZPkm/l7SR7TvLIHhXi0u9Dfi+7ccq127UQh+RdArwkXYF7uQrQMcDx3fq+hExDXT/PclFwL7AgvLnD1sc+3aKmuPjKgFWFP2Zv2mXYUbcRMSEma5PcLEA+Lak/YHbKGqLSJoPvNf2AeX2FsBs4Mejzj9d0gaAgKspWrwtJUhGxMS5u1Ol2b4bePUY6YuBAyrbtwKbjHHczuPNM0EyIiYhk+5GRDRlwyonSEZENLUyQTIiYmwGHs0nZSMixmZgwLskEyQjYuLsNLcjIlpKTTIiognj1CQjIppJn2RERBsJkhERTeTBTUREC3lPMiKihfRJRkS0keZ2REQTRZ9kr0vRWQmSETEpqUlGRDRhoKvzkvdAgmRETEJG3ERENJWn2xERLdiD/57kSK8LEBH9q6hJuvYyWZLeKulaSavKLyQ2O25XSTdKWiLp8Er6HEm/KNPPlDSzXZ7TqiZ51VVXLV9rrbVu62KWs4DlXcyv23J//avb97b5RE/scnP7N8DfAl9udoCkGcCJwGuApcAVkhbZvg74JHCC7TMkfQnYHzipVYbTKkja3qCb+UlabLvpX6N+l/vrX/1yb42aZNfys68HkNTqsO2BJbZvLo89A9hd0vXAzsA7yuNOA46mn4JkRPSXP/DouV/0bbPGccqakhZXthfaXjjFxdoEuKOyvRTYAXg68EfbKyrpT/o292gJkhExYbZ3neprSjofeOYYu460/cOpzq+dYQ+SU/0XbLrJ/fWvQb63lmzvMslLLANmV7Y3LdPuBtaVtFpZm2yktzTUT7c7UM2fVnJ//WuQ760LrgDmlk+yZwJ7AYtsG7gI2LM8bl+gbc10qINk9B9Jm/a6DNE7kt4saSnwUuA/JJ1bpm8s6RyAspZ4MHAucD3wbdvXlpc4DPiwpCUUfZRfbZunB3xIUQwOSRsA3wTeDtxjeyCHDUsaGdR760dDVZOUNPB9sJJeJellvS5Hh8wEngqsNqhBRNIuwLt6XY74i6EJkpJmAUskrd/rsnTYK4F9oKiR9LgsU8r2MuBnwN/A4N2fpJ2BHwBHqM2LgNE9A/UfWSu2lwP/AFwmab1el6eDLgPWARiE2pakV0j6rKTPSNqK4t7mQnF/gxJMJL0O+AzwfuBypx9s2hiaIAlg+2zgEGDxIAVKSa+WdLCkHYGbgC0kbTzqmH79t/49ReBfm6IZ+kpgF0k7ANh2vwdKSa8BPgccZPtrwDxJ25b7+vreBsHA99GNZvtHkg6mCJTzbd/b6zJNgZnAthRjVf8KeD7wHknX2F4kSf1aq7R9I3Aj8F0ASd8E3kAxzGyG7cv6udZV9pM/DzjA9s/Kccd3ARtA8UegcVxlpEh00dA+3Zb0euAE4GW27+l1eaaKpDnAsRQPOP4KuAfYGPgs8L1+DChlkHfl51xgb2B94HTbv+hxESelEQAbT7UlHQPcb/sz5f63AusBX+nXP3b9bOhqkg1ljXImcH5Zo+zr//ga/4PZvkXSFcA2tt8kaSPgtcBV/Rgg4S+1qcrPm8pJC94M3NzLsk2FSg2x8e/zJ+BlAJL2Bo4A9uz3/0b71dDWJBskrW37wV6XYypJ2hw41vY7e12WTpK0uu3Hel2OqSZpG+A9wCXA4cC+5TRf0QNDHyQHkaR1KR527NfvTdFhJGkz4FaKh3B7NKYHi97o1yee0dp9FCNT7mh3YExLd1JMGrtbAmTvpSY5oPI0tL8NaldCP0qQjIhoIc3tiIgWEiQjIlpIkIyIaCFBchqQNOXvaUraQtI7Wuz7s6SrJV0n6UsTHdst6VRJe5brXyknoRh9zExJnyu/dXyTpB92Y/JcSTsN8LRx0SUJkoNrC/7y6cyx/Nb2PGAbYCtgj8lmaPuAJi89H0cxTPK5tudSTAf2vamYvKHNHKE7UY5cmaLrxRBKkJxGyprOjTH2AAADQElEQVTPxZLOknSDpNMbgUTSrZI+JenXki6X9Owy/fGaXLndqJUuAP6mrC0e0izP8jWhy4BnS1pb0gWSflnms3t5zS0k/aaSx0ckHT1G+S+WNH9U2lrAfsAhtleWeZ4CPALsXF67ca/Xl/e+VnnudpJ+LOlKSeeWQywb+XxOxadJPyjpTZJ+IekqSedL2lDSFsB7gUPK38HflHldKOma8j43q/wOvyTpF8Cnav5zxZBIkJx+XgR8iKJ2tyWwY2XffbZfCPwrxdRarRwOXGJ7nu0Tmh1UBqRXA78GHgbebHtb4FXAZ6egtvds4Hbb949KXwxsXa4/F/ii7ecD9wPvl7Q68AWKMcvbASdTTNzRMNP2fNufBX4KvMT2i4AzgI/avhX4EnBC+Tu4pLzeaba3AU4HPl+53qYUk518eJL3GwMmTYvp53LbSwEkXU3RbP5pue9blZ9NA19Nzyqvb+CH5YQfqwPHSXoFsIriw+0bTjKfOu6wfWm5/g3gA8B/Ai8Azivj9AyKkSgNZ1bWNwXOLGuaM4FbmuTzUuBvy/Wv88Ra43caNd2IqgTJ6eeRyvpKnvhv5DHWV1C2CMqHLzNr5tPok6zam2Iew+1sPybpVmDNah6lNWvmAfBbYDNJT7X9QCV9O+Dfy/XRIxoMCLjW9kubXPdPlfUvAP9Szp25E3D0OMo31vUiHpfmdn/5u8rPn5Xrt1IEHIDdgNXL9QcoHpaMx9OAu8oA+Spg8zL998AzJD1d0hrAG+te0PafgNOAf1ExoSyS3gWsBVxYHraZpEYwfAdFzflGYINGuqTVJW3N2J7GXz4yv28lffTv4DKKbzBD8Qfhkrr3EcMrQbK/rCfpGuCDFJ+hAPg34JWSfkXRnGzUiK4BVkr6VasHN6OcDsyX9GuKTyXcAFCOIT4GuBw4r5E+DkdQ9Hf+l6SbgLdS9H02apA3AgdJup5ictmTbD9K8RH5T5b3djXNn1QfDXxH0pXA8kr62cCbGw9uKL5xtF/5O9yH4vcY0VLGbveJsuk7v/yg2cAon0L/u+0X9LgoEWNKTTIiooXUJCMiWkhNMiKihQTJiIgWEiQjIlpIkIyIaCFBMiKihQTJiIgW/geUyq6vXUMJswAAAABJRU5ErkJggg==\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "f, (ax1) = plt.subplots(1, 1, figsize=(5, 4.2))\n", "plot_pauli_transfer_matrix(np.real(Xpl), ax1, pl_basis_oneq.labels, 'X gate')\n", @@ -430,30 +234,9 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "CNOTpl = kraus2pauli_liouville(CNOT)\n", "CZpl = kraus2pauli_liouville(CZ)\n", @@ -487,30 +270,9 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from forest.benchmarking.utils import n_qubit_computational_basis\n", "from forest.benchmarking.plotting.hinton import hinton_real\n", @@ -531,30 +293,9 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "_ = hinton_real(Xpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels, ax=None, title='X gate')\n", "_ = hinton_real(Hpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels, ax=None, title='H gate')" @@ -569,30 +310,9 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": null, "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "from matplotlib import cm\n", "_ = hinton_real(Hpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels,cmap = cm.Greys_r, ax=None, title='Good H gate')\n", @@ -601,22 +321,9 @@ } ], "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.6.3" + "pygments_lexer": "ipython3" } }, "nbformat": 4, diff --git a/forest/benchmarking/plotting/hinton.py b/forest/benchmarking/plotting/hinton.py index 36035843..6928b56d 100644 --- a/forest/benchmarking/plotting/hinton.py +++ b/forest/benchmarking/plotting/hinton.py @@ -35,7 +35,6 @@ def hinton(matrix, max_weight=1.0, ax=None): ax.invert_yaxis() - # From QuTiP which in turn modified the code from the SciPy Cookbook. def _blob(x, y, w, w_max, area, cmap=None): """ diff --git a/forest/benchmarking/plotting/state_process.py b/forest/benchmarking/plotting/state_process.py index 9ac64fe6..46fa600e 100644 --- a/forest/benchmarking/plotting/state_process.py +++ b/forest/benchmarking/plotting/state_process.py @@ -116,4 +116,4 @@ def plot_pauli_transfer_matrix(ptransfermatrix, ax, labels=None, title='', fonts ax.set_xticklabels(labels, rotation=45, fontsize=int(np.floor(0.7*fontsizes))) ax.set_yticklabels(labels, fontsize=int(np.floor(0.7*fontsizes))) ax.grid(False) - return ax \ No newline at end of file + return ax From 66955109f88cad36099a007ded39ef27fb8d8fb0 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Thu, 9 May 2019 07:31:37 +1000 Subject: [PATCH 18/20] doc string catch Pauli -> computational --- forest/benchmarking/utils.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/forest/benchmarking/utils.py b/forest/benchmarking/utils.py index 080b1416..dbbbc594 100644 --- a/forest/benchmarking/utils.py +++ b/forest/benchmarking/utils.py @@ -456,7 +456,7 @@ def n_qubit_pauli_basis(n): def n_qubit_computational_basis(n): """ - Construct the tensor product operator basis of `n` PAULI_BASIS's. + Construct the tensor product operator basis of `n` COMPUTATIONAL_BASIS's. :param int n: The number of qubits. :return: The product Pauli operator basis of `n` qubits From f4c979176178a3bf5847483268627c8adbebeed1 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Thu, 9 May 2019 09:58:44 +1000 Subject: [PATCH 19/20] positive values = white neg values = black radius = mag this address kyle's point --- forest/benchmarking/plotting/hinton.py | 39 ++++++++++++++++++-------- 1 file changed, 27 insertions(+), 12 deletions(-) diff --git a/forest/benchmarking/plotting/hinton.py b/forest/benchmarking/plotting/hinton.py index 6928b56d..d9fae280 100644 --- a/forest/benchmarking/plotting/hinton.py +++ b/forest/benchmarking/plotting/hinton.py @@ -44,7 +44,7 @@ def _blob(x, y, w, w_max, area, cmap=None): xcorners = np.array([x - hs, x + hs, x + hs, x - hs]) ycorners = np.array([y - hs, y - hs, y + hs, y + hs]) - plt.fill(xcorners, ycorners, color=cmap(int((w + w_max) * 256 / (2 * w_max)))) + plt.fill(xcorners, ycorners, color=cmap) # cmap(int((w + w_max) * 256 / (2 * w_max)))) # Modified from QuTip (see https://bit.ly/2LrbayH ) which in turn modified the code from the @@ -77,11 +77,22 @@ def hinton_real(matrix: np.ndarray, ''' if ax is None: fig, ax = plt.subplots(1, 1, figsize=(8, 6)) + + # Grays in increasing darkness: smokewhite, gainsboro, lightgrey, lightgray, silver + backgnd_gray = 'gainsboro' + if cmap is None: cmap = cm.RdBu + cneg = cmap(0) + cpos = cmap(256) + cmap = mpl.colors.ListedColormap([cneg, backgnd_gray, cpos]) + else: + cneg = cmap(0) + cpos = cmap(256) + cmap = mpl.colors.ListedColormap([cneg, backgnd_gray, cpos]) if title and fig: - ax.set_title(title,y=1.1) + ax.set_title(title, y=1.1, fontsize=18) ax.set_aspect('equal', 'box') ax.set_frame_on(False) @@ -92,25 +103,29 @@ def hinton_real(matrix: np.ndarray, if max_weight <= 0.0: max_weight = 1.0 - ax.fill(np.array([0, width, width, 0]), np.array([0, 0, height, height]), color=cmap(128)) + bounds = [-max_weight, -0.0001, 0.0001, max_weight] + tick_loc = [-max_weight / 2, 0, max_weight / 2] + + ax.fill(np.array([0, width, width, 0]), np.array([0, 0, height, height]), color=cmap(1)) for x in range(width): for y in range(height): _x = x + 1 _y = y + 1 if np.real(matrix[x, y]) > 0.0: _blob(_x - 0.5, height - _y + 0.5, abs(matrix[x, y]), max_weight, - min(1, abs(matrix[x, y]) / max_weight), cmap=cmap) + min(1, abs(matrix[x, y]) / max_weight), cmap=cmap(2)) else: _blob(_x - 0.5, height - _y + 0.5, -abs(matrix[x, y]), max_weight, - min(1, abs(matrix[x, y]) / max_weight), cmap=cmap) + min(1, abs(matrix[x, y]) / max_weight), cmap=cmap(0)) - # color axis - if max_weight is None: - norm = mpl.colors.Normalize(-np.abs(matrix).max(), np.abs(matrix).max()) - else: - norm = mpl.colors.Normalize(-np.abs(max_weight), max_weight) + norm = mpl.colors.BoundaryNorm(bounds, cmap.N) cax, kw = mpl.colorbar.make_axes(ax, shrink=0.75, pad=.1) - mpl.colorbar.ColorbarBase(cax, norm=norm, cmap=cmap) + mpl.colorbar.ColorbarBase(cax, + norm=norm, + cmap=cmap, + boundaries=bounds, + ticks=tick_loc).set_ticklabels(['$-$', '$0$', '$+$']) + cax.tick_params(labelsize=14) # x axis ax.xaxis.set_major_locator(plt.IndexLocator(1, 0.5)) if xlabels: @@ -124,4 +139,4 @@ def hinton_real(matrix: np.ndarray, ax.set_yticklabels(list(reversed(ylabels))) ax.tick_params(axis='y', labelsize=14) - return fig, ax + return fig, ax \ No newline at end of file From b0e574c1834984d71a073f4d083ebb9a0c707cc2 Mon Sep 17 00:00:00 2001 From: Joshua Combes Date: Thu, 9 May 2019 10:04:37 +1000 Subject: [PATCH 20/20] fix plot titles --- examples/state_and_process_plots.ipynb | 26 +++++++++++++++++++++++--- 1 file changed, 23 insertions(+), 3 deletions(-) diff --git a/examples/state_and_process_plots.ipynb b/examples/state_and_process_plots.ipynb index 2be341f0..6dcb89d5 100644 --- a/examples/state_and_process_plots.ipynb +++ b/examples/state_and_process_plots.ipynb @@ -279,8 +279,8 @@ "oneq = n_qubit_computational_basis(1)\n", "oneq_latex_labels = [r'$|{}\\rangle$'.format(''.join(j)) for j in oneq.labels]\n", "\n", - "_ = hinton_real(ZERO, max_weight=1.0, xlabels=oneq_latex_labels, ylabels=oneq_latex_labels, ax=None, title='|0>')\n", - "_ = hinton_real(PLUS, max_weight=1.0, xlabels=oneq_latex_labels, ylabels=oneq_latex_labels, ax=None, title='|+>')" + "_ = hinton_real(ZERO, max_weight=1.0, xlabels=oneq_latex_labels, ylabels=oneq_latex_labels, ax=None, title=r'$|0\\rangle$')\n", + "_ = hinton_real(MINUS, max_weight=1.0, xlabels=oneq_latex_labels, ylabels=oneq_latex_labels, ax=None, title=r'$|-\\rangle$')" ] }, { @@ -318,12 +318,32 @@ "_ = hinton_real(Hpl, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels,cmap = cm.Greys_r, ax=None, title='Good H gate')\n", "_ = hinton_real(Hpl-0.3, max_weight=1.0, xlabels=pl_basis_oneq.labels, ylabels=pl_basis_oneq.labels, cmap = cm.Greys_r, ax=None, title='Bad H gate')" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "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", - "pygments_lexer": "ipython3" + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.3" } }, "nbformat": 4,