From ef1e9645e20ff5a4e1a9860540ea65084c603a0e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 14:52:57 +0200 Subject: [PATCH 001/116] integration of matplotlib circuit drawer --- src/qibo/models/circuit.py | 4 + src/qibo/models/mpldrawer.py | 254 +++++++++++++++++++++++++++++++++++ 2 files changed, 258 insertions(+) create mode 100644 src/qibo/models/mpldrawer.py diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index 67ec3a670b..c824d17224 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -9,6 +9,7 @@ from qibo.config import raise_error from qibo.gates.abstract import Gate from qibo.models._openqasm import QASMParser +from qibo.models.mpldrawer import plot_qibo_circuit NoiseMapType = Union[Tuple[int, int, int], Dict[int, Tuple[int, int, int]]] @@ -1269,6 +1270,9 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx + def draw_mpl(self, scale = 0.6): + plot_qibo_circuit(self, scale) + def draw(self, line_wrap=70, legend=False) -> str: """Draw text circuit using unicode symbols. diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py new file mode 100644 index 0000000000..922020bd0c --- /dev/null +++ b/src/qibo/models/mpldrawer.py @@ -0,0 +1,254 @@ +# Simplified Plotting Routines for Quantum Circuits by Rick Muller +# https://github.com/rpmuller/PlotQCircuit +import matplotlib +import numpy as np + +def _plot_quantum_circuit(gates,inits={},labels=[],plot_labels=True,**kwargs): + """Use Matplotlib to plot a quantum circuit. + gates List of tuples for each gate in the quantum circuit. + (name,target,control1,control2...). Targets and controls initially + defined in terms of labels. + inits Initialization list of gates, optional + + kwargs Can override plot_parameters + """ + plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, + control_radius = 0.05, not_radius = 0.15, + swap_delta = 0.08, label_buffer = 0.0) + plot_params.update(kwargs) + scale = plot_params['scale'] + + # Create labels from gates. This will become slow if there are a lot + # of gates, in which case move to an ordered dictionary + if not labels: + labels = [] + for i,gate in _enumerate_gates(gates): + for label in gate[1:]: + if label not in labels: + labels.append(label) + + nq = len(labels) + ng = len(gates) + wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) + gate_grid = np.arange(0.0, ng*scale, scale, dtype=float) + + fig,ax = _setup_figure(nq,ng,gate_grid,wire_grid,plot_params) + + measured = _measured_wires(gates,labels) + _draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured) + + if plot_labels: + _draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) + + _draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) + return ax + +def _enumerate_gates(l,schedule=False): + "Enumerate the gates in a way that can take l as either a list of gates or a schedule" + if schedule: + for i,gates in enumerate(l): + for gate in gates: + yield i,gate + else: + for i,gate in enumerate(l): + yield i,gate + return + +def _measured_wires(l,labels,schedule=False): + "measured[i] = j means wire i is measured at step j" + measured = {} + for i,gate in _enumerate_gates(l,schedule=schedule): + name,target = gate[:2] + j = _get_flipped_index(target,labels) + if name.startswith('M'): + measured[j] = i + return measured + +def _draw_gates(ax,l,labels,gate_grid,wire_grid,plot_params,measured={},schedule=False): + for i,gate in _enumerate_gates(l,schedule=schedule): + _draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) + if len(gate) > 2: # Controlled + _draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) + return + +def _draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): + linewidth = plot_params['linewidth'] + scale = plot_params['scale'] + control_radius = plot_params['control_radius'] + + name,target = gate[:2] + target_index = _get_flipped_index(target,labels) + controls = gate[2:] + control_indices = _get_flipped_indices(controls,labels) + gate_indices = control_indices + [target_index] + min_wire = min(gate_indices) + max_wire = max(gate_indices) + _line(ax,gate_grid[i],gate_grid[i],wire_grid[min_wire],wire_grid[max_wire],plot_params) + ismeasured = False + for index in control_indices: + if measured.get(index,1000) < i: + ismeasured = True + if ismeasured: + dy = 0.04 # TODO: put in plot_params + _line(ax,gate_grid[i]+dy,gate_grid[i]+dy,wire_grid[min_wire],wire_grid[max_wire],plot_params) + + for ci in control_indices: + x = gate_grid[i] + y = wire_grid[ci] + if name in ['SWAP']: + _swapx(ax,x,y,plot_params) + else: + _cdot(ax,x,y,plot_params) + return + +def _draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params): + target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CZ='Z') + name,target = gate[:2] + symbol = target_symbols.get(name,name) # override name with target_symbols + x = gate_grid[i] + target_index = _get_flipped_index(target,labels) + y = wire_grid[target_index] + if not symbol: return + if name in ['CNOT','TOFFOLI']: + _oplus(ax,x,y,plot_params) + elif name in ['CPHASE']: + _cdot(ax,x,y,plot_params) + elif name in ['SWAP']: + _swapx(ax,x,y,plot_params) + else: + _text(ax,x,y,symbol,plot_params,box=True) + return + +def _line(ax,x1,x2,y1,y2,plot_params): + Line2D = matplotlib.lines.Line2D + line = Line2D((x1,x2), (y1,y2), + color='k',lw=plot_params['linewidth']) + ax.add_line(line) + +def _text(ax,x,y,textstr,plot_params,box=False): + linewidth = plot_params['linewidth'] + fontsize = plot_params['fontsize'] + if box: + bbox = dict(ec='k',fc='w',fill=True,lw=linewidth) + else: + bbox= dict(fill=False,lw=0) + ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) + return + +def _oplus(ax,x,y,plot_params): + Line2D = matplotlib.lines.Line2D + Circle = matplotlib.patches.Circle + not_radius = plot_params['not_radius'] + linewidth = plot_params['linewidth'] + c = Circle((x, y),not_radius,ec='k', + fc='w',fill=False,lw=linewidth) + ax.add_patch(c) + _line(ax,x,x,y-not_radius,y+not_radius,plot_params) + return + +def _cdot(ax,x,y,plot_params): + Circle = matplotlib.patches.Circle + control_radius = plot_params['control_radius'] + scale = plot_params['scale'] + linewidth = plot_params['linewidth'] + c = Circle((x, y),control_radius*scale, + ec='k',fc='k',fill=True,lw=linewidth) + ax.add_patch(c) + return + +def _swapx(ax,x,y,plot_params): + d = plot_params['swap_delta'] + linewidth = plot_params['linewidth'] + _line(ax,x-d,x+d,y-d,y+d,plot_params) + _line(ax,x-d,x+d,y+d,y-d,plot_params) + return + +def _setup_figure(nq,ng,gate_grid,wire_grid,plot_params): + scale = plot_params['scale'] + fig = matplotlib.pyplot.figure( + figsize=(ng*scale, nq*scale), + facecolor='w', + edgecolor='w' + ) + ax = fig.add_subplot(1, 1, 1,frameon=True) + ax.set_axis_off() + offset = 0.5*scale + ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) + ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) + ax.set_aspect('equal') + return fig,ax + +def _draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured={}): + scale = plot_params['scale'] + linewidth = plot_params['linewidth'] + xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) + for i in range(nq): + _line(ax,gate_grid[0]-scale,gate_grid[-1]+scale,wire_grid[i],wire_grid[i],plot_params) + + # Add the doubling for measured wires: + dy=0.04 # TODO: add to plot_params + for i in measured: + j = measured[i] + _line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) + return + +def _draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params): + scale = plot_params['scale'] + label_buffer = plot_params['label_buffer'] + fontsize = plot_params['fontsize'] + nq = len(labels) + xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) + for i in range(nq): + j = _get_flipped_index(labels[i],labels) + _text(ax,xdata[0]-label_buffer,wire_grid[j],_render_label(labels[i],inits),plot_params) + return + +def _get_flipped_index(target,labels): + """Get qubit labels from the rest of the line,and return indices + + >>> _get_flipped_index('q0', ['q0', 'q1']) + 1 + >>> _get_flipped_index('q1', ['q0', 'q1']) + 0 + """ + nq = len(labels) + i = labels.index(target) + return nq-i-1 + +def _get_flipped_indices(targets,labels): return [_get_flipped_index(t,labels) for t in targets] + +def _render_label(label, inits={}): + """Slightly more flexible way to render labels. + + >>> _render_label('q0') + '$|q0\\\\rangle$' + >>> _render_label('q0', {'q0':'0'}) + '$|0\\\\rangle$' + """ + if label in inits: + s = inits[label] + if s is None: + return '' + else: + return r'$|%s\rangle$' % inits[label] + return r'$|%s\rangle$' % label + +def plot_qibo_circuit(circuit, scale): + gates_plot = [] + inits = [] + + for gate in circuit.queue: + init_label = gate.draw_label.upper() + inits.append(init_label) + item = () + item += (init_label, ) + + if len(gate.init_args) == 1: + item += ("q_" + str(gate.init_args[0]), ) + else: + for i in reversed(range(len(gate.init_args))): + item += ("q_" + str(gate.init_args[i]), ) + + gates_plot.append(item) + + _plot_quantum_circuit(gates_plot, inits, scale = scale) From 5a776fcdc17a0c479cf9e21f7d20da39b1ee57d5 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 17:31:36 +0200 Subject: [PATCH 002/116] integration of matplotlib circuit drawer --- src/qibo/models/circuit.py | 4 +- src/qibo/models/mpldrawer.py | 493 ++++++++++++++++++----------------- 2 files changed, 251 insertions(+), 246 deletions(-) diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index c824d17224..3e1b59f152 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -9,7 +9,7 @@ from qibo.config import raise_error from qibo.gates.abstract import Gate from qibo.models._openqasm import QASMParser -from qibo.models.mpldrawer import plot_qibo_circuit +from qibo.models.mpldrawer import MPLDrawer NoiseMapType = Union[Tuple[int, int, int], Dict[int, Tuple[int, int, int]]] @@ -1271,7 +1271,7 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx def draw_mpl(self, scale = 0.6): - plot_qibo_circuit(self, scale) + MPLDrawer().plot_qibo_circuit(self, scale) def draw(self, line_wrap=70, legend=False) -> str: """Draw text circuit using unicode symbols. diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 922020bd0c..5a43b6d4a3 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -3,252 +3,257 @@ import matplotlib import numpy as np -def _plot_quantum_circuit(gates,inits={},labels=[],plot_labels=True,**kwargs): - """Use Matplotlib to plot a quantum circuit. - gates List of tuples for each gate in the quantum circuit. - (name,target,control1,control2...). Targets and controls initially - defined in terms of labels. - inits Initialization list of gates, optional - - kwargs Can override plot_parameters - """ - plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, - control_radius = 0.05, not_radius = 0.15, - swap_delta = 0.08, label_buffer = 0.0) - plot_params.update(kwargs) - scale = plot_params['scale'] - - # Create labels from gates. This will become slow if there are a lot - # of gates, in which case move to an ordered dictionary - if not labels: - labels = [] - for i,gate in _enumerate_gates(gates): - for label in gate[1:]: - if label not in labels: - labels.append(label) - - nq = len(labels) - ng = len(gates) - wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) - gate_grid = np.arange(0.0, ng*scale, scale, dtype=float) - - fig,ax = _setup_figure(nq,ng,gate_grid,wire_grid,plot_params) - - measured = _measured_wires(gates,labels) - _draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured) - - if plot_labels: - _draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) - - _draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) - return ax - -def _enumerate_gates(l,schedule=False): - "Enumerate the gates in a way that can take l as either a list of gates or a schedule" - if schedule: - for i,gates in enumerate(l): - for gate in gates: +class MPLDrawer: + + def __init__(self): + pass + + def _plot_quantum_circuit(self, gates,inits={},labels=[],plot_labels=True,**kwargs): + """Use Matplotlib to plot a quantum circuit. + gates List of tuples for each gate in the quantum circuit. + (name,target,control1,control2...). Targets and controls initially + defined in terms of labels. + inits Initialization list of gates, optional + + kwargs Can override plot_parameters + """ + plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, + control_radius = 0.05, not_radius = 0.15, + swap_delta = 0.08, label_buffer = 0.0) + plot_params.update(kwargs) + scale = plot_params['scale'] + + # Create labels from gates. This will become slow if there are a lot + # of gates, in which case move to an ordered dictionary + if not labels: + labels = [] + for i,gate in self._enumerate_gates(gates): + for label in gate[1:]: + if label not in labels: + labels.append(label) + + nq = len(labels) + ng = len(gates) + wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) + gate_grid = np.arange(0.0, ng*scale, scale, dtype=float) + + fig,ax = self._setup_figure(nq,ng,gate_grid,wire_grid,plot_params) + + measured = self._measured_wires(gates,labels) + self._draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured) + + if plot_labels: + self._draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) + + self._draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) + return ax + + def _enumerate_gates(self,l,schedule=False): + "Enumerate the gates in a way that can take l as either a list of gates or a schedule" + if schedule: + for i,gates in enumerate(l): + for gate in gates: + yield i,gate + else: + for i,gate in enumerate(l): yield i,gate - else: - for i,gate in enumerate(l): - yield i,gate - return - -def _measured_wires(l,labels,schedule=False): - "measured[i] = j means wire i is measured at step j" - measured = {} - for i,gate in _enumerate_gates(l,schedule=schedule): + return + + def _measured_wires(self,l,labels,schedule=False): + "measured[i] = j means wire i is measured at step j" + measured = {} + for i,gate in self._enumerate_gates(l,schedule=schedule): + name,target = gate[:2] + j = self._get_flipped_index(target,labels) + if name.startswith('M'): + measured[j] = i + return measured + + def _draw_gates(self,ax,l,labels,gate_grid,wire_grid,plot_params,measured={},schedule=False): + for i,gate in self._enumerate_gates(l,schedule=schedule): + self._draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) + if len(gate) > 2: # Controlled + self._draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) + return + + def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): + linewidth = plot_params['linewidth'] + scale = plot_params['scale'] + control_radius = plot_params['control_radius'] + + name,target = gate[:2] + target_index = self._get_flipped_index(target,labels) + controls = gate[2:] + control_indices = self._get_flipped_indices(controls,labels) + gate_indices = control_indices + [target_index] + min_wire = min(gate_indices) + max_wire = max(gate_indices) + self._line(ax,gate_grid[i],gate_grid[i],wire_grid[min_wire],wire_grid[max_wire],plot_params) + ismeasured = False + for index in control_indices: + if measured.get(index,1000) < i: + ismeasured = True + if ismeasured: + dy = 0.04 # TODO: put in plot_params + self._line(ax,gate_grid[i]+dy,gate_grid[i]+dy,wire_grid[min_wire],wire_grid[max_wire],plot_params) + + for ci in control_indices: + x = gate_grid[i] + y = wire_grid[ci] + if name in ['SWAP']: + self._swapx(ax,x,y,plot_params) + else: + self._cdot(ax,x,y,plot_params) + return + + def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): + target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CZ='Z') name,target = gate[:2] - j = _get_flipped_index(target,labels) - if name.startswith('M'): - measured[j] = i - return measured - -def _draw_gates(ax,l,labels,gate_grid,wire_grid,plot_params,measured={},schedule=False): - for i,gate in _enumerate_gates(l,schedule=schedule): - _draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) - if len(gate) > 2: # Controlled - _draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) - return - -def _draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): - linewidth = plot_params['linewidth'] - scale = plot_params['scale'] - control_radius = plot_params['control_radius'] - - name,target = gate[:2] - target_index = _get_flipped_index(target,labels) - controls = gate[2:] - control_indices = _get_flipped_indices(controls,labels) - gate_indices = control_indices + [target_index] - min_wire = min(gate_indices) - max_wire = max(gate_indices) - _line(ax,gate_grid[i],gate_grid[i],wire_grid[min_wire],wire_grid[max_wire],plot_params) - ismeasured = False - for index in control_indices: - if measured.get(index,1000) < i: - ismeasured = True - if ismeasured: - dy = 0.04 # TODO: put in plot_params - _line(ax,gate_grid[i]+dy,gate_grid[i]+dy,wire_grid[min_wire],wire_grid[max_wire],plot_params) - - for ci in control_indices: + symbol = target_symbols.get(name,name) # override name with target_symbols x = gate_grid[i] - y = wire_grid[ci] - if name in ['SWAP']: - _swapx(ax,x,y,plot_params) + target_index = self._get_flipped_index(target,labels) + y = wire_grid[target_index] + if not symbol: return + if name in ['CNOT','TOFFOLI']: + self._oplus(ax,x,y,plot_params) + elif name in ['CPHASE']: + self._cdot(ax,x,y,plot_params) + elif name in ['SWAP']: + self._swapx(ax,x,y,plot_params) else: - _cdot(ax,x,y,plot_params) - return - -def _draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params): - target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CZ='Z') - name,target = gate[:2] - symbol = target_symbols.get(name,name) # override name with target_symbols - x = gate_grid[i] - target_index = _get_flipped_index(target,labels) - y = wire_grid[target_index] - if not symbol: return - if name in ['CNOT','TOFFOLI']: - _oplus(ax,x,y,plot_params) - elif name in ['CPHASE']: - _cdot(ax,x,y,plot_params) - elif name in ['SWAP']: - _swapx(ax,x,y,plot_params) - else: - _text(ax,x,y,symbol,plot_params,box=True) - return - -def _line(ax,x1,x2,y1,y2,plot_params): - Line2D = matplotlib.lines.Line2D - line = Line2D((x1,x2), (y1,y2), - color='k',lw=plot_params['linewidth']) - ax.add_line(line) - -def _text(ax,x,y,textstr,plot_params,box=False): - linewidth = plot_params['linewidth'] - fontsize = plot_params['fontsize'] - if box: - bbox = dict(ec='k',fc='w',fill=True,lw=linewidth) - else: - bbox= dict(fill=False,lw=0) - ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) - return - -def _oplus(ax,x,y,plot_params): - Line2D = matplotlib.lines.Line2D - Circle = matplotlib.patches.Circle - not_radius = plot_params['not_radius'] - linewidth = plot_params['linewidth'] - c = Circle((x, y),not_radius,ec='k', - fc='w',fill=False,lw=linewidth) - ax.add_patch(c) - _line(ax,x,x,y-not_radius,y+not_radius,plot_params) - return - -def _cdot(ax,x,y,plot_params): - Circle = matplotlib.patches.Circle - control_radius = plot_params['control_radius'] - scale = plot_params['scale'] - linewidth = plot_params['linewidth'] - c = Circle((x, y),control_radius*scale, - ec='k',fc='k',fill=True,lw=linewidth) - ax.add_patch(c) - return - -def _swapx(ax,x,y,plot_params): - d = plot_params['swap_delta'] - linewidth = plot_params['linewidth'] - _line(ax,x-d,x+d,y-d,y+d,plot_params) - _line(ax,x-d,x+d,y+d,y-d,plot_params) - return - -def _setup_figure(nq,ng,gate_grid,wire_grid,plot_params): - scale = plot_params['scale'] - fig = matplotlib.pyplot.figure( - figsize=(ng*scale, nq*scale), - facecolor='w', - edgecolor='w' - ) - ax = fig.add_subplot(1, 1, 1,frameon=True) - ax.set_axis_off() - offset = 0.5*scale - ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) - ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) - ax.set_aspect('equal') - return fig,ax - -def _draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured={}): - scale = plot_params['scale'] - linewidth = plot_params['linewidth'] - xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) - for i in range(nq): - _line(ax,gate_grid[0]-scale,gate_grid[-1]+scale,wire_grid[i],wire_grid[i],plot_params) - - # Add the doubling for measured wires: - dy=0.04 # TODO: add to plot_params - for i in measured: - j = measured[i] - _line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) - return - -def _draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params): - scale = plot_params['scale'] - label_buffer = plot_params['label_buffer'] - fontsize = plot_params['fontsize'] - nq = len(labels) - xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) - for i in range(nq): - j = _get_flipped_index(labels[i],labels) - _text(ax,xdata[0]-label_buffer,wire_grid[j],_render_label(labels[i],inits),plot_params) - return - -def _get_flipped_index(target,labels): - """Get qubit labels from the rest of the line,and return indices - - >>> _get_flipped_index('q0', ['q0', 'q1']) - 1 - >>> _get_flipped_index('q1', ['q0', 'q1']) - 0 - """ - nq = len(labels) - i = labels.index(target) - return nq-i-1 - -def _get_flipped_indices(targets,labels): return [_get_flipped_index(t,labels) for t in targets] - -def _render_label(label, inits={}): - """Slightly more flexible way to render labels. - - >>> _render_label('q0') - '$|q0\\\\rangle$' - >>> _render_label('q0', {'q0':'0'}) - '$|0\\\\rangle$' - """ - if label in inits: - s = inits[label] - if s is None: - return '' + self._text(ax,x,y,symbol,plot_params,box=True) + return + + def _line(self,ax,x1,x2,y1,y2,plot_params): + Line2D = matplotlib.lines.Line2D + line = Line2D((x1,x2), (y1,y2), + color='k',lw=plot_params['linewidth']) + ax.add_line(line) + + def _text(self,ax,x,y,textstr,plot_params,box=False): + linewidth = plot_params['linewidth'] + fontsize = plot_params['fontsize'] + if box: + bbox = dict(ec='k',fc='w',fill=True,lw=linewidth) else: - return r'$|%s\rangle$' % inits[label] - return r'$|%s\rangle$' % label - -def plot_qibo_circuit(circuit, scale): - gates_plot = [] - inits = [] - - for gate in circuit.queue: - init_label = gate.draw_label.upper() - inits.append(init_label) - item = () - item += (init_label, ) - - if len(gate.init_args) == 1: - item += ("q_" + str(gate.init_args[0]), ) - else: - for i in reversed(range(len(gate.init_args))): - item += ("q_" + str(gate.init_args[i]), ) - - gates_plot.append(item) - - _plot_quantum_circuit(gates_plot, inits, scale = scale) + bbox= dict(fill=False,lw=0) + ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) + return + + def _oplus(self,ax,x,y,plot_params): + Line2D = matplotlib.lines.Line2D + Circle = matplotlib.patches.Circle + not_radius = plot_params['not_radius'] + linewidth = plot_params['linewidth'] + c = Circle((x, y),not_radius,ec='k', + fc='w',fill=False,lw=linewidth) + ax.add_patch(c) + self._line(ax,x,x,y-not_radius,y+not_radius,plot_params) + return + + def _cdot(self,ax,x,y,plot_params): + Circle = matplotlib.patches.Circle + control_radius = plot_params['control_radius'] + scale = plot_params['scale'] + linewidth = plot_params['linewidth'] + c = Circle((x, y),control_radius*scale, + ec='k',fc='k',fill=True,lw=linewidth) + ax.add_patch(c) + return + + def _swapx(self,ax,x,y,plot_params): + d = plot_params['swap_delta'] + linewidth = plot_params['linewidth'] + self._line(ax,x-d,x+d,y-d,y+d,plot_params) + self._line(ax,x-d,x+d,y+d,y-d,plot_params) + return + + def _setup_figure(self,nq,ng,gate_grid,wire_grid,plot_params): + scale = plot_params['scale'] + fig = matplotlib.pyplot.figure( + figsize=(ng*scale, nq*scale), + facecolor='w', + edgecolor='w' + ) + ax = fig.add_subplot(1, 1, 1,frameon=True) + ax.set_axis_off() + offset = 0.5*scale + ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) + ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) + ax.set_aspect('equal') + return fig,ax + + def _draw_wires(self,ax,nq,gate_grid,wire_grid,plot_params,measured={}): + scale = plot_params['scale'] + linewidth = plot_params['linewidth'] + xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) + for i in range(nq): + self._line(ax,gate_grid[0]-scale,gate_grid[-1]+scale,wire_grid[i],wire_grid[i],plot_params) + + # Add the doubling for measured wires: + dy=0.04 # TODO: add to plot_params + for i in measured: + j = measured[i] + self._line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) + return + + def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): + scale = plot_params['scale'] + label_buffer = plot_params['label_buffer'] + fontsize = plot_params['fontsize'] + nq = len(labels) + xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) + for i in range(nq): + j = self._get_flipped_index(labels[i],labels) + self._text(ax,xdata[0]-label_buffer,wire_grid[j],self._render_label(labels[i],inits),plot_params) + return + + def _get_flipped_index(self,target,labels): + """Get qubit labels from the rest of the line,and return indices + + >>> _get_flipped_index('q0', ['q0', 'q1']) + 1 + >>> _get_flipped_index('q1', ['q0', 'q1']) + 0 + """ + nq = len(labels) + i = labels.index(target) + return nq-i-1 + + def _get_flipped_indices(self,targets,labels): return [self._get_flipped_index(t,labels) for t in targets] + + def _render_label(self,label, inits={}): + """Slightly more flexible way to render labels. + + >>> _render_label('q0') + '$|q0\\\\rangle$' + >>> _render_label('q0', {'q0':'0'}) + '$|0\\\\rangle$' + """ + if label in inits: + s = inits[label] + if s is None: + return '' + else: + return r'$|%s\rangle$' % inits[label] + return r'$|%s\rangle$' % label + + def plot_qibo_circuit(self,circuit, scale): + gates_plot = [] + inits = [] + + for gate in circuit.queue: + init_label = gate.draw_label.upper() + inits.append(init_label) + item = () + item += (init_label, ) + + if len(gate.init_args) == 1: + item += ("q_" + str(gate.init_args[0]), ) + else: + for i in reversed(range(len(gate.init_args))): + item += ("q_" + str(gate.init_args[i]), ) + + gates_plot.append(item) + + self._plot_quantum_circuit(gates_plot, inits, scale = scale) From 62ef4c0faee5af1d1240b54ac3e0a2bb04452b3d Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 18:55:19 +0200 Subject: [PATCH 003/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 16 +++++++++++----- 1 file changed, 11 insertions(+), 5 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 5a43b6d4a3..e63cbb8c94 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -248,11 +248,17 @@ def plot_qibo_circuit(self,circuit, scale): item = () item += (init_label, ) - if len(gate.init_args) == 1: - item += ("q_" + str(gate.init_args[0]), ) - else: - for i in reversed(range(len(gate.init_args))): - item += ("q_" + str(gate.init_args[i]), ) + for qbit in gate._target_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + for qbit in gate._control_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) gates_plot.append(item) From e094baad9b1bef59b64a140554c14fdd26fa93e9 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 19:34:29 +0200 Subject: [PATCH 004/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index e63cbb8c94..a4d59754d2 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -100,14 +100,14 @@ def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measure for ci in control_indices: x = gate_grid[i] y = wire_grid[ci] - if name in ['SWAP']: + if name in ['SWAP', 'ISWAP', 'SISWAP', 'FISWAP']: self._swapx(ax,x,y,plot_params) else: self._cdot(ax,x,y,plot_params) return def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): - target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CZ='Z') + target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X') name,target = gate[:2] symbol = target_symbols.get(name,name) # override name with target_symbols x = gate_grid[i] @@ -118,7 +118,7 @@ def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): self._oplus(ax,x,y,plot_params) elif name in ['CPHASE']: self._cdot(ax,x,y,plot_params) - elif name in ['SWAP']: + elif name in ['SWAP', 'ISWAP', 'SISWAP', 'FISWAP']: self._swapx(ax,x,y,plot_params) else: self._text(ax,x,y,symbol,plot_params,box=True) @@ -243,7 +243,7 @@ def plot_qibo_circuit(self,circuit, scale): inits = [] for gate in circuit.queue: - init_label = gate.draw_label.upper() + init_label = gate.name.upper() inits.append(init_label) item = () item += (init_label, ) From 6ee3ff8801c1c64d700537004d0c93ca639ae14c Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 19:38:31 +0200 Subject: [PATCH 005/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index a4d59754d2..ba5a682db8 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -107,7 +107,7 @@ def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measure return def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): - target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X') + target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE') name,target = gate[:2] symbol = target_symbols.get(name,name) # override name with target_symbols x = gate_grid[i] From b1600a5fdbbca74752d3a3d65b7f59f23e6ac70e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 19:43:24 +0200 Subject: [PATCH 006/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index ba5a682db8..7c33bd139a 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -107,7 +107,7 @@ def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measure return def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): - target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE') + target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE',UNITARY='U') name,target = gate[:2] symbol = target_symbols.get(name,name) # override name with target_symbols x = gate_grid[i] From 1894f03c958e8161d600b1d0b74333ac24cd955f Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 20:00:59 +0200 Subject: [PATCH 007/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 7c33bd139a..7c7da61e39 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -1,4 +1,5 @@ -# Simplified Plotting Routines for Quantum Circuits by Rick Muller +# MPLDrawer craeted from code provided by Rick Muller +# Simplified Plotting Routines for Quantum Circuits # https://github.com/rpmuller/PlotQCircuit import matplotlib import numpy as np From fcf66cb3ea3e0e6e19243fc39a20a818679f4e28 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 20:19:10 +0200 Subject: [PATCH 008/116] integration of matplotlib circuit drawer --- src/qibo/models/circuit.py | 10 ++++++++-- src/qibo/models/mpldrawer.py | 6 +++++- 2 files changed, 13 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index 3e1b59f152..bf43033114 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -1270,8 +1270,14 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx - def draw_mpl(self, scale = 0.6): - MPLDrawer().plot_qibo_circuit(self, scale) + def draw_mpl(self, scale = 0.6, save_file = None): + + ax = MPLDrawer().plot_qibo_circuit(self, scale) + + if save_file: + MPLDrawer.save_fig(ax.figure, save_file) + + return ax def draw(self, line_wrap=70, legend=False) -> str: """Draw text circuit using unicode symbols. diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 7c7da61e39..9b705f155a 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -263,4 +263,8 @@ def plot_qibo_circuit(self,circuit, scale): gates_plot.append(item) - self._plot_quantum_circuit(gates_plot, inits, scale = scale) + return self._plot_quantum_circuit(gates_plot, inits, scale = scale) + + @staticmethod + def save_fig(fig, path_file): + return fig.savefig(path_file, bbox_inches='tight') From 017e205caa9b03bae7adeab642d2bcfb15d1cbb7 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 21:26:29 +0200 Subject: [PATCH 009/116] integration of matplotlib circuit drawer --- src/qibo/models/circuit.py | 4 +-- src/qibo/models/mpldrawer.py | 67 ++++++++++++++++++++++++++++++++++-- 2 files changed, 67 insertions(+), 4 deletions(-) diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index bf43033114..b259c2892f 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -1270,9 +1270,9 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx - def draw_mpl(self, scale = 0.6, save_file = None): + def draw_mpl(self, scale = 0.6, cluster_gates = True, save_file = None): - ax = MPLDrawer().plot_qibo_circuit(self, scale) + ax = MPLDrawer().plot_qibo_circuit(self, scale, cluster_gates) if save_file: MPLDrawer.save_fig(ax.figure, save_file) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 9b705f155a..f3828233e8 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -9,6 +9,46 @@ class MPLDrawer: def __init__(self): pass + def _plot_quantum_schedule(self, schedule,inits={},labels=[],plot_labels=True,**kwargs): + """Use Matplotlib to plot a quantum circuit. + schedule List of time steps, each containing a sequence of gates during that step. + Each gate is a tuple containing (name,target,control1,control2...). + Targets and controls initially defined in terms of labels. + inits Initialization list of gates, optional + + kwargs Can override plot_parameters + """ + plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, + control_radius = 0.05, not_radius = 0.15, + swap_delta = 0.08, label_buffer = 0.0) + plot_params.update(kwargs) + scale = plot_params['scale'] + + # Create labels from gates. This will become slow if there are a lot + # of gates, in which case move to an ordered dictionary + if not labels: + labels = [] + for i,gate in self._enumerate_gates(schedule,schedule=True): + for label in gate[1:]: + if label not in labels: + labels.append(label) + + nq = len(labels) + nt = len(schedule) + wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) + gate_grid = np.arange(0.0, nt*scale, scale, dtype=float) + + fig,ax = self._setup_figure(nq,nt,gate_grid,wire_grid,plot_params) + + measured = self._measured_wires(schedule,labels,schedule=True) + self._draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured) + + if plot_labels: + self._draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) + + self._draw_gates(ax,schedule,labels,gate_grid,wire_grid,plot_params,measured,schedule=True) + return ax + def _plot_quantum_circuit(self, gates,inits={},labels=[],plot_labels=True,**kwargs): """Use Matplotlib to plot a quantum circuit. gates List of tuples for each gate in the quantum circuit. @@ -239,7 +279,26 @@ def _render_label(self,label, inits={}): return r'$|%s\rangle$' % inits[label] return r'$|%s\rangle$' % label - def plot_qibo_circuit(self,circuit, scale): + def _make_schedule(self, item_plos): + schedule = [[]] + current_tic = schedule[-1] + qubits_in_current_tic = set() + for gate in item_plos: + qubits = set(gate[1:]) + # print(qubits) + if qubits_in_current_tic.intersection(qubits): + # Qubits already in tic, create new tic + current_tic = [gate] + qubits_in_current_tic = qubits + schedule.append(current_tic) + else: + # Add to current tic + current_tic.append(gate) + qubits_in_current_tic = qubits_in_current_tic.union(qubits) + + return schedule + + def plot_qibo_circuit(self, circuit, scale, cluster_gates): gates_plot = [] inits = [] @@ -263,7 +322,11 @@ def plot_qibo_circuit(self,circuit, scale): gates_plot.append(item) - return self._plot_quantum_circuit(gates_plot, inits, scale = scale) + if cluster_gates: + scheduled_plots = self._make_schedule(gates_plot) + return self._plot_quantum_schedule(scheduled_plots, inits, scale = scale) + else: + return self._plot_quantum_circuit(gates_plot, inits, scale = scale) @staticmethod def save_fig(fig, path_file): From ebb64540079a94e7f67ce0a8c63a64b7bdf2fb19 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 20 Jun 2024 22:40:25 +0200 Subject: [PATCH 010/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 12 +----------- 1 file changed, 1 insertion(+), 11 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index f3828233e8..470f833fa1 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -98,7 +98,6 @@ def _enumerate_gates(self,l,schedule=False): else: for i,gate in enumerate(l): yield i,gate - return def _measured_wires(self,l,labels,schedule=False): "measured[i] = j means wire i is measured at step j" @@ -115,7 +114,6 @@ def _draw_gates(self,ax,l,labels,gate_grid,wire_grid,plot_params,measured={},sch self._draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) if len(gate) > 2: # Controlled self._draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) - return def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): linewidth = plot_params['linewidth'] @@ -145,7 +143,6 @@ def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measure self._swapx(ax,x,y,plot_params) else: self._cdot(ax,x,y,plot_params) - return def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE',UNITARY='U') @@ -163,7 +160,6 @@ def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): self._swapx(ax,x,y,plot_params) else: self._text(ax,x,y,symbol,plot_params,box=True) - return def _line(self,ax,x1,x2,y1,y2,plot_params): Line2D = matplotlib.lines.Line2D @@ -179,7 +175,6 @@ def _text(self,ax,x,y,textstr,plot_params,box=False): else: bbox= dict(fill=False,lw=0) ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) - return def _oplus(self,ax,x,y,plot_params): Line2D = matplotlib.lines.Line2D @@ -190,7 +185,6 @@ def _oplus(self,ax,x,y,plot_params): fc='w',fill=False,lw=linewidth) ax.add_patch(c) self._line(ax,x,x,y-not_radius,y+not_radius,plot_params) - return def _cdot(self,ax,x,y,plot_params): Circle = matplotlib.patches.Circle @@ -200,14 +194,12 @@ def _cdot(self,ax,x,y,plot_params): c = Circle((x, y),control_radius*scale, ec='k',fc='k',fill=True,lw=linewidth) ax.add_patch(c) - return def _swapx(self,ax,x,y,plot_params): d = plot_params['swap_delta'] linewidth = plot_params['linewidth'] self._line(ax,x-d,x+d,y-d,y+d,plot_params) self._line(ax,x-d,x+d,y+d,y-d,plot_params) - return def _setup_figure(self,nq,ng,gate_grid,wire_grid,plot_params): scale = plot_params['scale'] @@ -236,7 +228,6 @@ def _draw_wires(self,ax,nq,gate_grid,wire_grid,plot_params,measured={}): for i in measured: j = measured[i] self._line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) - return def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): scale = plot_params['scale'] @@ -247,7 +238,6 @@ def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): for i in range(nq): j = self._get_flipped_index(labels[i],labels) self._text(ax,xdata[0]-label_buffer,wire_grid[j],self._render_label(labels[i],inits),plot_params) - return def _get_flipped_index(self,target,labels): """Get qubit labels from the rest of the line,and return indices @@ -285,7 +275,7 @@ def _make_schedule(self, item_plos): qubits_in_current_tic = set() for gate in item_plos: qubits = set(gate[1:]) - # print(qubits) + if qubits_in_current_tic.intersection(qubits): # Qubits already in tic, create new tic current_tic = [gate] From 527904d7c7fd175f8be12f9348d57479418e6372 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 08:56:42 +0200 Subject: [PATCH 011/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 108 +++++++++++++++++++++++++---------- 1 file changed, 79 insertions(+), 29 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 470f833fa1..90cb22e089 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -89,6 +89,35 @@ def _plot_quantum_circuit(self, gates,inits={},labels=[],plot_labels=True,**kwar self._draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) return ax + def _plot_lines_circuit(self,labels=[],inits=[],plot_labels=True,**kwargs): + """Use Matplotlib to plot a quantum circuit. + gates List of tuples for each gate in the quantum circuit. + (name,target,control1,control2...). Targets and controls initially + defined in terms of labels. + inits Initialization list of gates, optional + + kwargs Can override plot_parameters + """ + plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, + control_radius = 0.05, not_radius = 0.15, + swap_delta = 0.08, label_buffer = 0.0) + plot_params.update(kwargs) + scale = plot_params['scale'] + + nq = len(labels) + + wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) + gate_grid = np.arange(0.0, nq*scale, scale, dtype=float) + + fig,ax = self._setup_figure(nq,nq,gate_grid,wire_grid,plot_params) + + self._draw_wires(ax,nq,gate_grid,wire_grid,plot_params) + + if plot_labels: + self._draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) + + return ax + def _enumerate_gates(self,l,schedule=False): "Enumerate the gates in a way that can take l as either a list of gates or a schedule" if schedule: @@ -98,6 +127,7 @@ def _enumerate_gates(self,l,schedule=False): else: for i,gate in enumerate(l): yield i,gate + return def _measured_wires(self,l,labels,schedule=False): "measured[i] = j means wire i is measured at step j" @@ -114,6 +144,7 @@ def _draw_gates(self,ax,l,labels,gate_grid,wire_grid,plot_params,measured={},sch self._draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) if len(gate) > 2: # Controlled self._draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) + return def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): linewidth = plot_params['linewidth'] @@ -143,9 +174,10 @@ def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measure self._swapx(ax,x,y,plot_params) else: self._cdot(ax,x,y,plot_params) + return def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): - target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE',UNITARY='U') + target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE',UNITARY='U',MEASURE='M',SX=r'$\sqrt{\text{X}}$',CSX=r'$\sqrt{\text{X}}$') name,target = gate[:2] symbol = target_symbols.get(name,name) # override name with target_symbols x = gate_grid[i] @@ -160,6 +192,7 @@ def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): self._swapx(ax,x,y,plot_params) else: self._text(ax,x,y,symbol,plot_params,box=True) + return def _line(self,ax,x1,x2,y1,y2,plot_params): Line2D = matplotlib.lines.Line2D @@ -175,6 +208,7 @@ def _text(self,ax,x,y,textstr,plot_params,box=False): else: bbox= dict(fill=False,lw=0) ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) + return def _oplus(self,ax,x,y,plot_params): Line2D = matplotlib.lines.Line2D @@ -185,6 +219,7 @@ def _oplus(self,ax,x,y,plot_params): fc='w',fill=False,lw=linewidth) ax.add_patch(c) self._line(ax,x,x,y-not_radius,y+not_radius,plot_params) + return def _cdot(self,ax,x,y,plot_params): Circle = matplotlib.patches.Circle @@ -194,12 +229,14 @@ def _cdot(self,ax,x,y,plot_params): c = Circle((x, y),control_radius*scale, ec='k',fc='k',fill=True,lw=linewidth) ax.add_patch(c) + return def _swapx(self,ax,x,y,plot_params): d = plot_params['swap_delta'] linewidth = plot_params['linewidth'] self._line(ax,x-d,x+d,y-d,y+d,plot_params) self._line(ax,x-d,x+d,y+d,y-d,plot_params) + return def _setup_figure(self,nq,ng,gate_grid,wire_grid,plot_params): scale = plot_params['scale'] @@ -228,6 +265,7 @@ def _draw_wires(self,ax,nq,gate_grid,wire_grid,plot_params,measured={}): for i in measured: j = measured[i] self._line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) + return def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): scale = plot_params['scale'] @@ -238,6 +276,7 @@ def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): for i in range(nq): j = self._get_flipped_index(labels[i],labels) self._text(ax,xdata[0]-label_buffer,wire_grid[j],self._render_label(labels[i],inits),plot_params) + return def _get_flipped_index(self,target,labels): """Get qubit labels from the rest of the line,and return indices @@ -275,7 +314,7 @@ def _make_schedule(self, item_plos): qubits_in_current_tic = set() for gate in item_plos: qubits = set(gate[1:]) - + # print(qubits) if qubits_in_current_tic.intersection(qubits): # Qubits already in tic, create new tic current_tic = [gate] @@ -289,34 +328,45 @@ def _make_schedule(self, item_plos): return schedule def plot_qibo_circuit(self, circuit, scale, cluster_gates): - gates_plot = [] - inits = [] - - for gate in circuit.queue: - init_label = gate.name.upper() - inits.append(init_label) - item = () - item += (init_label, ) - - for qbit in gate._target_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - for qbit in gate._control_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - gates_plot.append(item) - - if cluster_gates: - scheduled_plots = self._make_schedule(gates_plot) - return self._plot_quantum_schedule(scheduled_plots, inits, scale = scale) + + inits = list(range(circuit.nqubits)) + + if len(circuit.queue) > 0: + + labels = [] + for i in range(circuit.nqubits): + labels.append('q_' + str(i)) + + gates_plot = [] + + for gate in circuit.queue: + init_label = gate.name.upper() + + item = () + item += (init_label, ) + + for qbit in gate._target_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + for qbit in gate._control_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + gates_plot.append(item) + + if cluster_gates: + scheduled_plots = self._make_schedule(gates_plot) + return self._plot_quantum_schedule(scheduled_plots, inits, labels, scale = scale) + else: + return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: - return self._plot_quantum_circuit(gates_plot, inits, scale = scale) + + return self._plot_lines_circuit(circuit._wire_names, inits) @staticmethod def save_fig(fig, path_file): From 2e5c5945e8158c2095776c0a8de856b2d6054c2c Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 09:02:27 +0200 Subject: [PATCH 012/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 90cb22e089..37d60663fa 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -366,7 +366,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: - return self._plot_lines_circuit(circuit._wire_names, inits) + return self._plot_lines_circuit(circuit._wire_names, inits, scale = scale) @staticmethod def save_fig(fig, path_file): From ff5e0776d626c5abb7f7b89c3868e50ef104c3f5 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 09:06:42 +0200 Subject: [PATCH 013/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 12 +++++------- 1 file changed, 5 insertions(+), 7 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 37d60663fa..8882406056 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -331,12 +331,11 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): inits = list(range(circuit.nqubits)) - if len(circuit.queue) > 0: - - labels = [] - for i in range(circuit.nqubits): - labels.append('q_' + str(i)) + labels = [] + for i in range(circuit.nqubits): + labels.append('q_' + str(i)) + if len(circuit.queue) > 0: gates_plot = [] for gate in circuit.queue: @@ -365,8 +364,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): else: return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: - - return self._plot_lines_circuit(circuit._wire_names, inits, scale = scale) + return self._plot_lines_circuit(labels, inits, scale = scale) @staticmethod def save_fig(fig, path_file): From 45d737d34a61c63832f2612ec4f4beac7b0966a1 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 09:19:04 +0200 Subject: [PATCH 014/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 8882406056..6c3193edd6 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -9,12 +9,13 @@ class MPLDrawer: def __init__(self): pass - def _plot_quantum_schedule(self, schedule,inits={},labels=[],plot_labels=True,**kwargs): + def _plot_quantum_schedule(self, schedule,inits,labels=[],plot_labels=True,**kwargs): """Use Matplotlib to plot a quantum circuit. schedule List of time steps, each containing a sequence of gates during that step. Each gate is a tuple containing (name,target,control1,control2...). Targets and controls initially defined in terms of labels. - inits Initialization list of gates, optional + inits Initialization list of gates + labels List of qubit labels, optional kwargs Can override plot_parameters """ @@ -49,12 +50,13 @@ def _plot_quantum_schedule(self, schedule,inits={},labels=[],plot_labels=True,** self._draw_gates(ax,schedule,labels,gate_grid,wire_grid,plot_params,measured,schedule=True) return ax - def _plot_quantum_circuit(self, gates,inits={},labels=[],plot_labels=True,**kwargs): + def _plot_quantum_circuit(self, gates,inits,labels=[],plot_labels=True,**kwargs): """Use Matplotlib to plot a quantum circuit. gates List of tuples for each gate in the quantum circuit. (name,target,control1,control2...). Targets and controls initially defined in terms of labels. - inits Initialization list of gates, optional + inits Initialization list of gates + labels List of qubit labels. optional kwargs Can override plot_parameters """ @@ -89,11 +91,9 @@ def _plot_quantum_circuit(self, gates,inits={},labels=[],plot_labels=True,**kwar self._draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) return ax - def _plot_lines_circuit(self,labels=[],inits=[],plot_labels=True,**kwargs): + def _plot_lines_circuit(self,labels,inits,plot_labels=True,**kwargs): """Use Matplotlib to plot a quantum circuit. - gates List of tuples for each gate in the quantum circuit. - (name,target,control1,control2...). Targets and controls initially - defined in terms of labels. + labels List of qubit labels inits Initialization list of gates, optional kwargs Can override plot_parameters From ddd91bc1867b1764fed9fcf12a93ea85aab4354b Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 09:20:36 +0200 Subject: [PATCH 015/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 6c3193edd6..d058c7a9d4 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -314,7 +314,7 @@ def _make_schedule(self, item_plos): qubits_in_current_tic = set() for gate in item_plos: qubits = set(gate[1:]) - # print(qubits) + if qubits_in_current_tic.intersection(qubits): # Qubits already in tic, create new tic current_tic = [gate] From 0cd600b350e313ac61e6e19035e72fc3f207ea11 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 11:25:20 +0200 Subject: [PATCH 016/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 38 ++++++++++++++++-------------------- 1 file changed, 17 insertions(+), 21 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index d058c7a9d4..fadbb2fb99 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -308,25 +308,6 @@ def _render_label(self,label, inits={}): return r'$|%s\rangle$' % inits[label] return r'$|%s\rangle$' % label - def _make_schedule(self, item_plos): - schedule = [[]] - current_tic = schedule[-1] - qubits_in_current_tic = set() - for gate in item_plos: - qubits = set(gate[1:]) - - if qubits_in_current_tic.intersection(qubits): - # Qubits already in tic, create new tic - current_tic = [gate] - qubits_in_current_tic = qubits - schedule.append(current_tic) - else: - # Add to current tic - current_tic.append(gate) - qubits_in_current_tic = qubits_in_current_tic.union(qubits) - - return schedule - def plot_qibo_circuit(self, circuit, scale, cluster_gates): inits = list(range(circuit.nqubits)) @@ -359,8 +340,23 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): gates_plot.append(item) if cluster_gates: - scheduled_plots = self._make_schedule(gates_plot) - return self._plot_quantum_schedule(scheduled_plots, inits, labels, scale = scale) + cluster_gates = [] + temp_gates = [] + for i in list(range(len(gates_plot))): + item = gates_plot[i] + if len(item) == 2 and i > 0: + if len(temp_gates) > 0 and item[1] == gates_plot[i-1][1]: + gates = [] + temp_gates.append(item) + else: + if len(temp_gates) != 0: + cluster_gates.append(temp_gates) + temp_gates = [] + cluster_gates.append([item]) + i = i + 1 + cluster_gates.append(temp_gates) + temp_gates = [] + return self._plot_quantum_schedule(cluster_gates, inits, labels, scale = scale) else: return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: From a56b9b6d0ac3b033f35d91613e78cdb7c6ca513f Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 11:47:10 +0200 Subject: [PATCH 017/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 42 ++++++++++++++++++++---------------- 1 file changed, 23 insertions(+), 19 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index fadbb2fb99..8354e94bb8 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -308,6 +308,26 @@ def _render_label(self,label, inits={}): return r'$|%s\rangle$' % inits[label] return r'$|%s\rangle$' % label + def _make_cluster_gates(self,gates_items): + cluster_gates = [] + temp_gates = [] + for i in list(range(len(gates_items))): + item = gates_items[i] + if len(item) == 2 and i > 0: + if len(temp_gates) > 0 and item[1] == gates_items[i-1][1]: + gates = [] + temp_gates.append(item) + else: + if len(temp_gates) != 0: + cluster_gates.append(temp_gates) + temp_gates = [] + cluster_gates.append([item]) + i = i + 1 + cluster_gates.append(temp_gates) + temp_gates = [] + + return cluster_gates + def plot_qibo_circuit(self, circuit, scale, cluster_gates): inits = list(range(circuit.nqubits)) @@ -340,25 +360,9 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): gates_plot.append(item) if cluster_gates: - cluster_gates = [] - temp_gates = [] - for i in list(range(len(gates_plot))): - item = gates_plot[i] - if len(item) == 2 and i > 0: - if len(temp_gates) > 0 and item[1] == gates_plot[i-1][1]: - gates = [] - temp_gates.append(item) - else: - if len(temp_gates) != 0: - cluster_gates.append(temp_gates) - temp_gates = [] - cluster_gates.append([item]) - i = i + 1 - cluster_gates.append(temp_gates) - temp_gates = [] - return self._plot_quantum_schedule(cluster_gates, inits, labels, scale = scale) - else: - return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) + return self._plot_quantum_schedule(self._make_cluster_gates(gates_plot), inits, labels, scale = scale) + + return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: return self._plot_lines_circuit(labels, inits, scale = scale) From 4f9c4d09eb3f89d7bb7e72abf731efdd7887510b Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 12:00:03 +0200 Subject: [PATCH 018/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 10 ---------- 1 file changed, 10 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 8354e94bb8..b701140c90 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -127,7 +127,6 @@ def _enumerate_gates(self,l,schedule=False): else: for i,gate in enumerate(l): yield i,gate - return def _measured_wires(self,l,labels,schedule=False): "measured[i] = j means wire i is measured at step j" @@ -144,7 +143,6 @@ def _draw_gates(self,ax,l,labels,gate_grid,wire_grid,plot_params,measured={},sch self._draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) if len(gate) > 2: # Controlled self._draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) - return def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): linewidth = plot_params['linewidth'] @@ -174,7 +172,6 @@ def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measure self._swapx(ax,x,y,plot_params) else: self._cdot(ax,x,y,plot_params) - return def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE',UNITARY='U',MEASURE='M',SX=r'$\sqrt{\text{X}}$',CSX=r'$\sqrt{\text{X}}$') @@ -192,7 +189,6 @@ def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): self._swapx(ax,x,y,plot_params) else: self._text(ax,x,y,symbol,plot_params,box=True) - return def _line(self,ax,x1,x2,y1,y2,plot_params): Line2D = matplotlib.lines.Line2D @@ -208,7 +204,6 @@ def _text(self,ax,x,y,textstr,plot_params,box=False): else: bbox= dict(fill=False,lw=0) ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) - return def _oplus(self,ax,x,y,plot_params): Line2D = matplotlib.lines.Line2D @@ -219,7 +214,6 @@ def _oplus(self,ax,x,y,plot_params): fc='w',fill=False,lw=linewidth) ax.add_patch(c) self._line(ax,x,x,y-not_radius,y+not_radius,plot_params) - return def _cdot(self,ax,x,y,plot_params): Circle = matplotlib.patches.Circle @@ -229,14 +223,12 @@ def _cdot(self,ax,x,y,plot_params): c = Circle((x, y),control_radius*scale, ec='k',fc='k',fill=True,lw=linewidth) ax.add_patch(c) - return def _swapx(self,ax,x,y,plot_params): d = plot_params['swap_delta'] linewidth = plot_params['linewidth'] self._line(ax,x-d,x+d,y-d,y+d,plot_params) self._line(ax,x-d,x+d,y+d,y-d,plot_params) - return def _setup_figure(self,nq,ng,gate_grid,wire_grid,plot_params): scale = plot_params['scale'] @@ -265,7 +257,6 @@ def _draw_wires(self,ax,nq,gate_grid,wire_grid,plot_params,measured={}): for i in measured: j = measured[i] self._line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) - return def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): scale = plot_params['scale'] @@ -276,7 +267,6 @@ def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): for i in range(nq): j = self._get_flipped_index(labels[i],labels) self._text(ax,xdata[0]-label_buffer,wire_grid[j],self._render_label(labels[i],inits),plot_params) - return def _get_flipped_index(self,target,labels): """Get qubit labels from the rest of the line,and return indices From 78229145c184b3e80e5db16164e597b372a0bf2d Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 12:01:34 +0200 Subject: [PATCH 019/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index b701140c90..976fb67a19 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -313,7 +313,9 @@ def _make_cluster_gates(self,gates_items): temp_gates = [] cluster_gates.append([item]) i = i + 1 - cluster_gates.append(temp_gates) + + if len(temp_gates) > 0: + cluster_gates.append(temp_gates) temp_gates = [] return cluster_gates From d604d0390baf94875f81dc31674d92867b5ae483 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 12:36:32 +0200 Subject: [PATCH 020/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 22 +++++++++++++++++++--- 1 file changed, 19 insertions(+), 3 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 976fb67a19..863af8b5ea 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -301,22 +301,37 @@ def _render_label(self,label, inits={}): def _make_cluster_gates(self,gates_items): cluster_gates = [] temp_gates = [] + temp_mgates = [] for i in list(range(len(gates_items))): item = gates_items[i] - if len(item) == 2 and i > 0: + + if (len(item) == 2) and i > 0 and 'MEASURE' not in item[0]: if len(temp_gates) > 0 and item[1] == gates_items[i-1][1]: gates = [] temp_gates.append(item) + elif 'MEASURE' in item[0]: + temp_mgates.append(item) else: if len(temp_gates) != 0: cluster_gates.append(temp_gates) temp_gates = [] - cluster_gates.append([item]) + + if len(temp_mgates) != 0: + cluster_gates.append(temp_mgates) + temp_mgates = [] + + if 'MEASURE' not in item[0]: + cluster_gates.append([item]) i = i + 1 if len(temp_gates) > 0: cluster_gates.append(temp_gates) + + if len(temp_mgates) > 0: + cluster_gates.append(temp_mgates) + temp_gates = [] + temp_mgates = [] return cluster_gates @@ -352,7 +367,8 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): gates_plot.append(item) if cluster_gates: - return self._plot_quantum_schedule(self._make_cluster_gates(gates_plot), inits, labels, scale = scale) + gates_cluster = self._make_cluster_gates(gates_plot) + return self._plot_quantum_schedule(gates_cluster, inits, labels, scale = scale) return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: From 739d5760e1dc520ab0853d1ee873d537c0e49a0e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 12:54:59 +0200 Subject: [PATCH 021/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 863af8b5ea..8f3bec3dd9 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -1,6 +1,7 @@ -# MPLDrawer craeted from code provided by Rick Muller +# Some functions in MPLDrawer are from code provided by Rick Muller # Simplified Plotting Routines for Quantum Circuits # https://github.com/rpmuller/PlotQCircuit +# import matplotlib import numpy as np From 7633b211584310722e6eff563af432c5b32ffe7e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 12:58:41 +0200 Subject: [PATCH 022/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 8f3bec3dd9..8553158a83 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -92,7 +92,7 @@ def _plot_quantum_circuit(self, gates,inits,labels=[],plot_labels=True,**kwargs) self._draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) return ax - def _plot_lines_circuit(self,labels,inits,plot_labels=True,**kwargs): + def _plot_lines_circuit(self,inits,labels,plot_labels=True,**kwargs): """Use Matplotlib to plot a quantum circuit. labels List of qubit labels inits Initialization list of gates, optional @@ -373,7 +373,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) else: - return self._plot_lines_circuit(labels, inits, scale = scale) + return self._plot_lines_circuit(inits, labels, scale = scale) @staticmethod def save_fig(fig, path_file): From 4392cab1c60d491bd4d64bc6ff9c838978441bb3 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 13:15:47 +0200 Subject: [PATCH 023/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 399 ++++++++++++++++++++++------------- 1 file changed, 247 insertions(+), 152 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 8553158a83..1114fedf3e 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -5,12 +5,14 @@ import matplotlib import numpy as np -class MPLDrawer: +class MPLDrawer: def __init__(self): - pass + pass - def _plot_quantum_schedule(self, schedule,inits,labels=[],plot_labels=True,**kwargs): + def _plot_quantum_schedule( + self, schedule, inits, labels=[], plot_labels=True, **kwargs + ): """Use Matplotlib to plot a quantum circuit. schedule List of time steps, each containing a sequence of gates during that step. Each gate is a tuple containing (name,target,control1,control2...). @@ -20,38 +22,55 @@ def _plot_quantum_schedule(self, schedule,inits,labels=[],plot_labels=True,**kwa kwargs Can override plot_parameters """ - plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, - control_radius = 0.05, not_radius = 0.15, - swap_delta = 0.08, label_buffer = 0.0) + plot_params = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + ) plot_params.update(kwargs) - scale = plot_params['scale'] + scale = plot_params["scale"] # Create labels from gates. This will become slow if there are a lot # of gates, in which case move to an ordered dictionary if not labels: labels = [] - for i,gate in self._enumerate_gates(schedule,schedule=True): + for i, gate in self._enumerate_gates(schedule, schedule=True): for label in gate[1:]: if label not in labels: labels.append(label) nq = len(labels) nt = len(schedule) - wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) - gate_grid = np.arange(0.0, nt*scale, scale, dtype=float) + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) + gate_grid = np.arange(0.0, nt * scale, scale, dtype=float) - fig,ax = self._setup_figure(nq,nt,gate_grid,wire_grid,plot_params) + fig, ax = self._setup_figure(nq, nt, gate_grid, wire_grid, plot_params) - measured = self._measured_wires(schedule,labels,schedule=True) - self._draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured) + measured = self._measured_wires(schedule, labels, schedule=True) + self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) if plot_labels: - self._draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) - - self._draw_gates(ax,schedule,labels,gate_grid,wire_grid,plot_params,measured,schedule=True) + self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) + + self._draw_gates( + ax, + schedule, + labels, + gate_grid, + wire_grid, + plot_params, + measured, + schedule=True, + ) return ax - def _plot_quantum_circuit(self, gates,inits,labels=[],plot_labels=True,**kwargs): + def _plot_quantum_circuit( + self, gates, inits, labels=[], plot_labels=True, **kwargs + ): """Use Matplotlib to plot a quantum circuit. gates List of tuples for each gate in the quantum circuit. (name,target,control1,control2...). Targets and controls initially @@ -61,215 +80,288 @@ def _plot_quantum_circuit(self, gates,inits,labels=[],plot_labels=True,**kwargs) kwargs Can override plot_parameters """ - plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, - control_radius = 0.05, not_radius = 0.15, - swap_delta = 0.08, label_buffer = 0.0) + plot_params = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + ) plot_params.update(kwargs) - scale = plot_params['scale'] + scale = plot_params["scale"] # Create labels from gates. This will become slow if there are a lot # of gates, in which case move to an ordered dictionary if not labels: labels = [] - for i,gate in self._enumerate_gates(gates): + for i, gate in self._enumerate_gates(gates): for label in gate[1:]: if label not in labels: labels.append(label) nq = len(labels) ng = len(gates) - wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) - gate_grid = np.arange(0.0, ng*scale, scale, dtype=float) + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) + gate_grid = np.arange(0.0, ng * scale, scale, dtype=float) - fig,ax = self._setup_figure(nq,ng,gate_grid,wire_grid,plot_params) + fig, ax = self._setup_figure(nq, ng, gate_grid, wire_grid, plot_params) - measured = self._measured_wires(gates,labels) - self._draw_wires(ax,nq,gate_grid,wire_grid,plot_params,measured) + measured = self._measured_wires(gates, labels) + self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) if plot_labels: - self._draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) + self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - self._draw_gates(ax,gates,labels,gate_grid,wire_grid,plot_params,measured) + self._draw_gates(ax, gates, labels, gate_grid, wire_grid, plot_params, measured) return ax - def _plot_lines_circuit(self,inits,labels,plot_labels=True,**kwargs): + def _plot_lines_circuit(self, inits, labels, plot_labels=True, **kwargs): """Use Matplotlib to plot a quantum circuit. + inits Initialization list of gates labels List of qubit labels - inits Initialization list of gates, optional kwargs Can override plot_parameters """ - plot_params = dict(scale = 1.0,fontsize = 14.0, linewidth = 1.0, - control_radius = 0.05, not_radius = 0.15, - swap_delta = 0.08, label_buffer = 0.0) + plot_params = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + ) plot_params.update(kwargs) - scale = plot_params['scale'] + scale = plot_params["scale"] nq = len(labels) - wire_grid = np.arange(0.0, nq*scale, scale, dtype=float) - gate_grid = np.arange(0.0, nq*scale, scale, dtype=float) + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) + gate_grid = np.arange(0.0, nq * scale, scale, dtype=float) - fig,ax = self._setup_figure(nq,nq,gate_grid,wire_grid,plot_params) + fig, ax = self._setup_figure(nq, nq, gate_grid, wire_grid, plot_params) - self._draw_wires(ax,nq,gate_grid,wire_grid,plot_params) + self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params) if plot_labels: - self._draw_labels(ax,labels,inits,gate_grid,wire_grid,plot_params) + self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) return ax - def _enumerate_gates(self,l,schedule=False): + def _enumerate_gates(self, l, schedule=False): "Enumerate the gates in a way that can take l as either a list of gates or a schedule" if schedule: - for i,gates in enumerate(l): + for i, gates in enumerate(l): for gate in gates: - yield i,gate + yield i, gate else: - for i,gate in enumerate(l): - yield i,gate + for i, gate in enumerate(l): + yield i, gate - def _measured_wires(self,l,labels,schedule=False): + def _measured_wires(self, l, labels, schedule=False): "measured[i] = j means wire i is measured at step j" measured = {} - for i,gate in self._enumerate_gates(l,schedule=schedule): - name,target = gate[:2] - j = self._get_flipped_index(target,labels) - if name.startswith('M'): + for i, gate in self._enumerate_gates(l, schedule=schedule): + name, target = gate[:2] + j = self._get_flipped_index(target, labels) + if name.startswith("M"): measured[j] = i return measured - def _draw_gates(self,ax,l,labels,gate_grid,wire_grid,plot_params,measured={},schedule=False): - for i,gate in self._enumerate_gates(l,schedule=schedule): - self._draw_target(ax,i,gate,labels,gate_grid,wire_grid,plot_params) - if len(gate) > 2: # Controlled - self._draw_controls(ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured) - - def _draw_controls(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params,measured={}): - linewidth = plot_params['linewidth'] - scale = plot_params['scale'] - control_radius = plot_params['control_radius'] - - name,target = gate[:2] - target_index = self._get_flipped_index(target,labels) + def _draw_gates( + self, + ax, + l, + labels, + gate_grid, + wire_grid, + plot_params, + measured={}, + schedule=False, + ): + for i, gate in self._enumerate_gates(l, schedule=schedule): + self._draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) + if len(gate) > 2: # Controlled + self._draw_controls( + ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured + ) + + def _draw_controls( + self, ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured={} + ): + linewidth = plot_params["linewidth"] + scale = plot_params["scale"] + control_radius = plot_params["control_radius"] + + name, target = gate[:2] + target_index = self._get_flipped_index(target, labels) controls = gate[2:] - control_indices = self._get_flipped_indices(controls,labels) + control_indices = self._get_flipped_indices(controls, labels) gate_indices = control_indices + [target_index] min_wire = min(gate_indices) max_wire = max(gate_indices) - self._line(ax,gate_grid[i],gate_grid[i],wire_grid[min_wire],wire_grid[max_wire],plot_params) + self._line( + ax, + gate_grid[i], + gate_grid[i], + wire_grid[min_wire], + wire_grid[max_wire], + plot_params, + ) ismeasured = False for index in control_indices: - if measured.get(index,1000) < i: + if measured.get(index, 1000) < i: ismeasured = True if ismeasured: - dy = 0.04 # TODO: put in plot_params - self._line(ax,gate_grid[i]+dy,gate_grid[i]+dy,wire_grid[min_wire],wire_grid[max_wire],plot_params) + dy = 0.04 # TODO: put in plot_params + self._line( + ax, + gate_grid[i] + dy, + gate_grid[i] + dy, + wire_grid[min_wire], + wire_grid[max_wire], + plot_params, + ) for ci in control_indices: x = gate_grid[i] y = wire_grid[ci] - if name in ['SWAP', 'ISWAP', 'SISWAP', 'FISWAP']: - self._swapx(ax,x,y,plot_params) + if name in ["SWAP", "ISWAP", "SISWAP", "FISWAP"]: + self._swapx(ax, x, y, plot_params) else: - self._cdot(ax,x,y,plot_params) - - def _draw_target(self,ax,i,gate,labels,gate_grid,wire_grid,plot_params): - target_symbols = dict(CNOT='X',CPHASE='Z',NOP='',CX='X',CY='Y',CZ='Z',CCX='X',DEUTSCH='DE',UNITARY='U',MEASURE='M',SX=r'$\sqrt{\text{X}}$',CSX=r'$\sqrt{\text{X}}$') - name,target = gate[:2] - symbol = target_symbols.get(name,name) # override name with target_symbols + self._cdot(ax, x, y, plot_params) + + def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): + target_symbols = dict( + CNOT="X", + CPHASE="Z", + NOP="", + CX="X", + CY="Y", + CZ="Z", + CCX="X", + DEUTSCH="DE", + UNITARY="U", + MEASURE="M", + SX=r"$\sqrt{\text{X}}$", + CSX=r"$\sqrt{\text{X}}$", + ) + name, target = gate[:2] + symbol = target_symbols.get(name, name) # override name with target_symbols x = gate_grid[i] - target_index = self._get_flipped_index(target,labels) + target_index = self._get_flipped_index(target, labels) y = wire_grid[target_index] - if not symbol: return - if name in ['CNOT','TOFFOLI']: - self._oplus(ax,x,y,plot_params) - elif name in ['CPHASE']: - self._cdot(ax,x,y,plot_params) - elif name in ['SWAP', 'ISWAP', 'SISWAP', 'FISWAP']: - self._swapx(ax,x,y,plot_params) + if not symbol: + return + if name in ["CNOT", "TOFFOLI"]: + self._oplus(ax, x, y, plot_params) + elif name in ["CPHASE"]: + self._cdot(ax, x, y, plot_params) + elif name in ["SWAP", "ISWAP", "SISWAP", "FISWAP"]: + self._swapx(ax, x, y, plot_params) else: - self._text(ax,x,y,symbol,plot_params,box=True) + self._text(ax, x, y, symbol, plot_params, box=True) - def _line(self,ax,x1,x2,y1,y2,plot_params): + def _line(self, ax, x1, x2, y1, y2, plot_params): Line2D = matplotlib.lines.Line2D - line = Line2D((x1,x2), (y1,y2), - color='k',lw=plot_params['linewidth']) + line = Line2D((x1, x2), (y1, y2), color="k", lw=plot_params["linewidth"]) ax.add_line(line) - def _text(self,ax,x,y,textstr,plot_params,box=False): - linewidth = plot_params['linewidth'] - fontsize = plot_params['fontsize'] + def _text(self, ax, x, y, textstr, plot_params, box=False): + linewidth = plot_params["linewidth"] + fontsize = plot_params["fontsize"] if box: - bbox = dict(ec='k',fc='w',fill=True,lw=linewidth) + bbox = dict(ec="k", fc="w", fill=True, lw=linewidth) else: - bbox= dict(fill=False,lw=0) - ax.text(x,y,textstr,color='k',ha='center',va='center',bbox=bbox,size=fontsize) + bbox = dict(fill=False, lw=0) + ax.text( + x, y, textstr, color="k", ha="center", va="center", bbox=bbox, size=fontsize + ) - def _oplus(self,ax,x,y,plot_params): + def _oplus(self, ax, x, y, plot_params): Line2D = matplotlib.lines.Line2D Circle = matplotlib.patches.Circle - not_radius = plot_params['not_radius'] - linewidth = plot_params['linewidth'] - c = Circle((x, y),not_radius,ec='k', - fc='w',fill=False,lw=linewidth) + not_radius = plot_params["not_radius"] + linewidth = plot_params["linewidth"] + c = Circle((x, y), not_radius, ec="k", fc="w", fill=False, lw=linewidth) ax.add_patch(c) - self._line(ax,x,x,y-not_radius,y+not_radius,plot_params) + self._line(ax, x, x, y - not_radius, y + not_radius, plot_params) - def _cdot(self,ax,x,y,plot_params): + def _cdot(self, ax, x, y, plot_params): Circle = matplotlib.patches.Circle - control_radius = plot_params['control_radius'] - scale = plot_params['scale'] - linewidth = plot_params['linewidth'] - c = Circle((x, y),control_radius*scale, - ec='k',fc='k',fill=True,lw=linewidth) + control_radius = plot_params["control_radius"] + scale = plot_params["scale"] + linewidth = plot_params["linewidth"] + c = Circle( + (x, y), control_radius * scale, ec="k", fc="k", fill=True, lw=linewidth + ) ax.add_patch(c) - def _swapx(self,ax,x,y,plot_params): - d = plot_params['swap_delta'] - linewidth = plot_params['linewidth'] - self._line(ax,x-d,x+d,y-d,y+d,plot_params) - self._line(ax,x-d,x+d,y+d,y-d,plot_params) + def _swapx(self, ax, x, y, plot_params): + d = plot_params["swap_delta"] + linewidth = plot_params["linewidth"] + self._line(ax, x - d, x + d, y - d, y + d, plot_params) + self._line(ax, x - d, x + d, y + d, y - d, plot_params) - def _setup_figure(self,nq,ng,gate_grid,wire_grid,plot_params): - scale = plot_params['scale'] + def _setup_figure(self, nq, ng, gate_grid, wire_grid, plot_params): + scale = plot_params["scale"] fig = matplotlib.pyplot.figure( - figsize=(ng*scale, nq*scale), - facecolor='w', - edgecolor='w' + figsize=(ng * scale, nq * scale), facecolor="w", edgecolor="w" ) - ax = fig.add_subplot(1, 1, 1,frameon=True) + ax = fig.add_subplot(1, 1, 1, frameon=True) ax.set_axis_off() - offset = 0.5*scale + offset = 0.5 * scale ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) - ax.set_aspect('equal') - return fig,ax + ax.set_aspect("equal") + return fig, ax - def _draw_wires(self,ax,nq,gate_grid,wire_grid,plot_params,measured={}): - scale = plot_params['scale'] - linewidth = plot_params['linewidth'] + def _draw_wires(self, ax, nq, gate_grid, wire_grid, plot_params, measured={}): + scale = plot_params["scale"] + linewidth = plot_params["linewidth"] xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) for i in range(nq): - self._line(ax,gate_grid[0]-scale,gate_grid[-1]+scale,wire_grid[i],wire_grid[i],plot_params) + self._line( + ax, + gate_grid[0] - scale, + gate_grid[-1] + scale, + wire_grid[i], + wire_grid[i], + plot_params, + ) # Add the doubling for measured wires: - dy=0.04 # TODO: add to plot_params + dy = 0.04 # TODO: add to plot_params for i in measured: j = measured[i] - self._line(ax,gate_grid[j],gate_grid[-1]+scale,wire_grid[i]+dy,wire_grid[i]+dy,plot_params) - - def _draw_labels(self,ax,labels,inits,gate_grid,wire_grid,plot_params): - scale = plot_params['scale'] - label_buffer = plot_params['label_buffer'] - fontsize = plot_params['fontsize'] + self._line( + ax, + gate_grid[j], + gate_grid[-1] + scale, + wire_grid[i] + dy, + wire_grid[i] + dy, + plot_params, + ) + + def _draw_labels(self, ax, labels, inits, gate_grid, wire_grid, plot_params): + scale = plot_params["scale"] + label_buffer = plot_params["label_buffer"] + fontsize = plot_params["fontsize"] nq = len(labels) xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) for i in range(nq): - j = self._get_flipped_index(labels[i],labels) - self._text(ax,xdata[0]-label_buffer,wire_grid[j],self._render_label(labels[i],inits),plot_params) - - def _get_flipped_index(self,target,labels): + j = self._get_flipped_index(labels[i], labels) + self._text( + ax, + xdata[0] - label_buffer, + wire_grid[j], + self._render_label(labels[i], inits), + plot_params, + ) + + def _get_flipped_index(self, target, labels): """Get qubit labels from the rest of the line,and return indices >>> _get_flipped_index('q0', ['q0', 'q1']) @@ -279,11 +371,12 @@ def _get_flipped_index(self,target,labels): """ nq = len(labels) i = labels.index(target) - return nq-i-1 + return nq - i - 1 - def _get_flipped_indices(self,targets,labels): return [self._get_flipped_index(t,labels) for t in targets] + def _get_flipped_indices(self, targets, labels): + return [self._get_flipped_index(t, labels) for t in targets] - def _render_label(self,label, inits={}): + def _render_label(self, label, inits={}): """Slightly more flexible way to render labels. >>> _render_label('q0') @@ -294,23 +387,23 @@ def _render_label(self,label, inits={}): if label in inits: s = inits[label] if s is None: - return '' + return "" else: - return r'$|%s\rangle$' % inits[label] - return r'$|%s\rangle$' % label + return r"$|%s\rangle$" % inits[label] + return r"$|%s\rangle$" % label - def _make_cluster_gates(self,gates_items): + def _make_cluster_gates(self, gates_items): cluster_gates = [] temp_gates = [] temp_mgates = [] for i in list(range(len(gates_items))): item = gates_items[i] - if (len(item) == 2) and i > 0 and 'MEASURE' not in item[0]: - if len(temp_gates) > 0 and item[1] == gates_items[i-1][1]: + if (len(item) == 2) and i > 0 and "MEASURE" not in item[0]: + if len(temp_gates) > 0 and item[1] == gates_items[i - 1][1]: gates = [] temp_gates.append(item) - elif 'MEASURE' in item[0]: + elif "MEASURE" in item[0]: temp_mgates.append(item) else: if len(temp_gates) != 0: @@ -321,7 +414,7 @@ def _make_cluster_gates(self,gates_items): cluster_gates.append(temp_mgates) temp_mgates = [] - if 'MEASURE' not in item[0]: + if "MEASURE" not in item[0]: cluster_gates.append([item]) i = i + 1 @@ -342,7 +435,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): labels = [] for i in range(circuit.nqubits): - labels.append('q_' + str(i)) + labels.append("q_" + str(i)) if len(circuit.queue) > 0: gates_plot = [] @@ -351,7 +444,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): init_label = gate.name.upper() item = () - item += (init_label, ) + item += (init_label,) for qbit in gate._target_qubits: if qbit is tuple: @@ -369,12 +462,14 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): if cluster_gates: gates_cluster = self._make_cluster_gates(gates_plot) - return self._plot_quantum_schedule(gates_cluster, inits, labels, scale = scale) + return self._plot_quantum_schedule( + gates_cluster, inits, labels, scale=scale + ) - return self._plot_quantum_circuit(gates_plot, inits, labels, scale = scale) + return self._plot_quantum_circuit(gates_plot, inits, labels, scale=scale) else: - return self._plot_lines_circuit(inits, labels, scale = scale) + return self._plot_lines_circuit(inits, labels, scale=scale) @staticmethod def save_fig(fig, path_file): - return fig.savefig(path_file, bbox_inches='tight') + return fig.savefig(path_file, bbox_inches="tight") From 94e6948e77f0b34c2e9219776e90acbfd28e308c Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 16:50:38 +0200 Subject: [PATCH 024/116] integration of matplotlib circuit drawer --- examples/circuit-draw-mpl/file2.png | Bin 0 -> 17180 bytes .../qibo-draw-circuit-matplotlib.ipynb | 492 ++++++++++++++++++ src/qibo/models/mpldrawer.py | 3 + 3 files changed, 495 insertions(+) create mode 100644 examples/circuit-draw-mpl/file2.png create mode 100644 examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb diff --git a/examples/circuit-draw-mpl/file2.png b/examples/circuit-draw-mpl/file2.png new file mode 100644 index 0000000000000000000000000000000000000000..b4f1702f50f53c24e1f641ea471bad6175ea45ca GIT binary patch literal 17180 zcmdsfby(DE-uG}+P!Tv52nrYo3JQvJs)$N=Is+=*T|=rzI0mAGNFyK}A|M?m9a19= z(mB-7@qTY`chByg-S^q|dj5ExcdpCp3^4Kg-SPc?>OPMYSUQ@G!3H#fO^+|j_+&cw>{5~lzs z&$;8q_V(6xLR?%He|-U`m8}sM^XXF#@F9DwZ)(|LFf@12Ke9ye1QQJA>LaOZS5%$D zC%fFS%?>4-o5RN|Fdgi_4NBfWX>7+Q^J3PKuhewFAU%jh()*G2jT&s)XUi$uqMO3` z>2!r}Tr6H`7KENLY$x{)W~}!%nc~a2p%G^ha7>Qo==~FOtFg@HyU)}ZalQ&EUw7>2 z=w5LXn{z4E>Az4T;^NuO9MEN%O9@v7j|<1kns#kJEnD5sO}6#4?7~&n?cW`_Ua@og z*{9twI_Pox$ccm7&-R_t|7Gi$*PY*Fw|{lv>GM6?&%FPqeb~8%rd`glKYrY8Gv^ET zJ4jETl$dxXA&P(_70T#Ev8^n4Y<$leC|KOOrO3W1;<>36`70I8*S>uD@=o&{I|ql| zvgYg8uit5>$-AG(%kpqCshPXhQ}QiWeBoUFP%*k~FC*t4!cPiIRDR{=eNk(uqNNq` zE-T9*QxnVgti@E#)HKNm#Ag^A##V-FoZT&d4(Qt|u*6_bjh;_-mWxcPZ|e)U%S zhYuezh?7`2~@*h5UFcvONE`(dM7*A?U z#})DzHyp2x5GG7(hJ=K`8-wb?1!Em2+XY|a%m4VrWv&r|cJWf>p38&5$;rvKO1#!S zWo4Ix0s}{i7rRrOHrsQ|4*&XVw3pY=!AYLg!s=bScA0#Cd#63$E`gn${m`*v6Qlla zI);YvFVAVkFp1)g$6M3J8sEsItp{`Iw!#yKjWw4~dTCl&*KKTU9zT25y0$#WtM_%^ zr(yd*@dY%i8y);G0!1nw9wpw?jLEq@9=H5NW-F-ta<$V6h$XA@HJ9p*hiXDB6Ms#g zo{QSVmisXi3LM7gdmqrWwrglC)syCksqd` zOL1Ra2<0*HKXCBiVP@tGlcxC5+|qT6fVz;tz_{FQyv*|QGQRg7ML3SzV_={%K>O|O zdzK~3hLdesH{j1^5qejzUJZQl;`QUldq4HVHT%aN zefl&5za=(nZ%DXMLUMMt>iP<)sV3x7OQzlpG@qib3#!+zU$50Ax-Lw#4a`x~b6+#e z(h?LDtUE_Xs;H`JY)R4Jz4P%me5u>!E3R7hx$=_rOruKARoDeyi+lI&YYww2Ng5c? ze-jrs65-UHw3x?CA?vz0r3RPRi9H)`(V1tHoSNF~O?A}NLO0hk;^fJb^V6SbT;t!8 z3plVg<=OPx&yOfse1Cf-DJhA!gN_rM`1I*MDP=z<(NMSUw{I^{G4R~X&(GJ+w>8Kr z=ze>GO(C**qAhE@ix5t%avEtkAtj#ra8O|_)5>!~YqqBZif3-6`LvkWhIhHZdHt&TdO~a3 zt)R$A9gf@naToQzo;h_&;>3v)W36dn62l78(#n>W>D0_(sbcOc0Y;8=r8MB&wyTCuwBptV~*YrhIrnF`nVMp5n366xAwt z1FjuDIv%b~7~B6X_6DPeId5!JwTNi9Zyn*i#Vz-Z<>8gFlne&Z@zj;sFXLTIS@@_F zPKP2T-FX}g;kjkY9=PmjE|moNmSA0vq$HID_LC>C&JEWS(2rcDYmH5B`p839+DhcY z_!z|8^7t&;<6uF$&wQc7Pv#J?su36E_k?ij6eTt`DxYRyX)YA!;!;qaB)vjK1qz$! z@<4#UM_#Q{$9oG>>n*FZqN2rhf-t`NIof8ej<(k_bc&C8q$V7RsB2YS>~_t7+8Y=Z z)ic6t2DR_B6rs4Qu+}ieAvKHMJ@W6CVIe0rFIso)2VErR4o)7AHD`;C_i`pCCfs4Q z_#cnhLfxn{^0Ay}&fILI;hHeR<=aY9(w=)hpAjOfk&gYw7UdSBm1Ve|^1SRaiP)pd z>^`qle4^4az3t)}z+GVyKBXuzOAXvQq>ds!%%%x226^{SaT8~ z!c2+`KZ3kjE&VT;f4d%0gg86keK|w()OZ|Q=?+j#o2m=K#j*2S$-H0LL->U@BUG!G=Z42OR*8%DE_q}(Y#+jWr%3ovqd5%p_m7#Lo@VtM=MAog zCU#axNSjSQyy4M7Hq(;lYO1Qn6W=qTZ|~i`JF(3&tIeJ?)*_TkQ#$zamOWf4zWn=p zi?H@ws|?qv{PI4bqge;=c6ynbo!U<3=Bcn1(qYX?!gsa2Jb!Bp`-_&2PC7x?69;Ru zi6f&Z1_s0!K1RD3pY!z@*PwCL!|{>=#r%%Y@bm3g`P zc`DdDr5ZiBfn&^F{{8!Nri3VZ{GUH>=;fBI_3k3eGOT?k^Dauvy}GIHKWk?Tkp+HO4k=UCQFxVttO&8H}Y}*>oeud8G`R)Vm@}qNK&rWMF^WkEWWtG zlqn8d$l+^8o=q&g=mCwGbsRQ<{oJ{1nRj%ww5^4k^P^3UQVXzF_?@58h_5wpR*K#E zxYMWHMpdP5H9>s6Qp~bbz!j!hl!fIp)3Iab#O9;`_vS<;(#91 zoT*@0cIr}TQk&AprO-~K?4k<}GIA@wD#sPVgX7)7}omcqWC zM5Dcq+Ev>|fBlml&&^_VKe-g-PukpU>oJYU()y0|VYnZo=#z8>`du+Fbp3 z&Fy3bDCpg8b8=G3(BAp1x>MugSe#z&WiysdpVosV!Cs_JFqm<@2@%>`e8WI zRldL652|tTA^4VulyvMDE-1!c_f2-d!rF5rcBjEd>>@8H!ouKSFrh&W4T>aK`(~}F z`BT1Tah|*6pxJR2&RuNyH8_E<{260_sw-;%i!TGOG}>ty9wZLHZ)Z-NxI!%5EZHja zLQ}A9pr#>+k|MLkW1`z0J$~E>rHaAb?e^{40frMh>VCWok!2LJSJcD~^CD#NV&WRa~4!U)`xIH5vnznOL`x1=vqQd08SzHK^$;rd}+F+lai`X}fX z{Y3<~{T56S^Pi9*&eFp03@A6@rS!(8%=44QYXDrFR?u4%!wSX53+IG)olrR_dHp&& z505H<4^Czdc=F=K3whB5;c=(nuObTblSkcG_3Hi2y0?g$vo~8wR^GVq!%EBC4xHFy zzq6d2FKZ3$mIdHlj~_p_U2*ABD&3|SKN*LRI$|}BRDexPBM}%c+dL+UR|O!g47K}5 zf4?Y>nxPVxf0ftCJ>fQMz>b)hn4%TRDBDZ)1}QWUjjW(bK1@s;Yra_2cO)U2ih$54yXGYpf$a zOzfSi=bc)axB?v7BRMZmllF-uY`X2)R!?b3D*fK6Ra(e160wf7tSFZuky?H2N98f2KlEmM=dp9sLGX1Pdd?M5)pnbvQR19(XcEb!z9G5Ps zq^PGghFmggPR9wesS*V|Cpr+%E+a6CI4eTYHJhL5@mNjM@mMxcQ&Y=-%f7g0-#%3- zsYl(e#A5tn2Ch(@jErpWZey`;@~|%QUPMP9r#i|fE9^9-Dk=H!{(}dixC59n8GS=T z(@Ou-W8Y$Z-dlDhbK(k`+dY?O4bI~VREO)M_(fVndCd;d(It$G7}rLL>s~Ufx!@*$ zV~f&W!eB})fj;5;efhIp<_tw=D^3wa7dos;TfE42*bmjvi_UyLSZiqLw_kj7x!z%I z$p%W8JdN1W?KF1)TUB*+t?lo5)hus zVMcEK-)juBfOyQ8?Vu6J($6ak;?T(U-1LxY6yKPk`BGl)ns*YjafX9K1}47+K&Ab7 zTCUEbrf%rzaX(aGF_@(XAPgWD=sypa+9Dh~+U|vj&Fr-#&PxCe(y;l;NBPVfD7lIh zv)sE193KDvd&4Ih@y-!Dtu%Fs9G;=VVik#aU{a$a-(uU}-gyA1&+I)HHt($=xyrvF zlfUKwyi))<;AZXMZa`TCxU_8ZHtrnbZy!IkkXe7O3}E90W{h9t9WH#zBxDaj-E4LF z;9u6KE|$x9mgFVnKb1es)MZo7h!%(G)%YxaZYr z?b=QM0wjA!I?;r99sU@@F#Nq0 zsSZYkU6uq8NbEP)7hR*-7n37BjO`g>_-8=T=ou-@%%Nct(S%`5a?-tWkvve64o%q6t=|>*|%2l?BT~VGe^;htX1ibwo-guF9?F zLMd)RB-CNNHOYzCjb@-Z%Sgc|{g55+zap*xs#SVQ+(``*G$ykHmHZ-}f8?opTYT@_ z)3ayK&ZG?YjPP8u8rTw&a!+-xV{7{DUBvDD9${+R@%A-3<6j~P^MX?gipI$gKd1RdA3%Hf&N>cKx_r`P?M z&P%O;BGs9Aahr@%;cV43HAklPZ1h05N;j+xRU?*s|E>u*vIe$+PbxD|hbj}B>n zN8L3RdpYYo(k)dtk=zDKz~JyOKRzuIDz#LjgO#1``n~uSO{2nZprAS|o5D8a@#b>l zv`F1tE!}MT{OBNQFj#jCjn?JMUO*~|4jQ!rvx07GOEc}j)fyWc_4&d`pARbVxL|)W zS%3S!j}L`b)3Nz6yC`XI+D_Ejwm43Ff1RAn?tA3o$38pj;7bIMRkaHp(_jcWa6s2u zOMuF^Wkh;D`SL?!U3#Mp>6XGDyXw{cp39oT*gYs$S5-YDAfVY*=oHN24ty3yGu;kr zVDLt4V@WT^ysfd1m)z>}$lSos%7U#XcxI?_%>uI#L_(pT_(mT2z9Z4}mkgU-34*$p zoTqO)j5J))bteUZz;=jVo`q|J1#}?32l3cdm$>vRU8@41>xj^ z7IN``7|>E5>&VT3n}lf#3JXhl_38+)SBI%iEl|{{BUV9BZ7+1ni1b)70pep6w2y8C zco?Fw8KoQAfFG3MpQ&L1nO9+L7{3A#5bbyRkC4Fg`SUeY|3DdO9BoPn3Jy*Hg~kl{ zw}0I9v~?OZXa$j(-=<1dEvcBru+Z|9nb|ifKcomd=6Bq)Aui9CLzSK-2XQX&v ze}P7<3aYr&SW|*uB!2AdO1u#U)3B33F6-0ryMj2kk0}I5LQCNKk`MyLKSzFt81@@y*-DpRF^|WW| z`9R@Jf?Ze}$}3YZx`-_{n?DAyWt@+1#OFejq>r?@%@{8UAj1k#tPh zQC7JtL>2^G#F(!?J9buzfzSLE9;$z5XQy^Kqk#2gV1GjbTOhZ073dGc;R|Y%pe)1K z;WYPKem;LG1jaDBqM|~(qp7hm@a0R#Pvtbn1QhwgY9(8KdS&#-_J$-AuA6ohkf{95 zv$NakZ|R*t5%&8?u+sJ+*9L>R%p06h`O`}4x$)1Y+N)|JCk4j1J5`-y*or)~oxd7%{m!YiZ4$xG&8-X@20D+!mKXK-=~MeL!LEN#A^^(!x0oWQJbpYo##Jzt+H*JajF?#WdA+XP?uF`hWAp%@ zSgkgXb^l7cv3;NaE3Cl(l=A%-9nW3(0yNbE3jaV2W$Gr=nL1x*)(3Er&gCzV$iNoc za#P)|!7G8NRaI4C#gKZJs-DvHV5ieUFSV~rq+6O%r9%b{=JMQ@3EO)L=q9`}Fe2hS zw5xYE@M5GdX0?Sgoy<$2a5A2l8;}7r(cK-?75*&;ml;${P-BRr-1}x8GKE$lZnH%D zZ|6$z5O-~)=q+FZpn%B3n%sJHC$`n=;{jC}aEE{q#HtVsHfb*jmX!iV%;1TT=SETAmKd6s zCjb=4Y-4RX^rD`3pPkT0G}_M03A&sb>gw^(P?JGg1+nV!qetMUJejX#i>d&=d+Jnd z<*+QcJ0>PcpzB58IN{!kDu4jw-2U)Om)l%zJD|#lx03!p-8wQ6;J7Y%?3nA{Cmk)i3e-Rc zx^M;j!*K^cQV{(#0tRKmf+XAg|2hSF^UE)x>-fRxQ=XfvJuP7WAY&E)i+`N%<_clu z#}h8-DW?M}2m1Ds3H%5#iv0HYFo&s!ch=P7$ixD@d%@bl%jS=!+;O*UQ?6r_ z>*t_oSAbuV0d$xhtQGY#7Ad{2PnE7;_lBWtPP@hLQx^qIrLz;uDCVZ=zA|rfz0yks zT*@0gAbrY}sZJtx3JPaSu9Ys08hM$LCzwmwcfahF60b4#_t3Oo{P>U(6x!ymzDGs1 zn0gO^E@4~sMr}%6G8XA{(H)qgfPd+%J!BaT($M(^AS#xtWa%oD_c207 z6zw_9Xy92bt{VW|Ibd~zGfM3vd&7^(VZ^44WZqq*1=QZ*eXjAhs~j5X%?ci~2WeCX z#ne-BS~piIJtsSKQ#CWMp4ZM!JjkS5j90srYuN%6w)b^aXF0QOe@TO#iYfCydUf)Q z8JR`P%T^V>_}MQ&nI;=uD#;swnpV=149ZR>-+cbc&-ymKMgq(;55jX zKrjpJ7Gzu^y9Chdp(C2PslWfe8(@)~4-KFGILDwAxZq%0ykEo@7vrcAL$3V8o6i5$@&DDz&G<4ltM(Af-WX@x)ia(FJr)$3a z0C3w^RA%iQ+0>AqxE-($HnsZcQl^C8wjc!TDG(CoeiiAWK&8fSz-l7UOl4~tpap=$?7O4X3zN-=L z$e6poi;@MmS!WAi*nd7lW;{Jdubdh-t;y%#_fr!_$8{I_=rf8JLN|szHxdl{h+bY8 z`0FTC8nlYn4g0L1a|Da)ZM5fRJn{1*yq54W#qj}SrUc?WLL%rcraUZNpW&VI6BVvH z`2Wg+ND>+4|2QpncEf@Bng5>Ea21*XDN_Tk)wF{~q@nk|H%I^~AnZ8+x&_C(%*3*A zl8+I9-R5%CW)d1xaG=09Eq=q_?fl8=7uGVm;*FK@_ICzPK$nb(+FTn(wODL@UZr&J zE3cvdfCd@0{1Xj&$U0XZNrvgJG%@1_$5#&YD0Nu(LH_=zq(Tw-^7(UxIbVw1aNS-i zs&fEIwMJl#58snyOQRc6z1MA)+(bEg<0!40PodJZ!p#eASLtS)D6>t ziWi_`mhleNh9%6-+Md^XcMUWrl#@YG0$4+%AcRy^S2rPj#;RLHN*R0~l)qq$biN82 zNUk>xb2^H}Ww>zra;+Zd zgDr1l=%7m7q@X_50Ip3lxWZq)el-Pq5f9qd7%pt2_rnA2QV;hu3m-_)kjj;uc5-g@ zoK=vHfW$!gRW&p;Oq+zo5}@iN$_m3S6~Jl&z9k~WLZAWk=G)oY0=-V(SYH)RLH<)I z5RHVR-Hh?bA}e_CGy$-OF@OSJF?i@eSi-#V2!IfPTc&pn(zi>v50r54W8xlI|FIf< zl)LHnShbk!%vS;GE#$h88plk#VcGW1pw|ph2sZHYMdZ~7Y_}cU*?MpAIj|m*lYO4u7vh`|A?WJp>6QEA2M=a(m_(Az%8|*p+U%r#*zGAfm5JQ zkXk?&D5kEj9|u2%d+0ckZs%wRg@z_Wl1b|vZLn|CtKmul{v~!1+%O)it<<0x3p;z& zcxh*07R8eBVZs8RbHvyaH z4|GnAePF~ci;zu=ZRanGuKo$1*l`F=Svo!v^6O+)&?b6LS&(S8Bb%W7y}|A()Ju=Mb7Yt z4Y@ZPo#R1q= z0{u1HjKGP4Ur@z)Mbsex2$JO+U=4{N9myv$S*JsS)O}?%!B?#0-8+#H)Te>IzA@w~y~~eYxa}1a8%q^MVI2ftP~FcGU~(SNw`HD+2=pSy+s`^=RX1De;{(7&i$6gVX$rUJ4u# zZv+uf6i2RjLtXtPLWnT0BdEhqWn%ltJb#56UQ|>BF+_3dS16TmgURLdj-Z%O6|P{E zaC^oinhf^a8D8ET!&QLhW`-9?V9HbuQ&CbjMPGRk2+|`sMC`|-+qh2eS}FpQNpy80 zs~zGaam*VB_#DPmk-T{CUhRf77DEMr&<7~~1Fnj+|5rce4Dq!-8d#Ha)&^cSu!=%2 z89hVR8EE42{yY%=1U*~}+UA0}jde1>15+4O(v(@c?Y`1_+P2cIZKAxf<7 z480ebpXkD?jiqw&u`SjF%MHz=V<8S@W<;=zm>Uz&n84E0PqT>fSV=;Oq0$XfM!{%& zn20KU?=e{3Eizois%E!zbRvcuVy>0&m-c#~n2asPS)d*;0eB#OPzdvU|F)vtj&soq?7hi3wpAU#yy9UF747_K@ z1RHyofdQn0+r}BPBlKSB+8`HnNhhFLwU)W#EgHINfYyE3cijH$xlZtG2|162uo?8w zP^~9kxdm>^?_j7^ja&gofY>_^0UB_4@~QwGKy-0@o%!C$-Utu3Q7i}$EO3Pq@?n+R zL`4&1=KQ)6BqXEk9W3Y^=b5_zGLmCru9mKL5s}Oakz{Gu26hp4*REYl1hORLw)FNB zFC>4P`^tY=3I;pTk7^1jkpMe~=Ym@`(^|DRX_oHml|M@YxwdWruFja)U0eV`7!k#w z)oHuQj*_+6>hX>J`Ve0cD`k1WRrIwBSIF_Tuv-wYN=m)>CKjZBwb%?yl1EqT;s!1a z5{Nqe-D{zGaUlhiB6s{ zi*fDa7a?}rB4h|g2nwTZtPP8!0Ix%xlCtv2l$NoEuF+&*KhFGl@90=Z%quguWU6!SNDEHSo zAEGs&fU0e$A`+^}!hg_sE=d%NmqGzX0d6q7`tK!o`b3%a@PoPmur8(bDGf9lko`H> z*b)r2D0BxYGiJt^I=>vQZz17t%E&Z98O||nVV8>#A{7t|!EV`0O`X2H@h@VF<;DB0 zJmi*t(Oqh@d3LeKFB8D zT=eblGl>U}BQY8==E3UV78FiJNr`cOoEfYW)1H#z*GVhBA?>@OZ9pIbQ}(TPlPy5% z43K7)S{U)?Xeo*3r|F@)C_?7I10)r~+8cI=@`dqRwE}7s#YUjzSO|iBVmXtmEHth3 zwpM7UFf!E{CE?QyRw7Q~8kw1yp%BK?aTz>J#VDi-YauD?m=uWhI-cteAh*b86wN+H zr2?R{DJ&xfVMp@_BKD_S6c`!`jc3BYz(tOireuw%=uVe!M!1a}M+hIxPh{0Y=g|cV zCD@1KVNC=*sU<9Qec=-!RB*1<-%)p>Mei6|MK(a}ISpi+6wv$F zp<=)-szN3P1j6$=MR|3aka+tBH0ZPxWKDiQ!>IHep6 zxr>*6JVDa2Lx)A~D8L5%I*CA9EZr=wqf7uA4f{nM0x`er!08}u7EZO013-&~p5B@- z?CzfYAReWGm6Vh$6RAlyE~a)9-!Doz7;&%nGjA$Fe6nPD=qS=xAaBqLt8OgS+q1Wf z43Lm7G{u%TTL+H33}c|R%L$3WwndE^r%J`}Y1@BNG`dIxP{T7evx9;<5NsStI6#IT z)(3p9#*gK^V6Y3DjfpvV!+ZPJUUW7B`giwRZvUi8Ic>j9Krz!Ee{xJKe{ISZy|P#K zuT-#>4v*=@{)JKinY$_>0VHm0HWQv4rl%jBpDW0saI$Wh+gT>OeavfmFWf%VWeBW6 zybT0)_)%UwLm2<|kF~n`>kI56&=vWgpM4!1K7tPe(3ovsX|NxBvVZGN{7*Yn_TNhN z{`O%%og@q21ypUUc*e%_Vf^2OfWR zcJIG>z6_nG#6*XjVQ2S;BWKS~NHBA%@ITTT+NvJPbb zzV=~iMA1A4H%L_=z`eHSMyEmE-1;|nhFH8933WjPhqNXP#!?Nul~XsK0W_HLzM=we zi*%cnDu%!g7*76S>^nVr=bt083xHP*Bq507qf=$bL=R99djaJTP9X)NfTC865buSgnxd(xY3%|8uv=?xL*Vd6K>blT&3EMi`B{E`4e$z7FJI0ot)lUw zdDk(C9||!-eg@>uuKJ^MB1o+RMXA4d&$Kc?3<8RaKu%Grv6`zi75bYgbb~Dh1l9`} za>(w3^37rbn5(_WC2MwecD^ZUqxn*NqU&6ly@n9hM4@nK z-Db7YB5)J~B187z4$-Jn99e`@a&myf0=q0TNDSim`9x4d-++tg{8mUHK)f^xkpa7* zni+d~OFN5(Y>?ljlmTD^;gsFJ*gv5@#X}jJ;(Tx{E)8rKq`^nJFSOz7#od;ycaf8` zv$2);Jx2jSYEfzo%P3+yfJvaInp*IO$Z8kZCv8mjY}85wky$qbbQs4GegLyWBm{!{ zZ{VLxG~IrXb%UAs~$7e#%n&YDkNz#e60b!(rKtb!jLnMz2m4)+hDz z(pA4a-{iSg?r97bfqxtbqe-w6+=vgWKbM#HOdt8vpjs(Y6GX34{KQsnLd2+aYWdX3 zlgKUum+X5VgDYula9WQn`b5h(&kWO!rO54bMr76@o*Q#fYg4nQilT5)Ts1d6Ni7;? ztyH_PuP>T?6FRMrA~Gmd`uw>faige6M9P7nhoCZwdjSA5foLCrF&1K=(1~6bHmPx( zJ7>R?i2<#e0R}auF3b#u3^rF&udFPlmH>1umV(JSx|>E0NG7^-fMo;ssxZR>05m+7 zt94u3nBd$HM2pYsmUQj_a_cs^4n9r+?^5M{J(cGZ55SpK>bgpUd>?Td%R9ee%W3gDIJKGB_$qH;Y^awjfF}0&`LOdHhiX z$GR4%V)+oA;)OtQgn-S}EvTsj=drT0c_6k5WU6^@z)MbCGSV)%il(o|e*NPiDEiYo zE(gE?g|S#au|_DANnw@+QsT>%3iEJsYrNvcshzT3bhomNU!YQkP6>nXhJrXGAMv#- z5dX%d9?WvO@z>k>H+J)z+#(Vi{t;2-IeG#tdmIRqfju}y?{3)yReHBA)IOwS_4v9B7TV?|A8w`0r6k3OG0-L3% z6)(HF-m{qo8|y4UUo_PaB7%4Uk3m(S&^VtII=TD@hXjMMvXAvjVz?CAYXT|-m>7YO zOsJ`;(eB8#=wL-YC8#mh5t1JPI;X;fK?dx7-9LF47%!BUYN8@KLSAe0de{Dx{0_kB zpbg@?ypr1ejCf$#V?nyKR|)buD6#EbC{GGk=U8@W!;VRJz$z*}N1hCrx!N7oz;av{ zEkQvzd!b=)OCiKGq_RK;8_m{XM#iqh{`0g?Hs%w=lVELfrteFv9Zaf)F2>SQoQ2if z&QobYFSfs{hT15`+3zd4Yzq*$kr-(&?|cJR6>xBXyt#DsLvUoQOU%0WG91RIQ{9dZ zVT^3f=qKwO9c`EC9&1u`{!3b_&${CC$Lj z0tHFr*~quccqTegFRe44Tsv literal 0 HcmV?d00001 diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb new file mode 100644 index 0000000000..942bf19511 --- /dev/null +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -0,0 +1,492 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "66e4921b-c1ea-479d-9926-d93a7c784be9", + "metadata": {}, + "outputs": [], + "source": [ + "# General libraries\n", + "import numpy as np\n", + "\n", + "# Qibo libraries\n", + "import qibo\n", + "from qibo import gates, models\n", + "from qibo.models import Circuit\n", + "\n", + "%matplotlib inline" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "eda54008", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─RY─o─o───o─────RY─o─o───o─────RY─o─o───o─────RY─M─\n", + "q1: ─RY─X─|─o─|─o───RY─X─|─o─|─o───RY─X─|─o─|─o───RY─M─\n", + "q2: ─RY───X─X─|─|─o─RY───X─X─|─|─o─RY───X─X─|─|─o─RY───\n", + "q3: ─RY───────X─X─X─RY───────X─X─X─RY───────X─X─X─RY───\n" + ] + } + ], + "source": [ + "nqubits = 4\n", + "nlayers = 3\n", + "\n", + "# Create variational ansatz circuit Twolocal\n", + "ansatz = models.Circuit(nqubits)\n", + "for l in range(nlayers):\n", + " \n", + " ansatz.add((gates.RY(q, theta=0) for q in range(nqubits)))\n", + " \n", + " for i in range(nqubits - 3):\n", + " ansatz.add(gates.CNOT(i, i+1))\n", + " ansatz.add(gates.CNOT(i, i+2))\n", + " ansatz.add(gates.CNOT(i+1, i+2))\n", + " ansatz.add(gates.CNOT(i, i+3))\n", + " ansatz.add(gates.CNOT(i+1, i+3))\n", + " ansatz.add(gates.CNOT(i+2, i+3))\n", + " \n", + "ansatz.add((gates.RY(q, theta=0) for q in range(nqubits)))\n", + "ansatz.add(gates.M(qubit) for qubit in range(2))\n", + "print(ansatz.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "ea99c3d4-e36f-46ca-81c4-c8f10d6bcbe5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ansatz.draw_mpl(scale = 0.6, cluster_gates = False)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "81b65ea2-06a0-437d-b8f3-2ac176ea9b25", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "ansatz.draw_mpl(scale = 0.7, cluster_gates = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "62d00656-b40d-44f1-b56a-6733eeed6759", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ──────o───o─────o──X─M─\n", + "q1: ─H──X─|───o─o─i─o──X─M─\n", + "q2: ─SX───CSX─X─X─i─DE─────\n" + ] + } + ], + "source": [ + "c = models.Circuit(3)\n", + "c.add(gates.H(1))\n", + "c.add(gates.X(1))\n", + "c.add(gates.SX(2))\n", + "c.add(gates.CSX(0,2))\n", + "c.add(gates.TOFFOLI(0,1, 2))\n", + "c.add(gates.CNOT(1, 2))\n", + "c.add(gates.iSWAP(1,2))\n", + "c.add(gates.DEUTSCH(1, 0, 2, np.pi))\n", + "c.add(gates.X(1))\n", + "c.add(gates.X(0))\n", + "c.add(gates.M(qubit) for qubit in range(2))\n", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl()" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "5f5896a5-e639-401c-992a-19b960720ec4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─H─U1─U1─U1─U1───────────────────────────x───M─\n", + "q1: ───o──|──|──|──H─U1─U1─U1────────────────|─x─M─\n", + "q2: ──────o──|──|────o──|──|──H─U1─U1────────|─|───\n", + "q3: ─────────o──|───────o──|────o──|──H─U1───|─x───\n", + "q4: ────────────o──────────o───────o────o──H─x─────\n" + ] + } + ], + "source": [ + "from qibo.models import QFT\n", + "c = QFT(5)\n", + "c.add(gates.M(qubit) for qubit in range(2))\n", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "afa80613-6330-4a85-928f-4cb884d81990", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl(scale = 0.8, cluster_gates = True, save_file = \"file2.png\")" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "d549425d-0d8c-4b07-8349-db873b6ae9b0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─U─U─\n", + "q1: ─U─U─\n" + ] + } + ], + "source": [ + "c = models.Circuit(2)\n", + "c.add(gates.Unitary(np.random.random((4, 4)), 0, 1))\n", + "c.add(gates.Unitary(np.random.random((2, 2)), 0))\n", + "c.add(gates.Unitary(np.random.random((2, 2)), 1))\n", + "\n", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "edacdee7-3f48-4a63-adb9-3c898d62fc9d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "17bdbe2f-77c9-4b60-bd0e-ed7efdf20a17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─U───\n", + "q1: ─|───\n", + "q2: ─U─U─\n", + "q3: ─U───\n", + "q4: ───U─\n", + "q5: ─────\n" + ] + } + ], + "source": [ + "c = models.Circuit(6)\n", + "\n", + "c.add(gates.Unitary(np.random.random((8, 8)), 0, 2, 3))\n", + "c.add(gates.Unitary(np.random.random((2, 2)), 2))\n", + "c.add(gates.Unitary(np.random.random((2, 2)), 4))\n", + "\n", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "832527e0-2734-4fd4-a20c-73a48f9b096f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl(cluster_gates = True)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "5763dbf9-7c12-44d5-8cf5-adf763b045d6", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─M─\n", + "q1: ─M─\n", + "q2: ───\n" + ] + } + ], + "source": [ + "c = models.Circuit(3)\n", + "c.add(gates.M(qubit) for qubit in range(2))\n", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "bb9539ee-06d7-413b-8abb-164b8a57e9f8", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl()" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "5a14c98b-35e4-4ac8-9c9a-6eadf660f5e0", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─\n", + "q1: ─\n", + "q2: ─\n" + ] + } + ], + "source": [ + "c = models.Circuit(3)\n", + "print(c.draw())" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "c7e1a83f-b24c-4308-b897-502d571d25fa", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "71fd155b-1902-495a-96b7-70b454b72c90", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.7" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 1114fedf3e..7269070b54 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -472,4 +472,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): @staticmethod def save_fig(fig, path_file): + """Save natpltlib image to file + path_file Path to file with filename and extension + """ return fig.savefig(path_file, bbox_inches="tight") From 529ce0e9dc09364fe84e44f49dff5f2636e99de5 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 16:53:23 +0200 Subject: [PATCH 025/116] integration of matplotlib circuit drawer --- examples/circuit-draw-mpl/file2.png | Bin 17180 -> 0 bytes 1 file changed, 0 insertions(+), 0 deletions(-) delete mode 100644 examples/circuit-draw-mpl/file2.png diff --git a/examples/circuit-draw-mpl/file2.png b/examples/circuit-draw-mpl/file2.png deleted file mode 100644 index b4f1702f50f53c24e1f641ea471bad6175ea45ca..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 17180 zcmdsfby(DE-uG}+P!Tv52nrYo3JQvJs)$N=Is+=*T|=rzI0mAGNFyK}A|M?m9a19= z(mB-7@qTY`chByg-S^q|dj5ExcdpCp3^4Kg-SPc?>OPMYSUQ@G!3H#fO^+|j_+&cw>{5~lzs z&$;8q_V(6xLR?%He|-U`m8}sM^XXF#@F9DwZ)(|LFf@12Ke9ye1QQJA>LaOZS5%$D zC%fFS%?>4-o5RN|Fdgi_4NBfWX>7+Q^J3PKuhewFAU%jh()*G2jT&s)XUi$uqMO3` z>2!r}Tr6H`7KENLY$x{)W~}!%nc~a2p%G^ha7>Qo==~FOtFg@HyU)}ZalQ&EUw7>2 z=w5LXn{z4E>Az4T;^NuO9MEN%O9@v7j|<1kns#kJEnD5sO}6#4?7~&n?cW`_Ua@og z*{9twI_Pox$ccm7&-R_t|7Gi$*PY*Fw|{lv>GM6?&%FPqeb~8%rd`glKYrY8Gv^ET zJ4jETl$dxXA&P(_70T#Ev8^n4Y<$leC|KOOrO3W1;<>36`70I8*S>uD@=o&{I|ql| zvgYg8uit5>$-AG(%kpqCshPXhQ}QiWeBoUFP%*k~FC*t4!cPiIRDR{=eNk(uqNNq` zE-T9*QxnVgti@E#)HKNm#Ag^A##V-FoZT&d4(Qt|u*6_bjh;_-mWxcPZ|e)U%S zhYuezh?7`2~@*h5UFcvONE`(dM7*A?U z#})DzHyp2x5GG7(hJ=K`8-wb?1!Em2+XY|a%m4VrWv&r|cJWf>p38&5$;rvKO1#!S zWo4Ix0s}{i7rRrOHrsQ|4*&XVw3pY=!AYLg!s=bScA0#Cd#63$E`gn${m`*v6Qlla zI);YvFVAVkFp1)g$6M3J8sEsItp{`Iw!#yKjWw4~dTCl&*KKTU9zT25y0$#WtM_%^ zr(yd*@dY%i8y);G0!1nw9wpw?jLEq@9=H5NW-F-ta<$V6h$XA@HJ9p*hiXDB6Ms#g zo{QSVmisXi3LM7gdmqrWwrglC)syCksqd` zOL1Ra2<0*HKXCBiVP@tGlcxC5+|qT6fVz;tz_{FQyv*|QGQRg7ML3SzV_={%K>O|O zdzK~3hLdesH{j1^5qejzUJZQl;`QUldq4HVHT%aN zefl&5za=(nZ%DXMLUMMt>iP<)sV3x7OQzlpG@qib3#!+zU$50Ax-Lw#4a`x~b6+#e z(h?LDtUE_Xs;H`JY)R4Jz4P%me5u>!E3R7hx$=_rOruKARoDeyi+lI&YYww2Ng5c? ze-jrs65-UHw3x?CA?vz0r3RPRi9H)`(V1tHoSNF~O?A}NLO0hk;^fJb^V6SbT;t!8 z3plVg<=OPx&yOfse1Cf-DJhA!gN_rM`1I*MDP=z<(NMSUw{I^{G4R~X&(GJ+w>8Kr z=ze>GO(C**qAhE@ix5t%avEtkAtj#ra8O|_)5>!~YqqBZif3-6`LvkWhIhHZdHt&TdO~a3 zt)R$A9gf@naToQzo;h_&;>3v)W36dn62l78(#n>W>D0_(sbcOc0Y;8=r8MB&wyTCuwBptV~*YrhIrnF`nVMp5n366xAwt z1FjuDIv%b~7~B6X_6DPeId5!JwTNi9Zyn*i#Vz-Z<>8gFlne&Z@zj;sFXLTIS@@_F zPKP2T-FX}g;kjkY9=PmjE|moNmSA0vq$HID_LC>C&JEWS(2rcDYmH5B`p839+DhcY z_!z|8^7t&;<6uF$&wQc7Pv#J?su36E_k?ij6eTt`DxYRyX)YA!;!;qaB)vjK1qz$! z@<4#UM_#Q{$9oG>>n*FZqN2rhf-t`NIof8ej<(k_bc&C8q$V7RsB2YS>~_t7+8Y=Z z)ic6t2DR_B6rs4Qu+}ieAvKHMJ@W6CVIe0rFIso)2VErR4o)7AHD`;C_i`pCCfs4Q z_#cnhLfxn{^0Ay}&fILI;hHeR<=aY9(w=)hpAjOfk&gYw7UdSBm1Ve|^1SRaiP)pd z>^`qle4^4az3t)}z+GVyKBXuzOAXvQq>ds!%%%x226^{SaT8~ z!c2+`KZ3kjE&VT;f4d%0gg86keK|w()OZ|Q=?+j#o2m=K#j*2S$-H0LL->U@BUG!G=Z42OR*8%DE_q}(Y#+jWr%3ovqd5%p_m7#Lo@VtM=MAog zCU#axNSjSQyy4M7Hq(;lYO1Qn6W=qTZ|~i`JF(3&tIeJ?)*_TkQ#$zamOWf4zWn=p zi?H@ws|?qv{PI4bqge;=c6ynbo!U<3=Bcn1(qYX?!gsa2Jb!Bp`-_&2PC7x?69;Ru zi6f&Z1_s0!K1RD3pY!z@*PwCL!|{>=#r%%Y@bm3g`P zc`DdDr5ZiBfn&^F{{8!Nri3VZ{GUH>=;fBI_3k3eGOT?k^Dauvy}GIHKWk?Tkp+HO4k=UCQFxVttO&8H}Y}*>oeud8G`R)Vm@}qNK&rWMF^WkEWWtG zlqn8d$l+^8o=q&g=mCwGbsRQ<{oJ{1nRj%ww5^4k^P^3UQVXzF_?@58h_5wpR*K#E zxYMWHMpdP5H9>s6Qp~bbz!j!hl!fIp)3Iab#O9;`_vS<;(#91 zoT*@0cIr}TQk&AprO-~K?4k<}GIA@wD#sPVgX7)7}omcqWC zM5Dcq+Ev>|fBlml&&^_VKe-g-PukpU>oJYU()y0|VYnZo=#z8>`du+Fbp3 z&Fy3bDCpg8b8=G3(BAp1x>MugSe#z&WiysdpVosV!Cs_JFqm<@2@%>`e8WI zRldL652|tTA^4VulyvMDE-1!c_f2-d!rF5rcBjEd>>@8H!ouKSFrh&W4T>aK`(~}F z`BT1Tah|*6pxJR2&RuNyH8_E<{260_sw-;%i!TGOG}>ty9wZLHZ)Z-NxI!%5EZHja zLQ}A9pr#>+k|MLkW1`z0J$~E>rHaAb?e^{40frMh>VCWok!2LJSJcD~^CD#NV&WRa~4!U)`xIH5vnznOL`x1=vqQd08SzHK^$;rd}+F+lai`X}fX z{Y3<~{T56S^Pi9*&eFp03@A6@rS!(8%=44QYXDrFR?u4%!wSX53+IG)olrR_dHp&& z505H<4^Czdc=F=K3whB5;c=(nuObTblSkcG_3Hi2y0?g$vo~8wR^GVq!%EBC4xHFy zzq6d2FKZ3$mIdHlj~_p_U2*ABD&3|SKN*LRI$|}BRDexPBM}%c+dL+UR|O!g47K}5 zf4?Y>nxPVxf0ftCJ>fQMz>b)hn4%TRDBDZ)1}QWUjjW(bK1@s;Yra_2cO)U2ih$54yXGYpf$a zOzfSi=bc)axB?v7BRMZmllF-uY`X2)R!?b3D*fK6Ra(e160wf7tSFZuky?H2N98f2KlEmM=dp9sLGX1Pdd?M5)pnbvQR19(XcEb!z9G5Ps zq^PGghFmggPR9wesS*V|Cpr+%E+a6CI4eTYHJhL5@mNjM@mMxcQ&Y=-%f7g0-#%3- zsYl(e#A5tn2Ch(@jErpWZey`;@~|%QUPMP9r#i|fE9^9-Dk=H!{(}dixC59n8GS=T z(@Ou-W8Y$Z-dlDhbK(k`+dY?O4bI~VREO)M_(fVndCd;d(It$G7}rLL>s~Ufx!@*$ zV~f&W!eB})fj;5;efhIp<_tw=D^3wa7dos;TfE42*bmjvi_UyLSZiqLw_kj7x!z%I z$p%W8JdN1W?KF1)TUB*+t?lo5)hus zVMcEK-)juBfOyQ8?Vu6J($6ak;?T(U-1LxY6yKPk`BGl)ns*YjafX9K1}47+K&Ab7 zTCUEbrf%rzaX(aGF_@(XAPgWD=sypa+9Dh~+U|vj&Fr-#&PxCe(y;l;NBPVfD7lIh zv)sE193KDvd&4Ih@y-!Dtu%Fs9G;=VVik#aU{a$a-(uU}-gyA1&+I)HHt($=xyrvF zlfUKwyi))<;AZXMZa`TCxU_8ZHtrnbZy!IkkXe7O3}E90W{h9t9WH#zBxDaj-E4LF z;9u6KE|$x9mgFVnKb1es)MZo7h!%(G)%YxaZYr z?b=QM0wjA!I?;r99sU@@F#Nq0 zsSZYkU6uq8NbEP)7hR*-7n37BjO`g>_-8=T=ou-@%%Nct(S%`5a?-tWkvve64o%q6t=|>*|%2l?BT~VGe^;htX1ibwo-guF9?F zLMd)RB-CNNHOYzCjb@-Z%Sgc|{g55+zap*xs#SVQ+(``*G$ykHmHZ-}f8?opTYT@_ z)3ayK&ZG?YjPP8u8rTw&a!+-xV{7{DUBvDD9${+R@%A-3<6j~P^MX?gipI$gKd1RdA3%Hf&N>cKx_r`P?M z&P%O;BGs9Aahr@%;cV43HAklPZ1h05N;j+xRU?*s|E>u*vIe$+PbxD|hbj}B>n zN8L3RdpYYo(k)dtk=zDKz~JyOKRzuIDz#LjgO#1``n~uSO{2nZprAS|o5D8a@#b>l zv`F1tE!}MT{OBNQFj#jCjn?JMUO*~|4jQ!rvx07GOEc}j)fyWc_4&d`pARbVxL|)W zS%3S!j}L`b)3Nz6yC`XI+D_Ejwm43Ff1RAn?tA3o$38pj;7bIMRkaHp(_jcWa6s2u zOMuF^Wkh;D`SL?!U3#Mp>6XGDyXw{cp39oT*gYs$S5-YDAfVY*=oHN24ty3yGu;kr zVDLt4V@WT^ysfd1m)z>}$lSos%7U#XcxI?_%>uI#L_(pT_(mT2z9Z4}mkgU-34*$p zoTqO)j5J))bteUZz;=jVo`q|J1#}?32l3cdm$>vRU8@41>xj^ z7IN``7|>E5>&VT3n}lf#3JXhl_38+)SBI%iEl|{{BUV9BZ7+1ni1b)70pep6w2y8C zco?Fw8KoQAfFG3MpQ&L1nO9+L7{3A#5bbyRkC4Fg`SUeY|3DdO9BoPn3Jy*Hg~kl{ zw}0I9v~?OZXa$j(-=<1dEvcBru+Z|9nb|ifKcomd=6Bq)Aui9CLzSK-2XQX&v ze}P7<3aYr&SW|*uB!2AdO1u#U)3B33F6-0ryMj2kk0}I5LQCNKk`MyLKSzFt81@@y*-DpRF^|WW| z`9R@Jf?Ze}$}3YZx`-_{n?DAyWt@+1#OFejq>r?@%@{8UAj1k#tPh zQC7JtL>2^G#F(!?J9buzfzSLE9;$z5XQy^Kqk#2gV1GjbTOhZ073dGc;R|Y%pe)1K z;WYPKem;LG1jaDBqM|~(qp7hm@a0R#Pvtbn1QhwgY9(8KdS&#-_J$-AuA6ohkf{95 zv$NakZ|R*t5%&8?u+sJ+*9L>R%p06h`O`}4x$)1Y+N)|JCk4j1J5`-y*or)~oxd7%{m!YiZ4$xG&8-X@20D+!mKXK-=~MeL!LEN#A^^(!x0oWQJbpYo##Jzt+H*JajF?#WdA+XP?uF`hWAp%@ zSgkgXb^l7cv3;NaE3Cl(l=A%-9nW3(0yNbE3jaV2W$Gr=nL1x*)(3Er&gCzV$iNoc za#P)|!7G8NRaI4C#gKZJs-DvHV5ieUFSV~rq+6O%r9%b{=JMQ@3EO)L=q9`}Fe2hS zw5xYE@M5GdX0?Sgoy<$2a5A2l8;}7r(cK-?75*&;ml;${P-BRr-1}x8GKE$lZnH%D zZ|6$z5O-~)=q+FZpn%B3n%sJHC$`n=;{jC}aEE{q#HtVsHfb*jmX!iV%;1TT=SETAmKd6s zCjb=4Y-4RX^rD`3pPkT0G}_M03A&sb>gw^(P?JGg1+nV!qetMUJejX#i>d&=d+Jnd z<*+QcJ0>PcpzB58IN{!kDu4jw-2U)Om)l%zJD|#lx03!p-8wQ6;J7Y%?3nA{Cmk)i3e-Rc zx^M;j!*K^cQV{(#0tRKmf+XAg|2hSF^UE)x>-fRxQ=XfvJuP7WAY&E)i+`N%<_clu z#}h8-DW?M}2m1Ds3H%5#iv0HYFo&s!ch=P7$ixD@d%@bl%jS=!+;O*UQ?6r_ z>*t_oSAbuV0d$xhtQGY#7Ad{2PnE7;_lBWtPP@hLQx^qIrLz;uDCVZ=zA|rfz0yks zT*@0gAbrY}sZJtx3JPaSu9Ys08hM$LCzwmwcfahF60b4#_t3Oo{P>U(6x!ymzDGs1 zn0gO^E@4~sMr}%6G8XA{(H)qgfPd+%J!BaT($M(^AS#xtWa%oD_c207 z6zw_9Xy92bt{VW|Ibd~zGfM3vd&7^(VZ^44WZqq*1=QZ*eXjAhs~j5X%?ci~2WeCX z#ne-BS~piIJtsSKQ#CWMp4ZM!JjkS5j90srYuN%6w)b^aXF0QOe@TO#iYfCydUf)Q z8JR`P%T^V>_}MQ&nI;=uD#;swnpV=149ZR>-+cbc&-ymKMgq(;55jX zKrjpJ7Gzu^y9Chdp(C2PslWfe8(@)~4-KFGILDwAxZq%0ykEo@7vrcAL$3V8o6i5$@&DDz&G<4ltM(Af-WX@x)ia(FJr)$3a z0C3w^RA%iQ+0>AqxE-($HnsZcQl^C8wjc!TDG(CoeiiAWK&8fSz-l7UOl4~tpap=$?7O4X3zN-=L z$e6poi;@MmS!WAi*nd7lW;{Jdubdh-t;y%#_fr!_$8{I_=rf8JLN|szHxdl{h+bY8 z`0FTC8nlYn4g0L1a|Da)ZM5fRJn{1*yq54W#qj}SrUc?WLL%rcraUZNpW&VI6BVvH z`2Wg+ND>+4|2QpncEf@Bng5>Ea21*XDN_Tk)wF{~q@nk|H%I^~AnZ8+x&_C(%*3*A zl8+I9-R5%CW)d1xaG=09Eq=q_?fl8=7uGVm;*FK@_ICzPK$nb(+FTn(wODL@UZr&J zE3cvdfCd@0{1Xj&$U0XZNrvgJG%@1_$5#&YD0Nu(LH_=zq(Tw-^7(UxIbVw1aNS-i zs&fEIwMJl#58snyOQRc6z1MA)+(bEg<0!40PodJZ!p#eASLtS)D6>t ziWi_`mhleNh9%6-+Md^XcMUWrl#@YG0$4+%AcRy^S2rPj#;RLHN*R0~l)qq$biN82 zNUk>xb2^H}Ww>zra;+Zd zgDr1l=%7m7q@X_50Ip3lxWZq)el-Pq5f9qd7%pt2_rnA2QV;hu3m-_)kjj;uc5-g@ zoK=vHfW$!gRW&p;Oq+zo5}@iN$_m3S6~Jl&z9k~WLZAWk=G)oY0=-V(SYH)RLH<)I z5RHVR-Hh?bA}e_CGy$-OF@OSJF?i@eSi-#V2!IfPTc&pn(zi>v50r54W8xlI|FIf< zl)LHnShbk!%vS;GE#$h88plk#VcGW1pw|ph2sZHYMdZ~7Y_}cU*?MpAIj|m*lYO4u7vh`|A?WJp>6QEA2M=a(m_(Az%8|*p+U%r#*zGAfm5JQ zkXk?&D5kEj9|u2%d+0ckZs%wRg@z_Wl1b|vZLn|CtKmul{v~!1+%O)it<<0x3p;z& zcxh*07R8eBVZs8RbHvyaH z4|GnAePF~ci;zu=ZRanGuKo$1*l`F=Svo!v^6O+)&?b6LS&(S8Bb%W7y}|A()Ju=Mb7Yt z4Y@ZPo#R1q= z0{u1HjKGP4Ur@z)Mbsex2$JO+U=4{N9myv$S*JsS)O}?%!B?#0-8+#H)Te>IzA@w~y~~eYxa}1a8%q^MVI2ftP~FcGU~(SNw`HD+2=pSy+s`^=RX1De;{(7&i$6gVX$rUJ4u# zZv+uf6i2RjLtXtPLWnT0BdEhqWn%ltJb#56UQ|>BF+_3dS16TmgURLdj-Z%O6|P{E zaC^oinhf^a8D8ET!&QLhW`-9?V9HbuQ&CbjMPGRk2+|`sMC`|-+qh2eS}FpQNpy80 zs~zGaam*VB_#DPmk-T{CUhRf77DEMr&<7~~1Fnj+|5rce4Dq!-8d#Ha)&^cSu!=%2 z89hVR8EE42{yY%=1U*~}+UA0}jde1>15+4O(v(@c?Y`1_+P2cIZKAxf<7 z480ebpXkD?jiqw&u`SjF%MHz=V<8S@W<;=zm>Uz&n84E0PqT>fSV=;Oq0$XfM!{%& zn20KU?=e{3Eizois%E!zbRvcuVy>0&m-c#~n2asPS)d*;0eB#OPzdvU|F)vtj&soq?7hi3wpAU#yy9UF747_K@ z1RHyofdQn0+r}BPBlKSB+8`HnNhhFLwU)W#EgHINfYyE3cijH$xlZtG2|162uo?8w zP^~9kxdm>^?_j7^ja&gofY>_^0UB_4@~QwGKy-0@o%!C$-Utu3Q7i}$EO3Pq@?n+R zL`4&1=KQ)6BqXEk9W3Y^=b5_zGLmCru9mKL5s}Oakz{Gu26hp4*REYl1hORLw)FNB zFC>4P`^tY=3I;pTk7^1jkpMe~=Ym@`(^|DRX_oHml|M@YxwdWruFja)U0eV`7!k#w z)oHuQj*_+6>hX>J`Ve0cD`k1WRrIwBSIF_Tuv-wYN=m)>CKjZBwb%?yl1EqT;s!1a z5{Nqe-D{zGaUlhiB6s{ zi*fDa7a?}rB4h|g2nwTZtPP8!0Ix%xlCtv2l$NoEuF+&*KhFGl@90=Z%quguWU6!SNDEHSo zAEGs&fU0e$A`+^}!hg_sE=d%NmqGzX0d6q7`tK!o`b3%a@PoPmur8(bDGf9lko`H> z*b)r2D0BxYGiJt^I=>vQZz17t%E&Z98O||nVV8>#A{7t|!EV`0O`X2H@h@VF<;DB0 zJmi*t(Oqh@d3LeKFB8D zT=eblGl>U}BQY8==E3UV78FiJNr`cOoEfYW)1H#z*GVhBA?>@OZ9pIbQ}(TPlPy5% z43K7)S{U)?Xeo*3r|F@)C_?7I10)r~+8cI=@`dqRwE}7s#YUjzSO|iBVmXtmEHth3 zwpM7UFf!E{CE?QyRw7Q~8kw1yp%BK?aTz>J#VDi-YauD?m=uWhI-cteAh*b86wN+H zr2?R{DJ&xfVMp@_BKD_S6c`!`jc3BYz(tOireuw%=uVe!M!1a}M+hIxPh{0Y=g|cV zCD@1KVNC=*sU<9Qec=-!RB*1<-%)p>Mei6|MK(a}ISpi+6wv$F zp<=)-szN3P1j6$=MR|3aka+tBH0ZPxWKDiQ!>IHep6 zxr>*6JVDa2Lx)A~D8L5%I*CA9EZr=wqf7uA4f{nM0x`er!08}u7EZO013-&~p5B@- z?CzfYAReWGm6Vh$6RAlyE~a)9-!Doz7;&%nGjA$Fe6nPD=qS=xAaBqLt8OgS+q1Wf z43Lm7G{u%TTL+H33}c|R%L$3WwndE^r%J`}Y1@BNG`dIxP{T7evx9;<5NsStI6#IT z)(3p9#*gK^V6Y3DjfpvV!+ZPJUUW7B`giwRZvUi8Ic>j9Krz!Ee{xJKe{ISZy|P#K zuT-#>4v*=@{)JKinY$_>0VHm0HWQv4rl%jBpDW0saI$Wh+gT>OeavfmFWf%VWeBW6 zybT0)_)%UwLm2<|kF~n`>kI56&=vWgpM4!1K7tPe(3ovsX|NxBvVZGN{7*Yn_TNhN z{`O%%og@q21ypUUc*e%_Vf^2OfWR zcJIG>z6_nG#6*XjVQ2S;BWKS~NHBA%@ITTT+NvJPbb zzV=~iMA1A4H%L_=z`eHSMyEmE-1;|nhFH8933WjPhqNXP#!?Nul~XsK0W_HLzM=we zi*%cnDu%!g7*76S>^nVr=bt083xHP*Bq507qf=$bL=R99djaJTP9X)NfTC865buSgnxd(xY3%|8uv=?xL*Vd6K>blT&3EMi`B{E`4e$z7FJI0ot)lUw zdDk(C9||!-eg@>uuKJ^MB1o+RMXA4d&$Kc?3<8RaKu%Grv6`zi75bYgbb~Dh1l9`} za>(w3^37rbn5(_WC2MwecD^ZUqxn*NqU&6ly@n9hM4@nK z-Db7YB5)J~B187z4$-Jn99e`@a&myf0=q0TNDSim`9x4d-++tg{8mUHK)f^xkpa7* zni+d~OFN5(Y>?ljlmTD^;gsFJ*gv5@#X}jJ;(Tx{E)8rKq`^nJFSOz7#od;ycaf8` zv$2);Jx2jSYEfzo%P3+yfJvaInp*IO$Z8kZCv8mjY}85wky$qbbQs4GegLyWBm{!{ zZ{VLxG~IrXb%UAs~$7e#%n&YDkNz#e60b!(rKtb!jLnMz2m4)+hDz z(pA4a-{iSg?r97bfqxtbqe-w6+=vgWKbM#HOdt8vpjs(Y6GX34{KQsnLd2+aYWdX3 zlgKUum+X5VgDYula9WQn`b5h(&kWO!rO54bMr76@o*Q#fYg4nQilT5)Ts1d6Ni7;? ztyH_PuP>T?6FRMrA~Gmd`uw>faige6M9P7nhoCZwdjSA5foLCrF&1K=(1~6bHmPx( zJ7>R?i2<#e0R}auF3b#u3^rF&udFPlmH>1umV(JSx|>E0NG7^-fMo;ssxZR>05m+7 zt94u3nBd$HM2pYsmUQj_a_cs^4n9r+?^5M{J(cGZ55SpK>bgpUd>?Td%R9ee%W3gDIJKGB_$qH;Y^awjfF}0&`LOdHhiX z$GR4%V)+oA;)OtQgn-S}EvTsj=drT0c_6k5WU6^@z)MbCGSV)%il(o|e*NPiDEiYo zE(gE?g|S#au|_DANnw@+QsT>%3iEJsYrNvcshzT3bhomNU!YQkP6>nXhJrXGAMv#- z5dX%d9?WvO@z>k>H+J)z+#(Vi{t;2-IeG#tdmIRqfju}y?{3)yReHBA)IOwS_4v9B7TV?|A8w`0r6k3OG0-L3% z6)(HF-m{qo8|y4UUo_PaB7%4Uk3m(S&^VtII=TD@hXjMMvXAvjVz?CAYXT|-m>7YO zOsJ`;(eB8#=wL-YC8#mh5t1JPI;X;fK?dx7-9LF47%!BUYN8@KLSAe0de{Dx{0_kB zpbg@?ypr1ejCf$#V?nyKR|)buD6#EbC{GGk=U8@W!;VRJz$z*}N1hCrx!N7oz;av{ zEkQvzd!b=)OCiKGq_RK;8_m{XM#iqh{`0g?Hs%w=lVELfrteFv9Zaf)F2>SQoQ2if z&QobYFSfs{hT15`+3zd4Yzq*$kr-(&?|cJR6>xBXyt#DsLvUoQOU%0WG91RIQ{9dZ zVT^3f=qKwO9c`EC9&1u`{!3b_&${CC$Lj z0tHFr*~quccqTegFRe44Tsv From 716f263554b96e1f066aceea1d3687af4ef116ee Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 21 Jun 2024 16:54:36 +0200 Subject: [PATCH 026/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 7269070b54..f7e05b0ed0 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -472,7 +472,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): @staticmethod def save_fig(fig, path_file): - """Save natpltlib image to file + """Save matpltlib image to file path_file Path to file with filename and extension """ return fig.savefig(path_file, bbox_inches="tight") From c4f259800d4c8917f691d30c27868b0b77c384a1 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 21 Jun 2024 15:05:19 +0000 Subject: [PATCH 027/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/circuit.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index b259c2892f..86b2961cfd 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -1270,7 +1270,7 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx - def draw_mpl(self, scale = 0.6, cluster_gates = True, save_file = None): + def draw_mpl(self, scale=0.6, cluster_gates=True, save_file=None): ax = MPLDrawer().plot_qibo_circuit(self, scale, cluster_gates) From 44072661a13f89a02ee3373923f76673c28db758 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Sat, 22 Jun 2024 23:26:26 +0200 Subject: [PATCH 028/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index f7e05b0ed0..6006e1324f 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -245,8 +245,8 @@ def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): DEUTSCH="DE", UNITARY="U", MEASURE="M", - SX=r"$\sqrt{\text{X}}$", - CSX=r"$\sqrt{\text{X}}$", + SX=r'$\rm\sqrt{X}$', + CSX=r'$\rm\sqrt{X}$', ) name, target = gate[:2] symbol = target_symbols.get(name, name) # override name with target_symbols From 75055994fb7412dcbe24550ce146f2b916d95817 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sat, 22 Jun 2024 21:27:42 +0000 Subject: [PATCH 029/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/mpldrawer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 6006e1324f..c2ac9bd341 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -245,8 +245,8 @@ def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): DEUTSCH="DE", UNITARY="U", MEASURE="M", - SX=r'$\rm\sqrt{X}$', - CSX=r'$\rm\sqrt{X}$', + SX=r"$\rm\sqrt{X}$", + CSX=r"$\rm\sqrt{X}$", ) name, target = gate[:2] symbol = target_symbols.get(name, name) # override name with target_symbols From 843bd32fe8ca1bde2455289eb4982202c5c71f07 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Sun, 23 Jun 2024 23:05:32 +0200 Subject: [PATCH 030/116] integration of matplotlib circuit drawer --- src/qibo/models/mpldrawer.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index c2ac9bd341..65e786e773 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -443,6 +443,9 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): for gate in circuit.queue: init_label = gate.name.upper() + if len(gate._target_qubits) > 0 and 'C' in init_label[0]: + init_label = init_label[1:] + item = () item += (init_label,) From 235953614d1ca8318c37fd0af58db3a7b9d1ccd8 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Sun, 23 Jun 2024 21:08:27 +0000 Subject: [PATCH 031/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/models/mpldrawer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 65e786e773..811dbedd64 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -443,9 +443,9 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): for gate in circuit.queue: init_label = gate.name.upper() - if len(gate._target_qubits) > 0 and 'C' in init_label[0]: + if len(gate._target_qubits) > 0 and "C" in init_label[0]: init_label = init_label[1:] - + item = () item += (init_label,) From 1aaec6b94c02bad68409062dcc492dab11085c8c Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Sun, 23 Jun 2024 23:48:25 +0200 Subject: [PATCH 032/116] added new analysis data review --- src/qibo/models/mpldrawer.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/models/mpldrawer.py index 811dbedd64..8ec9344fce 100644 --- a/src/qibo/models/mpldrawer.py +++ b/src/qibo/models/mpldrawer.py @@ -259,7 +259,7 @@ def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): self._oplus(ax, x, y, plot_params) elif name in ["CPHASE"]: self._cdot(ax, x, y, plot_params) - elif name in ["SWAP", "ISWAP", "SISWAP", "FISWAP"]: + elif name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: self._swapx(ax, x, y, plot_params) else: self._text(ax, x, y, symbol, plot_params, box=True) @@ -443,7 +443,7 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): for gate in circuit.queue: init_label = gate.name.upper() - if len(gate._target_qubits) > 0 and "C" in init_label[0]: + if len(gate._control_qubits) > 0 and "C" in init_label[0]: init_label = init_label[1:] item = () From 08221e96223098cf97afe79e7e5039ea5372289a Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 08:16:59 +0200 Subject: [PATCH 033/116] moved drawing mpl circuit to new module --- src/qibo/__init__.py | 1 + src/qibo/{models => imaging}/mpldrawer.py | 0 src/qibo/models/circuit.py | 2 +- 3 files changed, 2 insertions(+), 1 deletion(-) rename src/qibo/{models => imaging}/mpldrawer.py (100%) diff --git a/src/qibo/__init__.py b/src/qibo/__init__.py index bcd912f1cc..e5f33fb422 100644 --- a/src/qibo/__init__.py +++ b/src/qibo/__init__.py @@ -33,3 +33,4 @@ set_metropolis_threshold, ) from qibo.models.circuit import Circuit +from qibo.imaging.mpldrawer import MPLDrawer diff --git a/src/qibo/models/mpldrawer.py b/src/qibo/imaging/mpldrawer.py similarity index 100% rename from src/qibo/models/mpldrawer.py rename to src/qibo/imaging/mpldrawer.py diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index 86b2961cfd..fd0787d9da 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -9,7 +9,7 @@ from qibo.config import raise_error from qibo.gates.abstract import Gate from qibo.models._openqasm import QASMParser -from qibo.models.mpldrawer import MPLDrawer +from qibo.imaging.mpldrawer import MPLDrawer NoiseMapType = Union[Tuple[int, int, int], Dict[int, Tuple[int, int, int]]] From 12991bf42d57cc45de9228a2181346d9d1820226 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 24 Jun 2024 06:18:02 +0000 Subject: [PATCH 034/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/__init__.py | 2 +- src/qibo/models/circuit.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/__init__.py b/src/qibo/__init__.py index e5f33fb422..69d089610d 100644 --- a/src/qibo/__init__.py +++ b/src/qibo/__init__.py @@ -32,5 +32,5 @@ set_batch_size, set_metropolis_threshold, ) -from qibo.models.circuit import Circuit from qibo.imaging.mpldrawer import MPLDrawer +from qibo.models.circuit import Circuit diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index fd0787d9da..e89b737da9 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -8,8 +8,8 @@ from qibo import gates from qibo.config import raise_error from qibo.gates.abstract import Gate -from qibo.models._openqasm import QASMParser from qibo.imaging.mpldrawer import MPLDrawer +from qibo.models._openqasm import QASMParser NoiseMapType = Union[Tuple[int, int, int], Dict[int, Tuple[int, int, int]]] From 6e777ee95da4c8b9889c254f1b6b54bbf8f71b29 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 10:13:13 +0200 Subject: [PATCH 035/116] moved drawing mpl circuit to new module with new styles --- .../qibo-draw-circuit-matplotlib.ipynb | 247 ++++++++++++++++-- src/qibo/imaging/mpldrawer.py | 102 +++++--- src/qibo/imaging/plot_styles.py | 45 ++++ src/qibo/models/circuit.py | 4 +- 4 files changed, 329 insertions(+), 69 deletions(-) create mode 100644 src/qibo/imaging/plot_styles.py diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index 942bf19511..c1f58ff649 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -8,13 +8,16 @@ "outputs": [], "source": [ "# General libraries\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import warnings\n", "\n", "# Qibo libraries\n", "import qibo\n", "from qibo import gates, models\n", "from qibo.models import Circuit\n", "\n", + "warnings.filterwarnings(\"ignore\")\n", "%matplotlib inline" ] }, @@ -76,7 +79,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -107,7 +110,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -122,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 22, "id": "62d00656-b40d-44f1-b56a-6733eeed6759", "metadata": {}, "outputs": [ @@ -130,9 +133,9 @@ "name": "stdout", "output_type": "stream", "text": [ - "q0: ──────o───o─────o──X─M─\n", - "q1: ─H──X─|───o─o─i─o──X─M─\n", - "q2: ─SX───CSX─X─X─i─DE─────\n" + "q0: ──────o───o───────────o──X─M─\n", + "q1: ─H──X─|───o─o─x─si─fx─o──X─M─\n", + "q2: ─SX───CSX─X─X─x─si─fx─DE─────\n" ] } ], @@ -144,7 +147,9 @@ "c.add(gates.CSX(0,2))\n", "c.add(gates.TOFFOLI(0,1, 2))\n", "c.add(gates.CNOT(1, 2))\n", - "c.add(gates.iSWAP(1,2))\n", + "c.add(gates.SWAP(1,2))\n", + "c.add(gates.SiSWAP(1,2))\n", + "c.add(gates.FSWAP(1,2))\n", "c.add(gates.DEUTSCH(1, 0, 2, np.pi))\n", "c.add(gates.X(1))\n", "c.add(gates.X(0))\n", @@ -154,7 +159,28 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 23, + "id": "0eb15305", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(c.queue[0]._control_qubits)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", "metadata": {}, "outputs": [ @@ -164,15 +190,46 @@ "" ] }, - "execution_count": 6, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl(style=\"garnacha\")" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "5e75d023-0ada-4cab-adff-2b7bb313a0b1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 25, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -185,7 +242,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "id": "5f5896a5-e639-401c-992a-19b960720ec4", "metadata": {}, "outputs": [ @@ -210,7 +267,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "id": "afa80613-6330-4a85-928f-4cb884d81990", "metadata": {}, "outputs": [ @@ -220,13 +277,13 @@ "" ] }, - "execution_count": 8, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -236,12 +293,144 @@ } ], "source": [ - "c.draw_mpl(scale = 0.8, cluster_gates = True, save_file = \"file2.png\")" + "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"garnacha\", save_file = \"file2.png\")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, + "id": "916f7b83-1ad7-4984-8573-eb55dfeb125d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"fardelejo\")" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "b9e1176c-d8dc-47e4-9607-ad24f6f536b9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"quantumspain\")" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "eaefdf76-af68-4187-996d-bdc9c33a4242", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"color-blind\")" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "56f4f3cc-6864-4ef2-aa19-9c209fc217e5", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "custom_style = dict()\n", + "custom_style[\"facecolor\"]=\"#6497bf\"\n", + "custom_style[\"edgecolor\"]=\"#01016f\"\n", + "custom_style[\"linecolor\"]=\"#01016f\"\n", + "custom_style[\"textcolor\"]=\"#01016f\"\n", + "custom_style[\"fillcolor\"]=\"#ffb9b9\"\n", + "custom_style[\"gatecolor\"]=\"#d8031c\"\n", + "custom_style[\"controlcolor\"]=\"#360000\"\n", + "c.draw_mpl(scale = 0.8, cluster_gates = True, style=custom_style)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, "id": "d549425d-0d8c-4b07-8349-db873b6ae9b0", "metadata": {}, "outputs": [ @@ -265,7 +454,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 15, "id": "edacdee7-3f48-4a63-adb9-3c898d62fc9d", "metadata": {}, "outputs": [ @@ -275,7 +464,7 @@ "" ] }, - "execution_count": 10, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" }, @@ -296,7 +485,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 16, "id": "17bdbe2f-77c9-4b60-bd0e-ed7efdf20a17", "metadata": {}, "outputs": [ @@ -325,7 +514,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 17, "id": "832527e0-2734-4fd4-a20c-73a48f9b096f", "metadata": {}, "outputs": [ @@ -335,7 +524,7 @@ "" ] }, - "execution_count": 12, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -356,7 +545,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 18, "id": "5763dbf9-7c12-44d5-8cf5-adf763b045d6", "metadata": {}, "outputs": [ @@ -378,7 +567,7 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 19, "id": "bb9539ee-06d7-413b-8abb-164b8a57e9f8", "metadata": {}, "outputs": [ @@ -388,7 +577,7 @@ "" ] }, - "execution_count": 14, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, @@ -409,7 +598,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 20, "id": "5a14c98b-35e4-4ac8-9c9a-6eadf660f5e0", "metadata": {}, "outputs": [ @@ -430,7 +619,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 21, "id": "c7e1a83f-b24c-4308-b897-502d571d25fa", "metadata": {}, "outputs": [ @@ -440,7 +629,7 @@ "" ] }, - "execution_count": 16, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" }, @@ -462,7 +651,7 @@ { "cell_type": "code", "execution_count": null, - "id": "71fd155b-1902-495a-96b7-70b454b72c90", + "id": "ce2296cf", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/imaging/mpldrawer.py b/src/qibo/imaging/mpldrawer.py index 8ec9344fce..a434d21021 100644 --- a/src/qibo/imaging/mpldrawer.py +++ b/src/qibo/imaging/mpldrawer.py @@ -4,12 +4,30 @@ # import matplotlib import numpy as np - +from .plot_styles import _get_style class MPLDrawer: def __init__(self): pass + global plot_params + plot_params = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + facecolor="w", + edgecolor="#000000", + fillcolor="#000000", + linecolor="k", + textcolor="k", + gatecolor="w", + controlcolor="#000000", + ) + def _plot_quantum_schedule( self, schedule, inits, labels=[], plot_labels=True, **kwargs ): @@ -22,15 +40,6 @@ def _plot_quantum_schedule( kwargs Can override plot_parameters """ - plot_params = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - ) plot_params.update(kwargs) scale = plot_params["scale"] @@ -80,15 +89,6 @@ def _plot_quantum_circuit( kwargs Can override plot_parameters """ - plot_params = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - ) plot_params.update(kwargs) scale = plot_params["scale"] @@ -124,15 +124,7 @@ def _plot_lines_circuit(self, inits, labels, plot_labels=True, **kwargs): kwargs Can override plot_parameters """ - plot_params = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - ) + plot_params.update(kwargs) scale = plot_params["scale"] @@ -228,14 +220,14 @@ def _draw_controls( for ci in control_indices: x = gate_grid[i] y = wire_grid[ci] - if name in ["SWAP", "ISWAP", "SISWAP", "FISWAP"]: + if name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: self._swapx(ax, x, y, plot_params) else: self._cdot(ax, x, y, plot_params) def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): target_symbols = dict( - CNOT="X", + #CNOT="X", CPHASE="Z", NOP="", CX="X", @@ -266,18 +258,18 @@ def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): def _line(self, ax, x1, x2, y1, y2, plot_params): Line2D = matplotlib.lines.Line2D - line = Line2D((x1, x2), (y1, y2), color="k", lw=plot_params["linewidth"]) + line = Line2D((x1, x2), (y1, y2), color=plot_params["linecolor"], lw=plot_params["linewidth"]) ax.add_line(line) def _text(self, ax, x, y, textstr, plot_params, box=False): linewidth = plot_params["linewidth"] fontsize = plot_params["fontsize"] if box: - bbox = dict(ec="k", fc="w", fill=True, lw=linewidth) + bbox = dict(ec=plot_params["edgecolor"], fc=plot_params["gatecolor"], fill=True, lw=linewidth) else: bbox = dict(fill=False, lw=0) ax.text( - x, y, textstr, color="k", ha="center", va="center", bbox=bbox, size=fontsize + x, y, textstr, color=plot_params["textcolor"], ha="center", va="center", bbox=bbox, size=fontsize ) def _oplus(self, ax, x, y, plot_params): @@ -285,7 +277,7 @@ def _oplus(self, ax, x, y, plot_params): Circle = matplotlib.patches.Circle not_radius = plot_params["not_radius"] linewidth = plot_params["linewidth"] - c = Circle((x, y), not_radius, ec="k", fc="w", fill=False, lw=linewidth) + c = Circle((x, y), not_radius, ec=plot_params["edgecolor"], fc=plot_params["gatecolor"], fill=True, lw=linewidth) ax.add_patch(c) self._line(ax, x, x, y - not_radius, y + not_radius, plot_params) @@ -295,7 +287,7 @@ def _cdot(self, ax, x, y, plot_params): scale = plot_params["scale"] linewidth = plot_params["linewidth"] c = Circle( - (x, y), control_radius * scale, ec="k", fc="k", fill=True, lw=linewidth + (x, y), control_radius * scale, ec=plot_params["edgecolor"], fc=plot_params["controlcolor"], fill=True, lw=linewidth ) ax.add_patch(c) @@ -308,7 +300,7 @@ def _swapx(self, ax, x, y, plot_params): def _setup_figure(self, nq, ng, gate_grid, wire_grid, plot_params): scale = plot_params["scale"] fig = matplotlib.pyplot.figure( - figsize=(ng * scale, nq * scale), facecolor="w", edgecolor="w" + figsize=(ng * scale, nq * scale), facecolor=plot_params["facecolor"], edgecolor=plot_params["edgecolor"] ) ax = fig.add_subplot(1, 1, 1, frameon=True) ax.set_axis_off() @@ -429,7 +421,36 @@ def _make_cluster_gates(self, gates_items): return cluster_gates - def plot_qibo_circuit(self, circuit, scale, cluster_gates): + def _set_style(self,style): + + if style is None: + default_values = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + facecolor="w", + edgecolor="#000000", + fillcolor="#000000", + linecolor="k", + textcolor="k", + gatecolor="w", + controlcolor="#000000", + ) + + plot_params.update(default_values) + else: + if type(style) is str: + plot_params.update(_get_style(style)) + elif type(style) is dict: + plot_params.update(style) + + def plot_qibo_circuit(self, circuit, scale, cluster_gates, style): + + self._set_style(style) inits = list(range(circuit.nqubits)) @@ -442,8 +463,13 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates): for gate in circuit.queue: init_label = gate.name.upper() + if "CCX" in init_label: + init_label = "TOFFOLI" + + if "CX" in init_label: + init_label = "CNOT" - if len(gate._control_qubits) > 0 and "C" in init_label[0]: + if len(gate._control_qubits) > 0 and "C" in init_label[0] and "CNOT" not in init_label: init_label = init_label[1:] item = () diff --git a/src/qibo/imaging/plot_styles.py b/src/qibo/imaging/plot_styles.py new file mode 100644 index 0000000000..50ba3924e0 --- /dev/null +++ b/src/qibo/imaging/plot_styles.py @@ -0,0 +1,45 @@ +def _get_style(style_name): + + if 'garnacha' in style_name: + new_values = dict() + new_values["facecolor"]="#5e2129" + new_values["edgecolor"]="#FFFFFF" + new_values["linecolor"]="#FFFFFF" + new_values["textcolor"]="#FFFFFF" + new_values["fillcolor"]="#FFFFFF" + new_values["gatecolor"]="#5e2129" + new_values["controlcolor"]="#FFFFFF" + return new_values + + if 'fardelejo' in style_name: + new_values = dict() + new_values["facecolor"]="#e17a02" + new_values["edgecolor"]="#fef1e2" + new_values["linecolor"]="#fef1e2" + new_values["textcolor"]="#FFFFFF" + new_values["fillcolor"]="#fef1e2" + new_values["gatecolor"]="#8b4513" + new_values["controlcolor"]="#fef1e2" + return new_values + + if 'quantumspain' in style_name: + new_values = dict() + new_values["facecolor"]="#EDEDF4" + new_values["edgecolor"]="#092D4E" + new_values["linecolor"]="#092D4E" + new_values["textcolor"]="#8561C3" + new_values["fillcolor"]="#092D4E" + new_values["gatecolor"]="#53E7CA" + new_values["controlcolor"]="#092D4E" + return new_values + + if 'color-blind' in style_name: + new_values = dict() + new_values["facecolor"]="#d55e00" + new_values["edgecolor"]="#f0e442" + new_values["linecolor"]="#f0e442" + new_values["textcolor"]="#f0e442" + new_values["fillcolor"]="#cc79a7" + new_values["gatecolor"]="#d55e00" + new_values["controlcolor"]="#f0e442" + return new_values diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index fd0787d9da..cb87e88005 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -1270,9 +1270,9 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx - def draw_mpl(self, scale=0.6, cluster_gates=True, save_file=None): + def draw_mpl(self, scale=0.6, cluster_gates=True, style=None, save_file=None): - ax = MPLDrawer().plot_qibo_circuit(self, scale, cluster_gates) + ax = MPLDrawer().plot_qibo_circuit(self, scale, cluster_gates, style) if save_file: MPLDrawer.save_fig(ax.figure, save_file) From 392d47bf8acf6991beb5d00d6dd0217d09b14b68 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 24 Jun 2024 08:15:49 +0000 Subject: [PATCH 036/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/imaging/mpldrawer.py | 59 +++++++++++++++++++----- src/qibo/imaging/plot_styles.py | 80 ++++++++++++++++----------------- 2 files changed, 88 insertions(+), 51 deletions(-) diff --git a/src/qibo/imaging/mpldrawer.py b/src/qibo/imaging/mpldrawer.py index a434d21021..709408aae8 100644 --- a/src/qibo/imaging/mpldrawer.py +++ b/src/qibo/imaging/mpldrawer.py @@ -4,8 +4,10 @@ # import matplotlib import numpy as np + from .plot_styles import _get_style + class MPLDrawer: def __init__(self): pass @@ -227,7 +229,7 @@ def _draw_controls( def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): target_symbols = dict( - #CNOT="X", + # CNOT="X", CPHASE="Z", NOP="", CX="X", @@ -258,18 +260,35 @@ def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): def _line(self, ax, x1, x2, y1, y2, plot_params): Line2D = matplotlib.lines.Line2D - line = Line2D((x1, x2), (y1, y2), color=plot_params["linecolor"], lw=plot_params["linewidth"]) + line = Line2D( + (x1, x2), + (y1, y2), + color=plot_params["linecolor"], + lw=plot_params["linewidth"], + ) ax.add_line(line) def _text(self, ax, x, y, textstr, plot_params, box=False): linewidth = plot_params["linewidth"] fontsize = plot_params["fontsize"] if box: - bbox = dict(ec=plot_params["edgecolor"], fc=plot_params["gatecolor"], fill=True, lw=linewidth) + bbox = dict( + ec=plot_params["edgecolor"], + fc=plot_params["gatecolor"], + fill=True, + lw=linewidth, + ) else: bbox = dict(fill=False, lw=0) ax.text( - x, y, textstr, color=plot_params["textcolor"], ha="center", va="center", bbox=bbox, size=fontsize + x, + y, + textstr, + color=plot_params["textcolor"], + ha="center", + va="center", + bbox=bbox, + size=fontsize, ) def _oplus(self, ax, x, y, plot_params): @@ -277,7 +296,14 @@ def _oplus(self, ax, x, y, plot_params): Circle = matplotlib.patches.Circle not_radius = plot_params["not_radius"] linewidth = plot_params["linewidth"] - c = Circle((x, y), not_radius, ec=plot_params["edgecolor"], fc=plot_params["gatecolor"], fill=True, lw=linewidth) + c = Circle( + (x, y), + not_radius, + ec=plot_params["edgecolor"], + fc=plot_params["gatecolor"], + fill=True, + lw=linewidth, + ) ax.add_patch(c) self._line(ax, x, x, y - not_radius, y + not_radius, plot_params) @@ -287,7 +313,12 @@ def _cdot(self, ax, x, y, plot_params): scale = plot_params["scale"] linewidth = plot_params["linewidth"] c = Circle( - (x, y), control_radius * scale, ec=plot_params["edgecolor"], fc=plot_params["controlcolor"], fill=True, lw=linewidth + (x, y), + control_radius * scale, + ec=plot_params["edgecolor"], + fc=plot_params["controlcolor"], + fill=True, + lw=linewidth, ) ax.add_patch(c) @@ -300,7 +331,9 @@ def _swapx(self, ax, x, y, plot_params): def _setup_figure(self, nq, ng, gate_grid, wire_grid, plot_params): scale = plot_params["scale"] fig = matplotlib.pyplot.figure( - figsize=(ng * scale, nq * scale), facecolor=plot_params["facecolor"], edgecolor=plot_params["edgecolor"] + figsize=(ng * scale, nq * scale), + facecolor=plot_params["facecolor"], + edgecolor=plot_params["edgecolor"], ) ax = fig.add_subplot(1, 1, 1, frameon=True) ax.set_axis_off() @@ -421,7 +454,7 @@ def _make_cluster_gates(self, gates_items): return cluster_gates - def _set_style(self,style): + def _set_style(self, style): if style is None: default_values = dict( @@ -464,12 +497,16 @@ def plot_qibo_circuit(self, circuit, scale, cluster_gates, style): for gate in circuit.queue: init_label = gate.name.upper() if "CCX" in init_label: - init_label = "TOFFOLI" + init_label = "TOFFOLI" if "CX" in init_label: - init_label = "CNOT" + init_label = "CNOT" - if len(gate._control_qubits) > 0 and "C" in init_label[0] and "CNOT" not in init_label: + if ( + len(gate._control_qubits) > 0 + and "C" in init_label[0] + and "CNOT" not in init_label + ): init_label = init_label[1:] item = () diff --git a/src/qibo/imaging/plot_styles.py b/src/qibo/imaging/plot_styles.py index 50ba3924e0..b0c3f93bca 100644 --- a/src/qibo/imaging/plot_styles.py +++ b/src/qibo/imaging/plot_styles.py @@ -1,45 +1,45 @@ def _get_style(style_name): - if 'garnacha' in style_name: - new_values = dict() - new_values["facecolor"]="#5e2129" - new_values["edgecolor"]="#FFFFFF" - new_values["linecolor"]="#FFFFFF" - new_values["textcolor"]="#FFFFFF" - new_values["fillcolor"]="#FFFFFF" - new_values["gatecolor"]="#5e2129" - new_values["controlcolor"]="#FFFFFF" - return new_values + if "garnacha" in style_name: + new_values = dict() + new_values["facecolor"] = "#5e2129" + new_values["edgecolor"] = "#FFFFFF" + new_values["linecolor"] = "#FFFFFF" + new_values["textcolor"] = "#FFFFFF" + new_values["fillcolor"] = "#FFFFFF" + new_values["gatecolor"] = "#5e2129" + new_values["controlcolor"] = "#FFFFFF" + return new_values - if 'fardelejo' in style_name: - new_values = dict() - new_values["facecolor"]="#e17a02" - new_values["edgecolor"]="#fef1e2" - new_values["linecolor"]="#fef1e2" - new_values["textcolor"]="#FFFFFF" - new_values["fillcolor"]="#fef1e2" - new_values["gatecolor"]="#8b4513" - new_values["controlcolor"]="#fef1e2" - return new_values + if "fardelejo" in style_name: + new_values = dict() + new_values["facecolor"] = "#e17a02" + new_values["edgecolor"] = "#fef1e2" + new_values["linecolor"] = "#fef1e2" + new_values["textcolor"] = "#FFFFFF" + new_values["fillcolor"] = "#fef1e2" + new_values["gatecolor"] = "#8b4513" + new_values["controlcolor"] = "#fef1e2" + return new_values - if 'quantumspain' in style_name: - new_values = dict() - new_values["facecolor"]="#EDEDF4" - new_values["edgecolor"]="#092D4E" - new_values["linecolor"]="#092D4E" - new_values["textcolor"]="#8561C3" - new_values["fillcolor"]="#092D4E" - new_values["gatecolor"]="#53E7CA" - new_values["controlcolor"]="#092D4E" - return new_values + if "quantumspain" in style_name: + new_values = dict() + new_values["facecolor"] = "#EDEDF4" + new_values["edgecolor"] = "#092D4E" + new_values["linecolor"] = "#092D4E" + new_values["textcolor"] = "#8561C3" + new_values["fillcolor"] = "#092D4E" + new_values["gatecolor"] = "#53E7CA" + new_values["controlcolor"] = "#092D4E" + return new_values - if 'color-blind' in style_name: - new_values = dict() - new_values["facecolor"]="#d55e00" - new_values["edgecolor"]="#f0e442" - new_values["linecolor"]="#f0e442" - new_values["textcolor"]="#f0e442" - new_values["fillcolor"]="#cc79a7" - new_values["gatecolor"]="#d55e00" - new_values["controlcolor"]="#f0e442" - return new_values + if "color-blind" in style_name: + new_values = dict() + new_values["facecolor"] = "#d55e00" + new_values["edgecolor"] = "#f0e442" + new_values["linecolor"] = "#f0e442" + new_values["textcolor"] = "#f0e442" + new_values["fillcolor"] = "#cc79a7" + new_values["gatecolor"] = "#d55e00" + new_values["controlcolor"] = "#f0e442" + return new_values From ffdf9b0b48439d174623131be8aaf5d3392ac72f Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 10:55:06 +0200 Subject: [PATCH 037/116] added enhancements based on feedback, reformat drawing class, new plot styles, init module file, detach matplotlib dependency for circuit --- .../qibo-draw-circuit-matplotlib.ipynb | 207 ++----- src/qibo/__init__.py | 1 - src/qibo/imaging/mpldrawer.py | 507 ----------------- src/qibo/imaging/plot_styles.py | 45 -- src/qibo/models/circuit.py | 10 - src/qibo/ui/__init__.py | 1 + src/qibo/ui/mpldrawer.py | 536 ++++++++++++++++++ src/qibo/ui/plot_styles.py | 45 ++ 8 files changed, 629 insertions(+), 723 deletions(-) delete mode 100644 src/qibo/imaging/mpldrawer.py delete mode 100644 src/qibo/imaging/plot_styles.py create mode 100644 src/qibo/ui/__init__.py create mode 100644 src/qibo/ui/mpldrawer.py create mode 100644 src/qibo/ui/plot_styles.py diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index c1f58ff649..22a1f4431c 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "66e4921b-c1ea-479d-9926-d93a7c784be9", "metadata": {}, "outputs": [], @@ -10,20 +10,19 @@ "# General libraries\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", - "import warnings\n", "\n", "# Qibo libraries\n", "import qibo\n", "from qibo import gates, models\n", "from qibo.models import Circuit\n", + "from qibo.ui import plot\n", "\n", - "warnings.filterwarnings(\"ignore\")\n", "%matplotlib inline" ] }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "eda54008", "metadata": {}, "outputs": [ @@ -63,23 +62,23 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "ea99c3d4-e36f-46ca-81c4-c8f10d6bcbe5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "(,
)" ] }, - "execution_count": 3, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -89,28 +88,28 @@ } ], "source": [ - "ansatz.draw_mpl(scale = 0.6, cluster_gates = False)" + "plot(ansatz, scale = 0.6, cluster_gates = False)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "id": "81b65ea2-06a0-437d-b8f3-2ac176ea9b25", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "(,
)" ] }, - "execution_count": 4, + "execution_count": 5, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -120,12 +119,12 @@ } ], "source": [ - "ansatz.draw_mpl(scale = 0.7, cluster_gates = True)" + "plot(ansatz, scale = 0.7, cluster_gates = True)" ] }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 6, "id": "62d00656-b40d-44f1-b56a-6733eeed6759", "metadata": {}, "outputs": [ @@ -159,75 +158,23 @@ }, { "cell_type": "code", - "execution_count": 23, - "id": "0eb15305", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "0" - ] - }, - "execution_count": 23, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "len(c.queue[0]._control_qubits)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, + "execution_count": 7, "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" - ] - }, - "execution_count": 24, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "c.draw_mpl(style=\"garnacha\")" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "id": "5e75d023-0ada-4cab-adff-2b7bb313a0b1", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" + "(,
)" ] }, - "execution_count": 25, + "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -237,12 +184,12 @@ } ], "source": [ - "c.draw_mpl()" + "plot(c)" ] }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 22, "id": "5f5896a5-e639-401c-992a-19b960720ec4", "metadata": {}, "outputs": [ @@ -267,23 +214,13 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 23, "id": "afa80613-6330-4a85-928f-4cb884d81990", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -293,28 +230,18 @@ } ], "source": [ - "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"garnacha\", save_file = \"file2.png\")" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\", save_file = \"file2.png\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 24, "id": "916f7b83-1ad7-4984-8573-eb55dfeb125d", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -324,28 +251,18 @@ } ], "source": [ - "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"fardelejo\")" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 25, "id": "b9e1176c-d8dc-47e4-9607-ad24f6f536b9", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAABJkAAAFICAYAAADzkC8GAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA8ZklEQVR4nO3deXxcdb3/8feZJZmkSSZNpk2TtI0paaEbrRQFBSx6+9MriMulF0XxClxBhQvXhStCXRAtyo5yLYiIIl4FLihbQa4FWkBKgW50hbQNSbOQNNskadaZM78/0rQJmTbJnNnP6/l48ODRmW/O+XxOZpI573zP9xgtLV0hAQAAAAAAABY4El0AAAAAAAAAUh8hEwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwjJAJAAAAAAAAlhEyAQAAAAAAwDJCJgAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgGSETAAAAAAAALCNkAgAAAAAAgGWETAAAAAAAALCMkAkAAAAAAACWETIBAAAAAADAMkImAAAAAAAAWEbIBAAAAAAAAMsImQAAAAAAAGAZIRMAAAAAAAAsI2QCAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJYRMgEAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAy1yJLiAV1TU2q9XfGfP9FHhzVVrki/l+hotXbxMV62Nhx77t2LNk374BAAAAJI94n5fE63yDkGmC6hqbtfQrV6m3tz/m+/J4MrTu/lviduIZz94mKpbHwo5927Fnyb59AwAAAEgeiTgvidf5BiHTBLX6O9Xb269FV39GOTNj983pqmnW1hsfV6u/M24nnfHqbaJifSzs2Lcde5bs2zcAAACA5BHv85J4nm8QMkUoZ6ZP3tnFiS4jJtK5t2OxY9927Fmyb98AAAAAkkc6npew8DcAAAAAAAAsI2QCAAAAAACAZRGFTK8/26C7r9qsjta+aNcDAAAAAACAFJT0azLtf6tDq3+zV8u+9D5VvH9yossZU0ZbSAtu7pd/tqG9F2WEHZOzz9Scewd04IMO7f+sO84VWjNUe8tJDlUvD197uDFZ9aYmbzOVXW8qqy4kd7fUWW6o8pLwxyiZ2LFnyZ5927FnAAAAAMllKFeQpIEcadvVGZLTGDXO02Rq3h0DkqS+fGnHdzPjWWZYSX+5XElFrjI8TlXtaE90KbAgf6epaeuCytkXUiB39JsjHdmxZ8mefduxZwAAAMRX7bsHJjS+vqlFpmnGqBrEQ8ghubsk79vhv4+Fb5gKGVIoiU5Bkj5kcjoNzZybp5pdHQoGeIOkqraFDu263K0t12Wo8uLUmr0VKTv2LNmzbzv2DAAAgPh5eeN2nXHBt7V63WvjGl9ZXaezv/Z9/eKBx2JbGGKqa6ahgGcwTBolGFLBlqA6KwyFnPGv7WiifrncQL+pN9c16e2Nrepq71d2nlsLPuxT6excPXL7W1q0dKo+dE7phLY5a2G+9mxuU21lp8rmeqNdMuKgt2h4nhlKWB3xZMeeJXv2bceeAQAAED+nLpqrs5aeosuvv1P64RU6e+kHjzq2srpO533zpyrIz9O/fWZZHKtEtJluqe1Eh3xvmHJ1hRTIOTJlyfuWKXeXVLvEqZyqQAKrHCmqM5n6e4N6YlWlXn+2QTn5bi08fYp8pVlav7peG56ulyT5SrMmvN0Zx+fK6TJUtd0fzXIBAAAAAEh6LpdTv7jmGzr7zMGg6WgzmoYHTA/fvkKF+XlxrhTR1rLEKcOUCjYHRzxe+IapQJbUPi+5LlCL6kymtQ/XqLmuWx87v0xzlhQcfnzL2ka9+tRgyFRYMvGQyZ3p1Izj81S9w6/QuSEZjiS64PAoMltCKl4TPk3MaGemAwAAAABg/IaCJklhZzQRMKWn7hkO9RQZKtxoqumMwcdcnSF53zZ14BSnQq7x5yN7quss1bJwTvmYY6IWMtVWdmrfm+2a9yHfiIBJko4/uUCvPlUvl9tQ/lRPRNsvX+DVOzv8erf6oIrLc6JRckx5WqXi54NjDwQAAAAAYByOFjQRMKW3liUOTX86qOz9prpnOFS4KSjDHHx8Iq5YucpSHbVr/zTmmKiFTDv+MbjS/eIzp456LjN7cDcF07LkGDYL6c2XmvTmuib1dAU0ZXq2Tv+X6fKVZIfdftl8rxwOqWpbe0qETP7ZhvZeFP725UO3QAcAAAAAYCLeGzQ1fOOL+tX/PEHAlMZaFztV8mxQhW8EB0Omjaa6Swz1lEwsZLpzxWWqKJvYGtkTFdWZTHm+TOUVZo56rrtjMFAZvh5T5aZWbVhdr48sn6Ep07O1ZW2TVv9mr86/ep4yPKOXRvdku+Sd4lFj9cGIa9z2dlXEXzvE6vSyZN7fuPY1lBEe64q/Q89F+zaKsToWY243gT1Lsemb7/VRpOH3GgAAAOnpkuX/rPqmZl333w8oPzdH11z6BdU3tai+qSXRpWEME/3cH8gx5D/BoYI3TbUvNOVpDmn/OVG/j1tURKWqvp6ABvpMTZke/tbdtZWdkqTCYbOU3nzxgOZ9yKfjTy6UJJ35rzP1hx9vU+WmNs3/sG/UNro7B9Te1KtFYWZKjdcnL10R8dcmitXpbNEWPHS1o6v76GNcB0OHxkb3LDxRxyKRPUv27NuOPUvJ934HAABAamjv7NKF19yc6DIQQy0nOzR5h6myRwZkuqTWxRNf8DtlLpcbugSur2f0GkTBgKmtLzRJOjKTKRgw1VzfrZM/Pu3INpyGSo7LVWP1wbAh0zs7/AqFpPIF+RHX+cw9KyP+2iF7quvieiIYj+lsQ8bTW6/PkOmUsmtNKRiSnKNPtCftHzwJ75kW3ZPwWB2LsfpOZM9SbPrmex1eOn6vAQAAkH5qGpr0vVt/K2/OJP378k/qB7/8vRyGoWsu/YJOX7Ig0eVhDJHkCh2zHerPkzI6pNYTHQpmTfx8JGUul3NnOpUzOUOtDT1qaehRYfGRMOmFh2rU1tQrw5AKDj3eezCokCll5YzcvSfHpY6WvrD7qNrWruw8t6bODL9m03iMZyX0ZFNRVppUdYfchtoWOlS4xVTxC0E1LHvP9/BdU77XgwpmSv4o30oxUccikT1L9uzbjj1Lyfd+BwAAQPKprK7T9+/4vaYWTtbDt684fHncGScv1I33PqyZJUUj7jqHNOEwtO8Ct9wdIfUUR3YuEo/zjahdxLd46VS9/FitHl9VqYrFk+V0Gare6VduQaacLkN5BZlyZ0R2IPp6gqrb06W5pxTKMGKwEAompO4slybtH1Dx80HlvWWqq9yhkEvKbA7Ju8uUJL1znmtEsprZZGrai4Mz3RyH1jz3HAip7JEjC6BXLw9/uWUysGPPkj37tmPPAAAASA3h7iI3FDL918X/qvy8nBF3nUN66Z4e/T90R1vUQqb5p/nU1xvUzvXN2v1ai/IKMzT3VJ/K53v14E27VDhs0W/PJKcMh9TTFRixjd6ugLJzR5+I1ezyywyGVL7AG61yYUEgx9Duy90qejko7y5TvteCMoJSIEdqX+BQ4xnOUavcu7ukwk3mMR+rXh6X8iNix54le/Ztx54BAACQ/MIFTMM5nY4Rd50jaEIiRC1kMgxDS5ZN05Jl00Y8vm9buyTJV3IkZHK6HPKVZKu2slNl8waDIzMYUv3eTn3gn0tGbbtqu1+ZWU6VHJcbrXJjpn+yoU03jL7D3nBdsxxjjkl2psdQwzKXGpaNbzw9py479m3HngEAAJC89owRMA1xuZwjgibjR1forI8QNKWa8eQKw225PnnORWJ+z7uW+h5JGjGTSZJO/MgUrX24RlOmZ8tXmqWt65pkOA3NPmnyiHGBAVM1uzs0a6FXjjCL8AIAAAAAkM6yPJl6/7wK3fxflxw1YBoyFDR5MjOUNynyNY2BSMQtZPKVjnxxzz6pQD0HA3rtmXp1dwY0ZUa2zr7kOGV4nCPGNVR1yeUyNOvEkeETAAAAAAB2UFrk030rvzPu8S6XU7d+99IYVgSEF/OQqbm+R5O8bmVNGr2rE8+YqhPPmHrMr58xJ08XXn9irMoDAAAAAABAFEQUMpUclyNpmjKznGOOvWDF/Eh2AQAAAAAAgBQSUchUWpGr0orkX4QbAAAAAAAA8eEYewgAAAAAAABwbIRMAAAAAAAAsIyQCQAAAAAAAJbF/O5y6aqrpjmlt5+s+w4nXvXYsW879hzP/YxXstUDAAAAIPbS8fyHkGmCCry58ngytPXGx2O+L48nQwXe+C2wHs/eJiqWx8KOfduxZ8m+fQMAAABIHok4L4nX+YbR0tIVivle0kxdY7Na/Z0x30+BN1elRb6Y72e4aPW2p7pOV6xcpTtXXKaKslLL24v1sbBj33bsWbJv3wAAAEhP296u0icvXaFn7lmphXPKE10OxileucKQeJ1vMJMpAqVFvrQ9GYx2bxVlpSnxg86OfduxZ8m+fQMAAABIHumaK7DwNwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwjJAJAAAAAAAAlhEyAQAAAAAAwDJCJgAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgGSETAAAAAAAALCNkAgAAAAAAgGWETAAAAAAAALCMkAkAAAAAAACWETIBAAAAAADAMkImAAAAAAAAWEbIBAAAAAAAAMsImQAAAAAAAGAZIRMAAAAAAAAsI2QCAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJYRMgEAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwzJXoAgAAiVPX2KxWf2fM91PgzVVpkS/m+xkuXr1NVKyPhR37tmPPAAAgtcX780u8PpcQMgGATdU1NmvpV65Sb29/zPfl8WRo3f23xO2EO569TVQsj4Ud+7ZjzwAAILUl4vNLvD6XEDIBgE21+jvV29uvRVd/RjkzY/fLpqumWVtvfFyt/s64nWzHq7eJivWxsGPfduwZAACktnh/fonn5xJCJgCwuZyZPnlnFye6jJhI596OxY5927FnAACQ2tLx8wsLfwMAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAyyIKmV5/tkF3X7VZHa190a4HAAAAAAAAKSjpF/7e/1aHVv9mr5Z96X2qeP/kRJcDALaR0RbSgpv75Z9taO9FGWHH5OwzNefeAR34oEP7P+uOc4XWDNXecpJD1cvD1x5uTFa9qcnbTGXXm8qqC8ndLXWWG6q8JPwxSiZ27Fmyb98AACA1DX0Ol6SBHGnb1RmS0xg1ztNkat4dA5Kkvnxpx3cz41lmWEl/uVxJRa4yPE5V7WhPdCkAACh/p6lp64LK2RdSIHf0L/t0ZMeeJfv2DQBAsnjtzd16+sXXxj2+vbNLv3zgMZmmGcOq4ifkkNxdkvft8P0UvmEqZEihJPqYkvQzmZxOQzPn5ql6p1/BgCmnK+lzMQBAGmtb6FD7XId6phlydUsn/qw/0SXFnB17luzbNwAAyeJ/n31JDz+zTqt+dKXOXvrBY45t7+zS+d+5QbXvNutzy07TjOIpcaoydrpmGsp6N6TCN0z55zpHPhkMqWBLUJ0VhnKqQokpMIyoh0wD/abeXNektze2qqu9X9l5bi34sE+ls3P1yO1vadHSqfrQOaUT2uashfnas7lNtZWdKpvrjXbJAACMW2/R8D92JM8v9FiyY8+SffsGACBZ/OxbF6u7p1eX/fiXxwyahgdMD922Ii0CJkky3VLbiQ753jDl6gopkHNkypL3LVPuLql2iVM5VYEEVjlSVEOm/t6gnrx7jw7Udqu0IkflC7zyt/Rp/ep6zZiTK0nylWZNeLszjs+V02WoarufkCkF9A8EtGHrbklSY3ObFs4pT3BFAAAAAIBU43I59YtrL5OkowZN7w2Y5lWUJaLUmGlZ4tSU10wVbA6q6YwjEU7hG6YCWVL7PIfG2/Ge6jpLtYzn3D6qIdPah2vUXNetj51fpjlLCg4/vmVto159ql6SVFgy8ZDJnenUjOPzVL3Dr9C5IRmOJLrgECOs37JLl/7odrX5uyRJF157iy4455+08psXyenkUkcgFWW2hFS8JvxfRzLamd0BAACA2DlW0JTuAZMkdc9wqKfIUOFGU01nDD7m6gzJ+7apA6c4FXKNPx+5YuUqS7XUrv3TmGOiFjLVVnZq35vtmvch34iASZKOP7lArz5VL5fbUP5UT0TbL1/g1Ts7/Hq3+qCKy3OiUTKirM3fqX/73k3q6xu5ZsX/PPmcykqn6htfOCdBlQGwwtMqFT8fTHQZAAAAsKlwQdNpJ81L+4BpSMsSh6Y/HVT2flPdMxwq3BSUYQ4+PhF3rrhMFWUTW75ooqIWMu34xwFJ0uIzp456LjN7cDcF07LkODQLad+2du14pVnNtd3q6wnqi9fOU17B0W+3VzbfK4dDqtrWHnHItO3tqoi+DuPz2HOvqKe3b9TjIUm/fnC1Tj9pQfyLirOh6YdWpyGmEjv2LKVH3+Ot3T/b0N6Lwt+yfei279HcXzQk+/clVvXZsW879gwAwHDp8Ll0vC7510+qvfOgvn7dHSrw5qq/P6Cff+ffFTTNlDrfn+j3qnWxUyXPBlX4RnAwZNpoqrvEUE9J8l0tFNWZTHm+TOUVjg6KujsGT0CGr8cU6DdVMitH5fO9evmx2jG378l2yTvFo8bqgxHX+MlLV0T8tbCmub3DVsff6jTEVGTHniX79h2JpDtWQzOLj3XF36Hnon1b2IQdiwT2LNmz76R73QMA0pbdfue0tHdKki7/yX8nuJLYC+QY8p/gUMGbptoXmvI0h7T/nInHOSlzuVxfT0ADfaamTHeHL6Ry8JtfWJJ9+LGhS+paG3rGtY/uzgG1N/VqUZiZUuP1zD0rI/5ajG3N+k269XePhn3ufaVFuutHV8a5ovjbU12nK1auiss0xGRhx56l9Oh7qId4ieexGk9vwUNXb7u6jz7GdTB0aGx0k4dYHYux+k5kz1Js+rbr9xoAgCHp8Ll0vDoP9uja2+9TfVOLunv7ZBiGrr30Czp9SWpdNRPJ5/CWkx2avMNU2SMDMl1S6+KJz2JKmcvlhi6B6+sZvWZHMGBq6wtNkiK7s9yQd3b4FQpJ5QvyI94GdzmLrYqyUj349Fq9e6BNQdMc8dzVX/28rY5/RVmprfqV7NmzZN++I5Fsx6rXZ8h0Stm1phQMSc7R4cKk/YPBQ8+06AYPiToWiexZsmffyfa6BwCkr3T/nTO0yHdLe4du/q9LdPlP/lsfOXmBfv6bh7SqpGjUXefSTcdsh/rzpIwOqfVEh4JZE//MEo/XSFQu4HNnOpUzOUOtDT1qGTYzKRgw9cJDNWpr6pVhSAXFkYdMVdvalZ3n1tSZ2WMPRkJkZWbokTt+qFMWnXD4MV9+nm666hKd89FTE1gZAIwWchtqW+iQ+6BU/MLoP5J43jXlez2oYKbkn5d817tHwo49S/btGwCAdPHeu8jNmlEsSfqvi8/Tp848RZf9+Jdave61BFcZYw5D+y5wa+8FLtV/ImorH0Vd1CpbvHSqXn6sVo+vqlTF4slyugxV7/QrtyBTTpehvIJMuTMi++DW1xNU3Z4uzT2lUIYRg0UiEDUziqfo4du/r8aWNnV2daustEhuV/K+AQDYW91ZLk3aP6Di54PKe8tUV7lDIZeU2RySd9fgjMx3znON+EtRZpOpaS8OBhWOQ2ueew6EVPbIkQXQq5eHv3w8GdixZ8m+fQMAkOreGzDNqyg7vMi30+kYdde5dJ7R1D09+f8YFrWz//mn+dTXG9TO9c3a/VqL8gozNPdUn8rne/XgTbtUaOFSuZpdfpnBkMoXeKNVLmKsqHCyigonJ7oMADimQI6h3Ze7VfRyUN5dpnyvBWUEpUCO1L7AocYznKPu2uHukgo3mcd8rHp5XMqPiB17luzbNwAAqSxcwPReLpfTVkFTsotayGQYhpYsm6Yly6aNeHzftnZJkq/EwqVy2/3KzHKq5LhcKyUCACagf7KhTTeMvmPocF2zHGOOSXamx1DDMpcalo1vPD2nLrv2DQBAqvruzfceM2AaMjxouvz6O7XggVtUVlIUrzKjbjyfw4fbcn3yfF6J+XVMLfWDazS9dyZTb3dAXW396mjplyS1NfaqvyeonMkZ8mQfKSswYKpmd4dmLfTKEWahTgAAAAAAkH5+dPkF8nd1a95xM8ccOxQ0nfuJM1I6YEp1cQuZfKUjF+x+Z4dfax+qOfzvZ367T5J05udn6oQPFB5+vKGqSy6XoVkncukVAAAAAAB2UVrkU+kE8iKXy6mPnbI4ZvVgbDEPmZrrezTJ61bWpJG7OuEDhSPCpKOZMSdPF15/YqzKAwAAAAAAQBREFDKVHJcjaZoys5xjjr1gxfxIdgEAAAAAAIAUElHIVFqRq9IKFuEGAAAAAADAIMfYQwAAAAAAAIBjI2QCAAAAAACAZYRMAAAAAAAAsCzmd5cDACS3rprmlN5+su47nHjVY8e+7dgzAABIben42ZCQCQBsqsCbK48nQ1tvfDzm+/J4MlTgjd8NI+LZ20TF8ljYsW879gwAAFJbIj6/xOtzCSETANhUaZFP6+6/Ra3+zpjvq8Cbq9IiX8z3MySave2prtMVK1fpzhWXqaKs1PL2Ynks7Ni3HXsGAACpLZ6fw4fE63MJIRMA2FhpkS9tT4Kj3VtFWakWzimP2vZixY5927FnAACQ2tL1czgLfwMAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwjJAJAAAAAAAAlhEyAQAAAAAAwDJCJgAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgGSETAAAAAAAALCNkAgAAAAAAgGWETAAAAAAAALCMkAkAAAAAAACWETIBAAAAAADAMkImAAAAAAAAWEbIBAAAAAAAAMsImQAAAAAAAGAZIRMAAAAAAAAsI2QCAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJYRMgEAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAy1yJLgAAAADRU9fYrFZ/Z8z3U+DNVWmRL+b7ea949TdRsTweduwZAJCaCJkAAADSRF1js5Z+5Sr19vbHfF8eT4bW3X9LXEOGePY3UbE6HnbsGQCQugiZAAAA0kSrv1O9vf1adPVnlDMzdif+XTXN2nrj42r1d8Y1YIhXfxMVy+Nhx54BAKmLkAkAACDN5Mz0yTu7ONFlxEy69xeOHXsGAKQeFv4GAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJZFFDK9/myD7r5qszpa+6JdDwAAAAAAAFJQ0i/8vf+tDq3+zV4t+9L7VPH+yYkuBwAAIKVltIW04OZ++Wcb2ntRRtgxOftMzbl3QAc+6ND+z7rjXGHkhupuOcmh6uXh6w43Jqve1ORtprLrTWXVheTuljrLDVVeEv74JBu79g0ASD5Jf7lcSUWuMjxOVe1oT3QpAAAASEP5O01NWxdUzr6QArlGosuJG7v2DQCInaSfyeR0Gpo5N0/VO/0KBkw5XUmfiwEAACCFtC10qH2uQz3TDLm6pRN/1p/okuLCrn0DAGIn6iHTQL+pN9c16e2Nrepq71d2nlsLPuxT6excPXL7W1q0dKo+dE7phLY5a2G+9mxuU21lp8rmeqNdMgAAAGyst2j4HzFDCasj3uzaNwAgdqI6Lai/N6gnVlXq9WcblJPv1sLTp8hXmqX1q+u14el6SZKvNGvC251xfK6cLkNV2/3RLBeImpb2Dt36u0f07Rt/LUla+9pWmaaZ4KoAWBEKhfTU2g364Z1/kCTd/9e/q6mlPbFFAQAAAEksqjOZ1j5co+a6bn3s/DLNWVJw+PEtaxv16lODIVNhycRDJnemUzOOz1P1Dr9C54ZkOLhmHMmjvqlF51z2Qx1obZdpDv4V8MZ7H9bemgbdfs3XZRi8XoFUdO3tv9MDT6w5/B5+6G/r9Pf1m/TkXddrZvHUBFcHWJfZElLxmkDY5zLamdUCAAAmLmozmWorO7XvzXbNPdU3ImCSpONPHvy3y20of6onou2XL/Cqpyugd6sPWq4ViKY77v+Lmtv8hwOmIY/830va8ObuBFUFwIotu/fqgSfWSBqc0TT0//aOLt3824cTWRoQNZ5Wqfj5YNj/CjcxGxcAAExc1GYy7fjHAUnS4jNH/3U3M3twNwXTsuQ4NAtp03Pvqmpbu9oP9Mnldqh4Vo5O/VSJ8goyw26/bL5XDodUta1dxeU5EdW47e2qiL4OOJYnXlivYHD0h3Gnw6E/PvGcJmVFFqymij3VdSP+bxd27dsu/vj4c3I4jFHhcdA09dTa13Tpeen/+8SOr/F06HkitftnG9p7Ufhb1Q/d7j6a+4uGZP/exKI+O/YMYGLS4ffXRNmx52SwcE75mGOiFjLVVnYqz5epvMLRIVF3x+CHlOHrMTXs69KC06ZoyoxsmcGQ1j9Vp6fv3avzvjNXDufoy4s82S55p3jUaGEm0ycvXRHx1wITFTRNPfbcK3rsuVcSXUpcXLFyVaJLSAi79m1nA4GArX6f2PE1bseeI5V0x2roI+SxrvY79FwoBlezJ+x4JLDvpHsNADZmx/ejHXtOpNq1fxpzTFRCpr6egAb6TE2Z7g5fSGWnJKmwJPvwY2dfUjFizNLlM/Wnn+1UW2Nv2HWbujsH1N7Uq0VhZkqN1zP3rIz4a4Gj+cUf/qr/e2XjqBkPknTTVV8dV9qbyvZU1+mKlat054rLVFE2sTtHpjK79m0Xb79Tp/+8YfSHFodhaOkHFuq7X/18AqqKLzu+xtOh56Ee4iXex2qs/oKHJg+7uo++DdfB0KGx0U+ZYnE8xvM9TWTfqfx+AdJFOvz+mig79pwqohIyDV0C19cTHPVcMGBq6wtNko59Z7n+3sGvzcx2hn3+nR1+hUJS+YL8iOtM95N9JMb1V35Fm3fv1YFWv0zTPHyJzfKPn6Hzz/6obRb+rigrteV7zK59p7uFc8r1xva39cATa+RwOA69tx2anJejld+62FYLf9vxNW7HniOVbMeq12fIdErZtaYUDElhZsdP2j8YtvRMi/7v50Qdj0T2nWyvAcDO7Ph+tGPPyS4qIZM706mcyRlqbehRS0OPCosHw6RgwNQLD9WoralXhiEVFIcPmUxz8HK5mSfkKSc//NoAVdvalZ3n1tSZ2WGfBxKlZGqh/u/en+n+x/6ul97YppxJWTr342fo0x891TYBE5CObvjWRTrtpPn632dflL+jS6edNF9f+ezHNbUwP9GlATiKkNtQ20KHCreYKn4hqIZlIz/qet415Xs9qGCm5J8XtfvfJJxd+wYAJJ+orcm0eOlUvfxYrR5fVamKxZPldBmq3ulXbkGmnC5DeQWZcmeM/qUWCoX04qP71dU2oM/+x+yw2+7rCapuT5fmnlLISTuSUmF+nr594bn69oXnJroUAFFiGIY+deYp+tSZpyS6FAATUHeWS5P2D6j4+aDy3jLVVe5QyCVlNofk3TV4o453znMpmHXkM2Vmk6lpLw7OqnccWu/ccyCkskeOLH5evTz8shDJwq59AwCSS9RCpvmn+dTXG9TO9c3a/VqL8gozNPdUn8rne/XgTbtUGOZSuVAopJf+Uqu6tzv1mctnKysn/C+xml1+mcGQyhd4o1UuAAAA0lAgx9Duy90qejko7y5TvteCMoJSIEdqX+BQ4xlO9ZSM/MOnu0sq3GQe87Hq5XEpP2J27RsAkFyiFjIZhqEly6ZpybJpIx7ft61dkuR7z2LeQwFTzS6/Pv2N2Ue9TE6Sqrb7lZnlVMlxudEqFwAAwJb6JxvadMPouwEP1zXLMeaYZGZ6DDUsc6lh2fjGp3q/Q+zaNwAgecT8ouyW+h5JGjWT6aW/1GrPljb905feJ5fboe6OAXV3DCgYGPnXlMCAqZrdHSqblydHmEUMAQAAAAAAkHhRm8l0NEMhk6905ILdO9c3S5Ie/1XliMfP+XqFSiuOzFhqqOqSy2Vo1omTY1wpAAAAAAAAIhXzkKm5vkeTvG5lTRq5q6/f8v5xff2MOXm68PoTY1EaAAAAAAAAoiSikKnkuBxJ05SZ5Rxz7AUr5keyCwAAAAAAAKSQiEKm0orcEZe0AQAAAAAAwN5ivvA3AAAAAAAA0h8hEwAAAAAAACyL+cLfAAAAiK+umuaU3n6y7/+94lGPHXsGAKQeQiYAAIA0UeDNlceToa03Ph7zfXk8GSrwxneNznj2N1GxOh527BkAkLoImQAAANJEaZFP6+6/Ra3+zpjvq8Cbq9IiX8z3M1w0+9tTXacrVq7SnSsuU0VZqeXtxep42LFnAEDqImQCAABII6VFvrQ+8Y92fxVlpVo4pzxq24sFO/YMAEhNLPwNAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwjJAJAAAAAAAAlhEyAQAAAAAAwDJCJgAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgGSETAAAAAAAALCNkAgAAAAAAgGWETAAAAAAAALCMkAkAAAAAAACWETIBAAAAAADAMkImAAAAAAAAWEbIBAAAAAAAAMsImQAAAAAAAGAZIRMAAAAAAAAsI2QCAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJYRMgEAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACxzJboAAAAAABivusZmtfo7Y76fAm+uSot8Md/PcPHqbaIScSwApCZCJgAAAAApoa6xWUu/cpV6e/tjvi+PJ0Pr7r8lbuFKPHubqHgfCwCpi5AJAAAAQEpo9Xeqt7dfi67+jHJmxi7w6Kpp1tYbH1ervzNuwUq8epuoRBwLAKmLkAkAAABASsmZ6ZN3dnGiy4iJdO4NQPpj4W8AAAAAAABYRsgEAAAAAAAAywiZAAAAAAAAYFlEIdPrzzbo7qs2q6O1L9r1AAAAAAAAIAUl/cLf+9/q0Orf7NWyL71PFe+fnOhyAAAAACSpjLaQFtzcL/9sQ3svygg7JmefqTn3DujABx3a/1l3nCu0Zqj2lpMcql4evvZwY7LqTU3eZiq73lRWXUjubqmz3FDlJeGPEQBEKukvlyupyFWGx6mqHe2JLgUAAAAAUk7+TlPT1gWVsy+kQK6R6HKAcatrbNbOvTXjHh8IBPX8hi2xKwhjSvqQyek0NHNunmp2dSgYMBNdDgAAAACklLaFDu263K0t12Wo8uLUmr0Fe/vxr/6oz3/rp9q5p3rMsYFAUP95wypdfO2tqq5vjEN1CCfqIdNAv6mNf39Xf/75Tv3me1v0Pzfs0Na1jWqu69bdV23W+ifrJrzNWQvzNdBnqrayM9rlAgAAAEBa6y1yqKfUITmZxYTUctN/fVXTp/n0+W+vPGbQNBQwPbV2g371wytUVlIUxyoxXFRDpv7eoJ5YVanXn21QTr5bC0+fIl9pltavrteGp+slSb7SrAlvd8bxuXK6DFVt90ezXABR0HGwW5LU09uf4EoAREsgEFTtuwcSXQYQMz29fappaEp0GQCAMeTn5ujPt157zKBpeMC06kdX6uylH0xApRgS1YW/1z5co+a6bn3s/DLNWVJw+PEtaxv16lODIVNhycRDJnemUzOOz1P1Dr9C54ZkOEjggUTr6u7R9+/4vf6y5mVJ0he+s1JfXf5Jffffz5PL5UxwdQAi9cj/vaSVd/9JB1oH/7Bz1U336K7rrtSs6cUJrgywzjRN3Xb/X3TPQ6vV3Tt4l+Sf3fOg7vrRlfLmTkpwdYimzJaQitcEwj6X0R6KczUArBgKms7/zg36/LdX6qHbVhx+LhgkYEo2UZvJVFvZqX1vtmvuqb4RAZMkHX/y4L9dbkP5Uz0Rbb98gVc9XQG9W33Qcq0ArPvGj3+pv6z5h0xz8INa/0BAdz34pG787cMJrgxApP7+ykZ984a7DgdMkrRrb42WX/kTdXX3JLAyIDru+MNfdcf9fzkcMEnSyxu366s/uC2BVSEWPK1S8fPBsP8VbmKdVyDVvHdG0779DZKkm+97hIApyURtJtOOfwxOq1985tRRz2VmD+6mYFqWHIdmIW19sUm7N7Sos61fDochX2mWTjmrREVl4f+KVDbfK4dDqtrWruLynGiVDSACb1XV6oUNW0c9HgpJ9z36N/3nlz+rnOyJz1oEkFh3/vFxOQxDZujIX/nNUEhNre3669//oS9/ZlkCqwOs6enr168fWj3qcTMU0votu7R19z4tOmFWAipDLPhnG9p7UUbY53L2mZpz70CcKwJg1fAZTdfcdp8k6aWN23UXAVNSiVrIVFvZqTxfpvIKM0c9190x+EN8+HpMuZMz9OFPlyqvMFPBgKltLx3Q6t/s1RevmSfPpNFlebJd8k7xqNHCTKZtb1dF/LUAjlj3+ptHfa6vf0DPvbpFs6ZPi2NF8benum7E/4F0sHNP9YiAaYjT4dA/Nu/Q4rnHJaCq+OF9nd7qGlt0sKf3qM///ZVNh/8Ymq7S4TUe79rjub9x7WvoJXqsK/4OPReK8ss5lV836S4d3tsTseLS83XR9wdnoH76o6doZvEUzvXjZOGc8jHHRCVk6usJaKDP1JTp4W+HOXRXuMKS7MOPzVqYP2LMh84p1a4NLWp9t0clx+WO2kZ354Dam3q1KMxMqfH65KUrxh4EwLLLr78z0SXEzRUrVyW6BCDmgqapp9Zu0FNrNyS6lLjgfW1Pd/zhL7rjD39JdBlxwWt8/JLtWAUPrTzi6j76GNfB0KGx0U2Zku1YYDQ7fo8ee269HntufaLLsI3atX8ac0xUQqahv/r09QRHPRcMmNr6wuDdO452Z7lgwNTOV5uVmeVUQXH4Me/s8CsUksoX5Edc5zP3rIz4awEcEQqF9PXrfqHaxubDazJJksMwdNpJ83Xt185PYHXxsae6TlesXKU7V1ymirLSRJcDRMWTa1/Vqj89Oepxl8up399wlQrz8xJQVfzwvk5/t/3uEa15dYtCw2bsGZKKfJN170++LaczqjdeTjrp8Bof6iFe4nmsxtNbr8+Q6ZSya00pGJKco4OkSfsHX98906IbMqXy6ybdpcN7ezyCwaBuvu8RvbRxu6666FwVenP16/99Rs2tfv3s2xdr1gxuUpIMohIyuTOdypmcodaGHrU09KjwUFAUDJh64aEatTX1yjA0KkBq2Nel1ffuVXDAVFauW5/6WoU82eFLqtrWruw8t6bOzA77/HiMZ2oXgPF58LYV+sr3blblsGm5H1o8T3df95+2ukNPRVkpP1uQNuZXlKm/P6DfPvq3wyfh3pxJuuu6K/WRkxcmuLr44X2dvu78wX/oGz/+5Yh1BctKi/SHn3/XVicnvMbHL9mOVchtqG2hQ4VbTBW/EFTDspHnTp53TfleDyqYKfnnRTc0TbZjgdHS+XsUCAzeRe7l96zBdPZHT9X537lB3//F7/XQbSs0r6IswZUiamsyLV46VS8/VqvHV1WqYvFkOV2Gqnf6lVuQKafLUF5BptwZI3/QTZmRrX/99gnqPRjQrg0t+vsDVfrclccr6z1rMvX1BFW3p0tzTymUYaT3tfJAqphZPFXP//4mbXhzt+oaW3R8+XQtmP2+RJcFwAKHw6Hr/uPLuvS8s7Thzd3KyfbojCUL5ckMv3gukGpysrP0wI1Xa+feGu3aW6NpUybrQ4vmyuFI7xlMSC91Z7k0af+Aip8PKu8tU13lDoVcUmZzSN5dg3fOe+c8l4JZR86bMptMTXtx8KoTx6E1zz0HQip75MgC6NXLwy99AiTaUMAU7i5ywxcD//y3VxI0JYGohUzzT/Oprzeoneubtfu1FuUVZmjuqT6Vz/fqwZt2qTDMpXIut0NeX6a8vkwVlU3Sn36+U2+91qLFHy0aMa5ml19mMKTyBd5olQsgCgzD0KmL5ia6DABRVjK1UJ9bdlqiywBiZt5xMzXvuJmJLgOISCDH0O7L3Sp6OSjvLlO+14IyglIgR2pf4FDjGU71lIwMTt1dUuEm85iPVS+PS/nAhBwrYBpC0JRcohYyGYahJcumacmykXeU2retXZLkKxnH7cxDIQWDo2+VULXdr8wsZ9gFwQEAAABAkvonG9p0w+i7XQ/XNcsx5phkZ3oMNSxzqWHZ+ManQ8+wp2tuv++YAdOQ9wZNT/96pWYUT4ljpRgStZDpaFrqeyRp1EymV5+qU9l8r3K8GerrCWj7K8066B8Ydde5wICpmt0dmrXQK0eYhe0AAAAAAED6+ddPnKGPnrJIZ33k6AHTkKGg6Q+PrVFpUWEcqkM4cQuZfKUjF+w+2DGgNX98Rz1dAXmynZoyI1ufuWy2Jhd5RoxrqOqSy2Vo1omTY10qAAAAAABIEh888YQJjc/PzdGVX/5sbIrBuMQ8ZGqu79Ekr3vUYt7/9MX3jevrZ8zJ04XXnxiDygAAAAAAABAtEYVMJcflSJqmzCznmGMvWDE/kl0AAAAAAAAghUQUMpVW5Kq0gkW4AQAAAAAAMMgx9hAAAAAAAADg2AiZAAAAAAAAYBkhEwAAAAAAACyL+d3lAAAAACCaumqaU3r7ybrvcJKtHgDJjZAJAAAAQEoo8ObK48nQ1hsfj/m+PJ4MFXjjd7OjePY2UfE+FgBSFyETAAAAgJRQWuTTuvtvUau/M+b7KvDmqrTIF/P9DIlmb3uq63TFylW6c8Vlqigrtby9eB8LAKmLkAkAAABAyigt8qVt4BHt3irKSrVwTnnUtgcAY2HhbwAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgGSETAAAAAAAALCNkAgAAAAAAgGWETAAAAAAAALCMkAkAAAAAAACWETIBAAAAAADAMkImAAAAAAAAWEbIBAAAAAAAAMsImQAAAAAAAGAZIRMAAAAAAAAsI2QCAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJYRMgEAAAAAAMAyQiYAAAAAAABYRsgEAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwjJAJAAAAAAAAlhEyAQAAAAAAwDJCJgAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgmSvRBQAAAAAA8F51jc1q9XfGfD8F3lyVFvlivh/ADgiZAAAAAABJpa6xWUu/cpV6e/tjvi+PJ0Pr7r+FoAmIAkImAAAAAEBSafV3qre3X4uu/oxyZsYu/OmqadbWGx9Xq7+TkAmIAkImAAAAAEBSypnpk3d2caLLADBOLPwNAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACyLKGR6/dkG3X3VZnW09kW7HgAAAAAAAKSgpJ/JtP+tDt191Wbt2dyW6FIAAAAAAEkioy2kk67t03G/6z/qmJx9pk66tk8zHhuIY2WAfSV9yFRSkasMj1NVO9oTXQoAAAAAAHFX19isi1fcqpb2jnGNDwSC+s5N9+jljdtjXBkwUtKHTE6noZlz81Szq0PBgJnocgAAAAAAiKue3j5t3rlH531r5ZhBUyAQ1H/+7C49+uxL6jjYHacKgUFRD5kG+k1t/Pu7+vPPd+o339ui/7lhh7aubVRzXbfuvmqz1j9ZN+FtzlqYr4E+U7WVndEuFwAAAACApFZRVqqH7/i+Wts7jhk0DQVMq9du0K9+eIXO+sgH41wp7C6qIVN/b1BPrKrU6882KCffrYWnT5GvNEvrV9drw9P1kiRfadaEtzvj+Fw5XYaqtvujWS4ATFgoFNKmnXt036N/kyTt2FOtUCiU4KoAWNXa3qG/rnlZkvTMS6/rYHdvgisCoquq9l398cnnJEmvbN6hQCCY4IoQK/w8S1+zxwiagsGRAdPZSwmYEH+uaG5s7cM1aq7r1sfOL9OcJQWHH9+ytlGvPjUYMhWWTDxkcmc6NeP4PFXv8Ct0bkiGw4hazQAwXqFQSNfe/js98MQaOQ79HLrqpnu0Yesu3Xr11+RwJP0VyADCeHXrLn356pvU2zt419xfPvCYHly9Vo/88geaNb04wdUB1v3xyed0zW2/laHB310/uetPeuL5V/Xgbdcqd1J2gqtDNNn151lmS0jFawJhn8toT68/Bg4FTed986c671sr9fDtKw4/d8vvHtHLG3cQMCGhonZGVFvZqX1vtmvuqb4RAZMkHX/y4L9dbkP5Uz0Rbb98gVc9XQG9W33Qcq0AEIm/vfyGHnhijSTJNI98YPnfZ1/SX9e8kqiyAFjQPxDQ1370C/X19Wv4aUiLv0Pf+tndCasLiJbq+kZdc9t9CoUkc9jM222V7+jW3z2awMoQbXb+eeZplYqfD4b9r3BT+q3r+94ZTa2HZjS99MZ2AiYkXNRmMu34xwFJ0uIzp456LjN7cDcF07IO//V/uBcf3a+d65t1+mena8HpU8Juv2y+Vw6HVLWtXcXlORHVuO3tqoi+DgAk6b5H/yaHYYz4kC5JhiH9/q/Pas77ShNUGYBIvbH97bDrWgSDpjbuqNSa9ZtUVDg5AZUB0fHn1WvDPm6aph5c/YLO/fjp8S0IMZNuP8/2VI9/LV//bEN7L8oI+1zOPlNz7h2I6v6SxU+/eaGuvvW3+vcf3C5JuvBz/08zi6dw3ouYWTinfMwxUQuZais7lefLVF5h5qjnujsG39Th1mOq3ulXY/VBZee5j7l9T7ZL3ikeNVqYyfTJS1eMPQgAJigUkjbv2svPGCANXXjNLYkuAYiZrp5efnfZCD/Pju2KlasSXYJlv330Wf320WcTXQbSWO3aP405JiohU19PQAN9pqZMDx8UDd0VrrBk5DXf3Z0DevHR/Trrq8fpmfv2HXMf3Z0Dam/q1aIwM6XG65l7Vkb8tQDw56de0ANPrtF71/l2GIaW//MZuuhzn0hMYQAi1tzWoX+7+kaFW7EjLydbf7zpe3K7nHGvC4iW17e/pR/+8g+jHjcMQ4tOmKWffeviBFSFWEi3n2d7quviGvzcueIyVZSlzqz0YDCoW373iF56Y7su/Nz/08N/e1GT83J141VfVX7upESXBxuLSsg0dAlcX8/ou1QEA6a2vtAkafRMphceqtHC06eosHjsxcDf2eFXKCSVL8iPuM7xTO0CgKMpvbhQ//fKRh1o8ysYHLy+3+l0KD83R1d/9fMpNQUdwBH/vvyTuveRZw7/2zAMhUIhrfj6F3XSvIoEVgZYN7+iTE+tfU1vbH/r8HqCDodDDsPQj//jy3w+TjP8PItcRVlpyrwfAoHBu8i9vHGHVv3oSp299IO64NPLdN43f6rr/vsBPXz7ChXm5yW6TNhUVBb+dmc6lTM5Q60NPWpp6Dn8eDBg6oWHatTW1CvDkAqGhUnbXz6gQL+pRUvHNzOpalu7svPcmjqTO2AASIyC/Dw9sep6Lf/4GZqU5dGkrEx99p8+rCfvup6ACUhhP7zsS7r+yq+orGSqMtwuzTtupu6+7kp96VMfS3RpgGUOh0N/vPG7+vrnP6XC/DxlZrh1+knz9egvf6Al8+ckujxEGT/P0t9QwLR67YYRi3y/dzHwcOtzAfEQtTWZFi+dqpcfq9XjqypVsXiynC5D1Tv9yi3IlNNlKK8gU+6MwUyrralXG9e8q89dOUdGmIXA36uvJ6i6PV2ae0qhDGPs8QAQKyVTC3Xr1V/TrVd/LdGlAIgSh8Ohi//lE7r4X7jkFekpO8uja792vq792vmJLgUxxs+z9Ha0gGnIUNB03jd/qvO+tZIZTUiIqMxkkqT5p/n0gX8uljvDod2vtWj/Wx2ae6pPZ3xuuoKBkAqHXSrXWH1QPQcD+vPPd+rX392sX393s7ra+vWPx2v1v7ftHrXtml1+mcGQyhd4o1UuAAAAAAApYayAaQgzmpBoUZvJZBiGliybpiXLpo14fN+2dkmSr+RIyFS+wKup008YMe6p3+zV8R8o0AkfKBy17artfmVmOVVyXG60ygUAAAAApLD+yYY23TD67ubDdc1yjDkmFWx4c7eeXnfsgGnI8BlNf3h8jb71lX+JU5VAFEOmo2mpH1yjafhMpswslzKzRu7a4TQ0Kdctr2/kD4DAgKma3R2atdArh5NL5QAAAAAA9nLaSfP10h9v0/RpU8Y1fnZZqVb/+qea5mPdUMRX3EImX2lkC3Y3VHXJ5TI060TeHAAAAAAAexpvwDSkZOroq4SAWIt5yNRc36NJXreyJh17VxesmB/28Rlz8nTh9SfGojQAAAAAAABESUQhU8lxOZKmKTPLOebYo4VHAAAAAAAASB8RhUylFbkqrWARbgAAAAAAAAxyJLoAAAAAAAAApD5CJgAAAAAAAFgW84W/AQAAAACIRFdNc0pvH7AbQiYAAAAAQFIp8ObK48nQ1hsfj/m+PJ4MFXhZcxiIBqOlpSuU6CIAAAAAABiurrFZrf7OmO+nwJur0iJfzPcD2AEhEwAAAAAAACxj4W8AAAAAAABYRsgEAAAAAAAAywiZAAAAAAAAYBkhEwAAAAAAACwjZAIAAAAAAIBlhEwAAAAAAACwjJAJAAAAAAAAlhEyAQAAAAAAwDJCJgAAAAAAAFhGyAQAAAAAAADLCJkAAAAAAABgGSETAAAAAAAALCNkAgAAAAAAgGWETAAAAAAAALCMkAkAAAAAAACWETIBAAAAAADAMkImAAAAAAAAWEbIBAAAAAAAAMsImQAAAAAAAGAZIRMAAAAAAAAsI2QCAAAAAACAZYRMAAAAAAAAsIyQCQAAAAAAAJb9f7qB26E9OBYgAAAAAElFTkSuQmCC", + "image/png": "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", "text/plain": [ "
" ] @@ -355,28 +272,18 @@ } ], "source": [ - "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"quantumspain\")" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 26, "id": "eaefdf76-af68-4187-996d-bdc9c33a4242", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 12, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -386,28 +293,18 @@ } ], "source": [ - "c.draw_mpl(scale = 0.8, cluster_gates = True, style=\"color-blind\")" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"color-blind\")" ] }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 27, "id": "56f4f3cc-6864-4ef2-aa19-9c209fc217e5", "metadata": {}, "outputs": [ { "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -425,7 +322,7 @@ "custom_style[\"fillcolor\"]=\"#ffb9b9\"\n", "custom_style[\"gatecolor\"]=\"#d8031c\"\n", "custom_style[\"controlcolor\"]=\"#360000\"\n", - "c.draw_mpl(scale = 0.8, cluster_gates = True, style=custom_style)" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=custom_style)" ] }, { @@ -454,25 +351,15 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 28, "id": "edacdee7-3f48-4a63-adb9-3c898d62fc9d", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "" - ] - }, - "execution_count": 15, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -480,12 +367,12 @@ } ], "source": [ - "c.draw_mpl()" + "ax, fig = plot(c)" ] }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 30, "id": "17bdbe2f-77c9-4b60-bd0e-ed7efdf20a17", "metadata": {}, "outputs": [ @@ -521,7 +408,7 @@ { "data": { "text/plain": [ - "" + "(,
)" ] }, "execution_count": 17, @@ -540,7 +427,7 @@ } ], "source": [ - "c.draw_mpl(cluster_gates = True)" + "plot(c, cluster_gates = True)" ] }, { @@ -574,7 +461,7 @@ { "data": { "text/plain": [ - "" + "(,
)" ] }, "execution_count": 19, @@ -583,7 +470,7 @@ }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -593,7 +480,7 @@ } ], "source": [ - "c.draw_mpl()" + "plot(c)" ] }, { @@ -626,7 +513,7 @@ { "data": { "text/plain": [ - "" + "(,
)" ] }, "execution_count": 21, @@ -645,7 +532,7 @@ } ], "source": [ - "c.draw_mpl()" + "plot(c)" ] }, { diff --git a/src/qibo/__init__.py b/src/qibo/__init__.py index 69d089610d..bcd912f1cc 100644 --- a/src/qibo/__init__.py +++ b/src/qibo/__init__.py @@ -32,5 +32,4 @@ set_batch_size, set_metropolis_threshold, ) -from qibo.imaging.mpldrawer import MPLDrawer from qibo.models.circuit import Circuit diff --git a/src/qibo/imaging/mpldrawer.py b/src/qibo/imaging/mpldrawer.py deleted file mode 100644 index a434d21021..0000000000 --- a/src/qibo/imaging/mpldrawer.py +++ /dev/null @@ -1,507 +0,0 @@ -# Some functions in MPLDrawer are from code provided by Rick Muller -# Simplified Plotting Routines for Quantum Circuits -# https://github.com/rpmuller/PlotQCircuit -# -import matplotlib -import numpy as np -from .plot_styles import _get_style - -class MPLDrawer: - def __init__(self): - pass - - global plot_params - plot_params = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - facecolor="w", - edgecolor="#000000", - fillcolor="#000000", - linecolor="k", - textcolor="k", - gatecolor="w", - controlcolor="#000000", - ) - - def _plot_quantum_schedule( - self, schedule, inits, labels=[], plot_labels=True, **kwargs - ): - """Use Matplotlib to plot a quantum circuit. - schedule List of time steps, each containing a sequence of gates during that step. - Each gate is a tuple containing (name,target,control1,control2...). - Targets and controls initially defined in terms of labels. - inits Initialization list of gates - labels List of qubit labels, optional - - kwargs Can override plot_parameters - """ - plot_params.update(kwargs) - scale = plot_params["scale"] - - # Create labels from gates. This will become slow if there are a lot - # of gates, in which case move to an ordered dictionary - if not labels: - labels = [] - for i, gate in self._enumerate_gates(schedule, schedule=True): - for label in gate[1:]: - if label not in labels: - labels.append(label) - - nq = len(labels) - nt = len(schedule) - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, nt * scale, scale, dtype=float) - - fig, ax = self._setup_figure(nq, nt, gate_grid, wire_grid, plot_params) - - measured = self._measured_wires(schedule, labels, schedule=True) - self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) - - if plot_labels: - self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - self._draw_gates( - ax, - schedule, - labels, - gate_grid, - wire_grid, - plot_params, - measured, - schedule=True, - ) - return ax - - def _plot_quantum_circuit( - self, gates, inits, labels=[], plot_labels=True, **kwargs - ): - """Use Matplotlib to plot a quantum circuit. - gates List of tuples for each gate in the quantum circuit. - (name,target,control1,control2...). Targets and controls initially - defined in terms of labels. - inits Initialization list of gates - labels List of qubit labels. optional - - kwargs Can override plot_parameters - """ - plot_params.update(kwargs) - scale = plot_params["scale"] - - # Create labels from gates. This will become slow if there are a lot - # of gates, in which case move to an ordered dictionary - if not labels: - labels = [] - for i, gate in self._enumerate_gates(gates): - for label in gate[1:]: - if label not in labels: - labels.append(label) - - nq = len(labels) - ng = len(gates) - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, ng * scale, scale, dtype=float) - - fig, ax = self._setup_figure(nq, ng, gate_grid, wire_grid, plot_params) - - measured = self._measured_wires(gates, labels) - self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) - - if plot_labels: - self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - self._draw_gates(ax, gates, labels, gate_grid, wire_grid, plot_params, measured) - return ax - - def _plot_lines_circuit(self, inits, labels, plot_labels=True, **kwargs): - """Use Matplotlib to plot a quantum circuit. - inits Initialization list of gates - labels List of qubit labels - - kwargs Can override plot_parameters - """ - - plot_params.update(kwargs) - scale = plot_params["scale"] - - nq = len(labels) - - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, nq * scale, scale, dtype=float) - - fig, ax = self._setup_figure(nq, nq, gate_grid, wire_grid, plot_params) - - self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params) - - if plot_labels: - self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - return ax - - def _enumerate_gates(self, l, schedule=False): - "Enumerate the gates in a way that can take l as either a list of gates or a schedule" - if schedule: - for i, gates in enumerate(l): - for gate in gates: - yield i, gate - else: - for i, gate in enumerate(l): - yield i, gate - - def _measured_wires(self, l, labels, schedule=False): - "measured[i] = j means wire i is measured at step j" - measured = {} - for i, gate in self._enumerate_gates(l, schedule=schedule): - name, target = gate[:2] - j = self._get_flipped_index(target, labels) - if name.startswith("M"): - measured[j] = i - return measured - - def _draw_gates( - self, - ax, - l, - labels, - gate_grid, - wire_grid, - plot_params, - measured={}, - schedule=False, - ): - for i, gate in self._enumerate_gates(l, schedule=schedule): - self._draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) - if len(gate) > 2: # Controlled - self._draw_controls( - ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured - ) - - def _draw_controls( - self, ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured={} - ): - linewidth = plot_params["linewidth"] - scale = plot_params["scale"] - control_radius = plot_params["control_radius"] - - name, target = gate[:2] - target_index = self._get_flipped_index(target, labels) - controls = gate[2:] - control_indices = self._get_flipped_indices(controls, labels) - gate_indices = control_indices + [target_index] - min_wire = min(gate_indices) - max_wire = max(gate_indices) - self._line( - ax, - gate_grid[i], - gate_grid[i], - wire_grid[min_wire], - wire_grid[max_wire], - plot_params, - ) - ismeasured = False - for index in control_indices: - if measured.get(index, 1000) < i: - ismeasured = True - if ismeasured: - dy = 0.04 # TODO: put in plot_params - self._line( - ax, - gate_grid[i] + dy, - gate_grid[i] + dy, - wire_grid[min_wire], - wire_grid[max_wire], - plot_params, - ) - - for ci in control_indices: - x = gate_grid[i] - y = wire_grid[ci] - if name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: - self._swapx(ax, x, y, plot_params) - else: - self._cdot(ax, x, y, plot_params) - - def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): - target_symbols = dict( - #CNOT="X", - CPHASE="Z", - NOP="", - CX="X", - CY="Y", - CZ="Z", - CCX="X", - DEUTSCH="DE", - UNITARY="U", - MEASURE="M", - SX=r"$\rm\sqrt{X}$", - CSX=r"$\rm\sqrt{X}$", - ) - name, target = gate[:2] - symbol = target_symbols.get(name, name) # override name with target_symbols - x = gate_grid[i] - target_index = self._get_flipped_index(target, labels) - y = wire_grid[target_index] - if not symbol: - return - if name in ["CNOT", "TOFFOLI"]: - self._oplus(ax, x, y, plot_params) - elif name in ["CPHASE"]: - self._cdot(ax, x, y, plot_params) - elif name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: - self._swapx(ax, x, y, plot_params) - else: - self._text(ax, x, y, symbol, plot_params, box=True) - - def _line(self, ax, x1, x2, y1, y2, plot_params): - Line2D = matplotlib.lines.Line2D - line = Line2D((x1, x2), (y1, y2), color=plot_params["linecolor"], lw=plot_params["linewidth"]) - ax.add_line(line) - - def _text(self, ax, x, y, textstr, plot_params, box=False): - linewidth = plot_params["linewidth"] - fontsize = plot_params["fontsize"] - if box: - bbox = dict(ec=plot_params["edgecolor"], fc=plot_params["gatecolor"], fill=True, lw=linewidth) - else: - bbox = dict(fill=False, lw=0) - ax.text( - x, y, textstr, color=plot_params["textcolor"], ha="center", va="center", bbox=bbox, size=fontsize - ) - - def _oplus(self, ax, x, y, plot_params): - Line2D = matplotlib.lines.Line2D - Circle = matplotlib.patches.Circle - not_radius = plot_params["not_radius"] - linewidth = plot_params["linewidth"] - c = Circle((x, y), not_radius, ec=plot_params["edgecolor"], fc=plot_params["gatecolor"], fill=True, lw=linewidth) - ax.add_patch(c) - self._line(ax, x, x, y - not_radius, y + not_radius, plot_params) - - def _cdot(self, ax, x, y, plot_params): - Circle = matplotlib.patches.Circle - control_radius = plot_params["control_radius"] - scale = plot_params["scale"] - linewidth = plot_params["linewidth"] - c = Circle( - (x, y), control_radius * scale, ec=plot_params["edgecolor"], fc=plot_params["controlcolor"], fill=True, lw=linewidth - ) - ax.add_patch(c) - - def _swapx(self, ax, x, y, plot_params): - d = plot_params["swap_delta"] - linewidth = plot_params["linewidth"] - self._line(ax, x - d, x + d, y - d, y + d, plot_params) - self._line(ax, x - d, x + d, y + d, y - d, plot_params) - - def _setup_figure(self, nq, ng, gate_grid, wire_grid, plot_params): - scale = plot_params["scale"] - fig = matplotlib.pyplot.figure( - figsize=(ng * scale, nq * scale), facecolor=plot_params["facecolor"], edgecolor=plot_params["edgecolor"] - ) - ax = fig.add_subplot(1, 1, 1, frameon=True) - ax.set_axis_off() - offset = 0.5 * scale - ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) - ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) - ax.set_aspect("equal") - return fig, ax - - def _draw_wires(self, ax, nq, gate_grid, wire_grid, plot_params, measured={}): - scale = plot_params["scale"] - linewidth = plot_params["linewidth"] - xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) - for i in range(nq): - self._line( - ax, - gate_grid[0] - scale, - gate_grid[-1] + scale, - wire_grid[i], - wire_grid[i], - plot_params, - ) - - # Add the doubling for measured wires: - dy = 0.04 # TODO: add to plot_params - for i in measured: - j = measured[i] - self._line( - ax, - gate_grid[j], - gate_grid[-1] + scale, - wire_grid[i] + dy, - wire_grid[i] + dy, - plot_params, - ) - - def _draw_labels(self, ax, labels, inits, gate_grid, wire_grid, plot_params): - scale = plot_params["scale"] - label_buffer = plot_params["label_buffer"] - fontsize = plot_params["fontsize"] - nq = len(labels) - xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) - for i in range(nq): - j = self._get_flipped_index(labels[i], labels) - self._text( - ax, - xdata[0] - label_buffer, - wire_grid[j], - self._render_label(labels[i], inits), - plot_params, - ) - - def _get_flipped_index(self, target, labels): - """Get qubit labels from the rest of the line,and return indices - - >>> _get_flipped_index('q0', ['q0', 'q1']) - 1 - >>> _get_flipped_index('q1', ['q0', 'q1']) - 0 - """ - nq = len(labels) - i = labels.index(target) - return nq - i - 1 - - def _get_flipped_indices(self, targets, labels): - return [self._get_flipped_index(t, labels) for t in targets] - - def _render_label(self, label, inits={}): - """Slightly more flexible way to render labels. - - >>> _render_label('q0') - '$|q0\\\\rangle$' - >>> _render_label('q0', {'q0':'0'}) - '$|0\\\\rangle$' - """ - if label in inits: - s = inits[label] - if s is None: - return "" - else: - return r"$|%s\rangle$" % inits[label] - return r"$|%s\rangle$" % label - - def _make_cluster_gates(self, gates_items): - cluster_gates = [] - temp_gates = [] - temp_mgates = [] - for i in list(range(len(gates_items))): - item = gates_items[i] - - if (len(item) == 2) and i > 0 and "MEASURE" not in item[0]: - if len(temp_gates) > 0 and item[1] == gates_items[i - 1][1]: - gates = [] - temp_gates.append(item) - elif "MEASURE" in item[0]: - temp_mgates.append(item) - else: - if len(temp_gates) != 0: - cluster_gates.append(temp_gates) - temp_gates = [] - - if len(temp_mgates) != 0: - cluster_gates.append(temp_mgates) - temp_mgates = [] - - if "MEASURE" not in item[0]: - cluster_gates.append([item]) - i = i + 1 - - if len(temp_gates) > 0: - cluster_gates.append(temp_gates) - - if len(temp_mgates) > 0: - cluster_gates.append(temp_mgates) - - temp_gates = [] - temp_mgates = [] - - return cluster_gates - - def _set_style(self,style): - - if style is None: - default_values = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - facecolor="w", - edgecolor="#000000", - fillcolor="#000000", - linecolor="k", - textcolor="k", - gatecolor="w", - controlcolor="#000000", - ) - - plot_params.update(default_values) - else: - if type(style) is str: - plot_params.update(_get_style(style)) - elif type(style) is dict: - plot_params.update(style) - - def plot_qibo_circuit(self, circuit, scale, cluster_gates, style): - - self._set_style(style) - - inits = list(range(circuit.nqubits)) - - labels = [] - for i in range(circuit.nqubits): - labels.append("q_" + str(i)) - - if len(circuit.queue) > 0: - gates_plot = [] - - for gate in circuit.queue: - init_label = gate.name.upper() - if "CCX" in init_label: - init_label = "TOFFOLI" - - if "CX" in init_label: - init_label = "CNOT" - - if len(gate._control_qubits) > 0 and "C" in init_label[0] and "CNOT" not in init_label: - init_label = init_label[1:] - - item = () - item += (init_label,) - - for qbit in gate._target_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - for qbit in gate._control_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - gates_plot.append(item) - - if cluster_gates: - gates_cluster = self._make_cluster_gates(gates_plot) - return self._plot_quantum_schedule( - gates_cluster, inits, labels, scale=scale - ) - - return self._plot_quantum_circuit(gates_plot, inits, labels, scale=scale) - else: - return self._plot_lines_circuit(inits, labels, scale=scale) - - @staticmethod - def save_fig(fig, path_file): - """Save matpltlib image to file - path_file Path to file with filename and extension - """ - return fig.savefig(path_file, bbox_inches="tight") diff --git a/src/qibo/imaging/plot_styles.py b/src/qibo/imaging/plot_styles.py deleted file mode 100644 index 50ba3924e0..0000000000 --- a/src/qibo/imaging/plot_styles.py +++ /dev/null @@ -1,45 +0,0 @@ -def _get_style(style_name): - - if 'garnacha' in style_name: - new_values = dict() - new_values["facecolor"]="#5e2129" - new_values["edgecolor"]="#FFFFFF" - new_values["linecolor"]="#FFFFFF" - new_values["textcolor"]="#FFFFFF" - new_values["fillcolor"]="#FFFFFF" - new_values["gatecolor"]="#5e2129" - new_values["controlcolor"]="#FFFFFF" - return new_values - - if 'fardelejo' in style_name: - new_values = dict() - new_values["facecolor"]="#e17a02" - new_values["edgecolor"]="#fef1e2" - new_values["linecolor"]="#fef1e2" - new_values["textcolor"]="#FFFFFF" - new_values["fillcolor"]="#fef1e2" - new_values["gatecolor"]="#8b4513" - new_values["controlcolor"]="#fef1e2" - return new_values - - if 'quantumspain' in style_name: - new_values = dict() - new_values["facecolor"]="#EDEDF4" - new_values["edgecolor"]="#092D4E" - new_values["linecolor"]="#092D4E" - new_values["textcolor"]="#8561C3" - new_values["fillcolor"]="#092D4E" - new_values["gatecolor"]="#53E7CA" - new_values["controlcolor"]="#092D4E" - return new_values - - if 'color-blind' in style_name: - new_values = dict() - new_values["facecolor"]="#d55e00" - new_values["edgecolor"]="#f0e442" - new_values["linecolor"]="#f0e442" - new_values["textcolor"]="#f0e442" - new_values["fillcolor"]="#cc79a7" - new_values["gatecolor"]="#d55e00" - new_values["controlcolor"]="#f0e442" - return new_values diff --git a/src/qibo/models/circuit.py b/src/qibo/models/circuit.py index 9b99189ca1..67ec3a670b 100644 --- a/src/qibo/models/circuit.py +++ b/src/qibo/models/circuit.py @@ -8,7 +8,6 @@ from qibo import gates from qibo.config import raise_error from qibo.gates.abstract import Gate -from qibo.imaging.mpldrawer import MPLDrawer from qibo.models._openqasm import QASMParser NoiseMapType = Union[Tuple[int, int, int], Dict[int, Tuple[int, int, int]]] @@ -1270,15 +1269,6 @@ def _update_draw_matrix(self, matrix, idx, gate, gate_symbol=None): return matrix, idx - def draw_mpl(self, scale=0.6, cluster_gates=True, style=None, save_file=None): - - ax = MPLDrawer().plot_qibo_circuit(self, scale, cluster_gates, style) - - if save_file: - MPLDrawer.save_fig(ax.figure, save_file) - - return ax - def draw(self, line_wrap=70, legend=False) -> str: """Draw text circuit using unicode symbols. diff --git a/src/qibo/ui/__init__.py b/src/qibo/ui/__init__.py new file mode 100644 index 0000000000..b092d102ed --- /dev/null +++ b/src/qibo/ui/__init__.py @@ -0,0 +1 @@ +from qibo.ui.mpldrawer import plot diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py new file mode 100644 index 0000000000..497f03ed8f --- /dev/null +++ b/src/qibo/ui/mpldrawer.py @@ -0,0 +1,536 @@ +# Some functions in MPLDrawer are from code provided by Rick Muller +# Simplified Plotting Routines for Quantum Circuits +# https://github.com/rpmuller/PlotQCircuit +# +import matplotlib +import numpy as np +from .plot_styles import _get_style + +plot_params = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + facecolor="w", + edgecolor="#000000", + fillcolor="#000000", + linecolor="k", + textcolor="k", + gatecolor="w", + controlcolor="#000000", +) + + +def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwargs): + """Use Matplotlib to plot a quantum circuit. + schedule List of time steps, each containing a sequence of gates during that step. + Each gate is a tuple containing (name,target,control1,control2...). + Targets and controls initially defined in terms of labels. + inits Initialization list of gates + labels List of qubit labels, optional + + kwargs Can override plot_parameters + """ + plot_params.update(kwargs) + scale = plot_params["scale"] + + # Create labels from gates. This will become slow if there are a lot + # of gates, in which case move to an ordered dictionary + if not labels: + labels = [] + for i, gate in _enumerate_gates(schedule, schedule=True): + for label in gate[1:]: + if label not in labels: + labels.append(label) + + nq = len(labels) + nt = len(schedule) + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) + gate_grid = np.arange(0.0, nt * scale, scale, dtype=float) + + fig, ax = _setup_figure(nq, nt, gate_grid, wire_grid, plot_params) + + measured = _measured_wires(schedule, labels, schedule=True) + _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) + + if plot_labels: + _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) + + _draw_gates( + ax, schedule, labels, gate_grid, wire_grid, plot_params, measured, schedule=True + ) + return ax + + +def _plot_quantum_circuit(gates, inits, labels=[], plot_labels=True, **kwargs): + """Use Matplotlib to plot a quantum circuit. + gates List of tuples for each gate in the quantum circuit. + (name,target,control1,control2...). Targets and controls initially + defined in terms of labels. + inits Initialization list of gates + labels List of qubit labels. optional + + kwargs Can override plot_parameters + """ + plot_params.update(kwargs) + scale = plot_params["scale"] + + # Create labels from gates. This will become slow if there are a lot + # of gates, in which case move to an ordered dictionary + if not labels: + labels = [] + for i, gate in _enumerate_gates(gates): + for label in gate[1:]: + if label not in labels: + labels.append(label) + + nq = len(labels) + ng = len(gates) + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) + gate_grid = np.arange(0.0, ng * scale, scale, dtype=float) + + fig, ax = _setup_figure(nq, ng, gate_grid, wire_grid, plot_params) + + measured = _measured_wires(gates, labels) + _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) + + if plot_labels: + _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) + + _draw_gates(ax, gates, labels, gate_grid, wire_grid, plot_params, measured) + return ax + + +def _plot_lines_circuit(inits, labels, plot_labels=True, **kwargs): + """Use Matplotlib to plot a quantum circuit. + inits Initialization list of gates + labels List of qubit labels + + kwargs Can override plot_parameters + """ + + plot_params.update(kwargs) + scale = plot_params["scale"] + + nq = len(labels) + + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) + gate_grid = np.arange(0.0, nq * scale, scale, dtype=float) + + fig, ax = _setup_figure(nq, nq, gate_grid, wire_grid, plot_params) + + _draw_wires(ax, nq, gate_grid, wire_grid, plot_params) + + if plot_labels: + _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) + + return ax + + +def _enumerate_gates(l, schedule=False): + "Enumerate the gates in a way that can take l as either a list of gates or a schedule" + if schedule: + for i, gates in enumerate(l): + for gate in gates: + yield i, gate + else: + for i, gate in enumerate(l): + yield i, gate + + +def _measured_wires(l, labels, schedule=False): + "measured[i] = j means wire i is measured at step j" + measured = {} + for i, gate in _enumerate_gates(l, schedule=schedule): + name, target = gate[:2] + j = _get_flipped_index(target, labels) + if name.startswith("M"): + measured[j] = i + return measured + + +def _draw_gates( + ax, l, labels, gate_grid, wire_grid, plot_params, measured={}, schedule=False +): + for i, gate in _enumerate_gates(l, schedule=schedule): + _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) + if len(gate) > 2: # Controlled + _draw_controls( + ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured + ) + + +def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured={}): + linewidth = plot_params["linewidth"] + scale = plot_params["scale"] + control_radius = plot_params["control_radius"] + + name, target = gate[:2] + target_index = _get_flipped_index(target, labels) + controls = gate[2:] + control_indices = _get_flipped_indices(controls, labels) + gate_indices = control_indices + [target_index] + min_wire = min(gate_indices) + max_wire = max(gate_indices) + _line( + ax, + gate_grid[i], + gate_grid[i], + wire_grid[min_wire], + wire_grid[max_wire], + plot_params, + ) + ismeasured = False + for index in control_indices: + if measured.get(index, 1000) < i: + ismeasured = True + if ismeasured: + dy = 0.04 # TODO: put in plot_params + _line( + ax, + gate_grid[i] + dy, + gate_grid[i] + dy, + wire_grid[min_wire], + wire_grid[max_wire], + plot_params, + ) + + for ci in control_indices: + x = gate_grid[i] + y = wire_grid[ci] + if name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: + _swapx(ax, x, y, plot_params) + else: + _cdot(ax, x, y, plot_params) + + +def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): + target_symbols = dict( + # CNOT="X", + CPHASE="Z", + NOP="", + CX="X", + CY="Y", + CZ="Z", + CCX="X", + DEUTSCH="DE", + UNITARY="U", + MEASURE="M", + SX=r"$\rm\sqrt{X}$", + CSX=r"$\rm\sqrt{X}$", + ) + name, target = gate[:2] + symbol = target_symbols.get(name, name) # override name with target_symbols + x = gate_grid[i] + target_index = _get_flipped_index(target, labels) + y = wire_grid[target_index] + if not symbol: + return + if name in ["CNOT", "TOFFOLI"]: + _oplus(ax, x, y, plot_params) + elif name in ["CPHASE"]: + _cdot(ax, x, y, plot_params) + elif name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: + _swapx(ax, x, y, plot_params) + else: + _text(ax, x, y, symbol, plot_params, box=True) + + +def _line(ax, x1, x2, y1, y2, plot_params): + Line2D = matplotlib.lines.Line2D + line = Line2D( + (x1, x2), (y1, y2), color=plot_params["linecolor"], lw=plot_params["linewidth"] + ) + ax.add_line(line) + + +def _text(ax, x, y, textstr, plot_params, box=False): + linewidth = plot_params["linewidth"] + fontsize = plot_params["fontsize"] + if box: + bbox = dict( + ec=plot_params["edgecolor"], + fc=plot_params["gatecolor"], + fill=True, + lw=linewidth, + ) + else: + bbox = dict(fill=False, lw=0) + ax.text( + x, + y, + textstr, + color=plot_params["textcolor"], + ha="center", + va="center", + bbox=bbox, + size=fontsize, + ) + + +def _oplus(ax, x, y, plot_params): + Line2D = matplotlib.lines.Line2D + Circle = matplotlib.patches.Circle + not_radius = plot_params["not_radius"] + linewidth = plot_params["linewidth"] + c = Circle( + (x, y), + not_radius, + ec=plot_params["edgecolor"], + fc=plot_params["gatecolor"], + fill=True, + lw=linewidth, + ) + ax.add_patch(c) + _line(ax, x, x, y - not_radius, y + not_radius, plot_params) + + +def _cdot(ax, x, y, plot_params): + Circle = matplotlib.patches.Circle + control_radius = plot_params["control_radius"] + scale = plot_params["scale"] + linewidth = plot_params["linewidth"] + c = Circle( + (x, y), + control_radius * scale, + ec=plot_params["edgecolor"], + fc=plot_params["controlcolor"], + fill=True, + lw=linewidth, + ) + ax.add_patch(c) + + +def _swapx(ax, x, y, plot_params): + d = plot_params["swap_delta"] + linewidth = plot_params["linewidth"] + _line(ax, x - d, x + d, y - d, y + d, plot_params) + _line(ax, x - d, x + d, y + d, y - d, plot_params) + + +def _setup_figure(nq, ng, gate_grid, wire_grid, plot_params): + scale = plot_params["scale"] + fig = matplotlib.pyplot.figure( + figsize=(ng * scale, nq * scale), + facecolor=plot_params["facecolor"], + edgecolor=plot_params["edgecolor"], + ) + ax = fig.add_subplot(1, 1, 1, frameon=True) + ax.set_axis_off() + offset = 0.5 * scale + ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) + ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) + ax.set_aspect("equal") + return fig, ax + + +def _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured={}): + scale = plot_params["scale"] + linewidth = plot_params["linewidth"] + xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) + for i in range(nq): + _line( + ax, + gate_grid[0] - scale, + gate_grid[-1] + scale, + wire_grid[i], + wire_grid[i], + plot_params, + ) + + # Add the doubling for measured wires: + #dy = 0.04 # TODO: add to plot_params + #for i in measured: + # j = measured[i] + # _line( + # ax, + # gate_grid[j], + # gate_grid[-1] + scale, + # wire_grid[i] + dy, + # wire_grid[i] + dy, + # plot_params, + # ) + + +def _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params): + scale = plot_params["scale"] + label_buffer = plot_params["label_buffer"] + fontsize = plot_params["fontsize"] + nq = len(labels) + xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) + for i in range(nq): + j = _get_flipped_index(labels[i], labels) + _text( + ax, + xdata[0] - label_buffer, + wire_grid[j], + _render_label(labels[i], inits), + plot_params, + ) + + +def _get_flipped_index(target, labels): + """Get qubit labels from the rest of the line,and return indices + + >>> _get_flipped_index('q0', ['q0', 'q1']) + 1 + >>> _get_flipped_index('q1', ['q0', 'q1']) + 0 + """ + nq = len(labels) + i = labels.index(target) + return nq - i - 1 + + +def _get_flipped_indices(targets, labels): + return [_get_flipped_index(t, labels) for t in targets] + + +def _render_label(label, inits={}): + """Slightly more flexible way to render labels. + + >>> _render_label('q0') + '$|q0\\\\rangle$' + >>> _render_label('q0', {'q0':'0'}) + '$|0\\\\rangle$' + """ + if label in inits: + s = inits[label] + if s is None: + return "" + else: + return r"$|%s\rangle$" % inits[label] + return r"$|%s\rangle$" % label + + +def _make_cluster_gates(gates_items): + cluster_gates = [] + temp_gates = [] + temp_mgates = [] + for i in list(range(len(gates_items))): + item = gates_items[i] + + if (len(item) == 2) and i > 0 and "MEASURE" not in item[0]: + if len(temp_gates) > 0 and item[1] == gates_items[i - 1][1]: + gates = [] + temp_gates.append(item) + elif "MEASURE" in item[0]: + temp_mgates.append(item) + else: + if len(temp_gates) != 0: + cluster_gates.append(temp_gates) + temp_gates = [] + + if len(temp_mgates) != 0: + cluster_gates.append(temp_mgates) + temp_mgates = [] + + if "MEASURE" not in item[0]: + cluster_gates.append([item]) + i = i + 1 + + if len(temp_gates) > 0: + cluster_gates.append(temp_gates) + + if len(temp_mgates) > 0: + cluster_gates.append(temp_mgates) + + temp_gates = [] + temp_mgates = [] + + return cluster_gates + + +def _set_style(style): + + if style is None: + default_values = dict( + scale=1.0, + fontsize=14.0, + linewidth=1.0, + control_radius=0.05, + not_radius=0.15, + swap_delta=0.08, + label_buffer=0.0, + facecolor="w", + edgecolor="#000000", + fillcolor="#000000", + linecolor="k", + textcolor="k", + gatecolor="w", + controlcolor="#000000", + ) + + plot_params.update(default_values) + else: + if type(style) is str: + plot_params.update(_get_style(style)) + elif type(style) is dict: + plot_params.update(style) + + +def _plot_qibo_circuit(circuit, scale, cluster_gates, style): + + _set_style(style) + + inits = list(range(circuit.nqubits)) + + labels = [] + for i in range(circuit.nqubits): + labels.append("q_" + str(i)) + + if len(circuit.queue) > 0: + gates_plot = [] + + for gate in circuit.queue: + init_label = gate.name.upper() + if "CCX" in init_label: + init_label = "TOFFOLI" + + if "CX" in init_label: + init_label = "CNOT" + + if ( + len(gate._control_qubits) > 0 + and "C" in init_label[0] + and "CNOT" not in init_label + ): + init_label = init_label[1:] + + item = () + item += (init_label,) + + for qbit in gate._target_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + for qbit in gate._control_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + gates_plot.append(item) + + if cluster_gates: + gates_cluster = _make_cluster_gates(gates_plot) + return _plot_quantum_schedule(gates_cluster, inits, labels, scale=scale) + + return _plot_quantum_circuit(gates_plot, inits, labels, scale=scale) + else: + return _plot_lines_circuit(inits, labels, scale=scale) + + +def plot(circuit, scale=0.6, cluster_gates=True, style=None, save_file=None): + + ax = _plot_qibo_circuit(circuit, scale, cluster_gates, style) + + if save_file: + ax.figure.savefig(save_file, bbox_inches="tight") + + return ax, ax.figure diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py new file mode 100644 index 0000000000..b0c3f93bca --- /dev/null +++ b/src/qibo/ui/plot_styles.py @@ -0,0 +1,45 @@ +def _get_style(style_name): + + if "garnacha" in style_name: + new_values = dict() + new_values["facecolor"] = "#5e2129" + new_values["edgecolor"] = "#FFFFFF" + new_values["linecolor"] = "#FFFFFF" + new_values["textcolor"] = "#FFFFFF" + new_values["fillcolor"] = "#FFFFFF" + new_values["gatecolor"] = "#5e2129" + new_values["controlcolor"] = "#FFFFFF" + return new_values + + if "fardelejo" in style_name: + new_values = dict() + new_values["facecolor"] = "#e17a02" + new_values["edgecolor"] = "#fef1e2" + new_values["linecolor"] = "#fef1e2" + new_values["textcolor"] = "#FFFFFF" + new_values["fillcolor"] = "#fef1e2" + new_values["gatecolor"] = "#8b4513" + new_values["controlcolor"] = "#fef1e2" + return new_values + + if "quantumspain" in style_name: + new_values = dict() + new_values["facecolor"] = "#EDEDF4" + new_values["edgecolor"] = "#092D4E" + new_values["linecolor"] = "#092D4E" + new_values["textcolor"] = "#8561C3" + new_values["fillcolor"] = "#092D4E" + new_values["gatecolor"] = "#53E7CA" + new_values["controlcolor"] = "#092D4E" + return new_values + + if "color-blind" in style_name: + new_values = dict() + new_values["facecolor"] = "#d55e00" + new_values["edgecolor"] = "#f0e442" + new_values["linecolor"] = "#f0e442" + new_values["textcolor"] = "#f0e442" + new_values["fillcolor"] = "#cc79a7" + new_values["gatecolor"] = "#d55e00" + new_values["controlcolor"] = "#f0e442" + return new_values From cfeb57214844aa054cc88dea5fc296db8f1a3b92 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 24 Jun 2024 08:56:57 +0000 Subject: [PATCH 038/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 497f03ed8f..5b46994a02 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -4,6 +4,7 @@ # import matplotlib import numpy as np + from .plot_styles import _get_style plot_params = dict( @@ -342,8 +343,8 @@ def _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured={}): ) # Add the doubling for measured wires: - #dy = 0.04 # TODO: add to plot_params - #for i in measured: + # dy = 0.04 # TODO: add to plot_params + # for i in measured: # j = measured[i] # _line( # ax, From 2d724b0ba687e55c4d8b69c5298ccb88b62d9721 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 12:19:56 +0200 Subject: [PATCH 039/116] removed unused imaging folder --- src/qibo/imaging/mpldrawer.py | 544 -------------------------------- src/qibo/imaging/plot_styles.py | 45 --- 2 files changed, 589 deletions(-) delete mode 100644 src/qibo/imaging/mpldrawer.py delete mode 100644 src/qibo/imaging/plot_styles.py diff --git a/src/qibo/imaging/mpldrawer.py b/src/qibo/imaging/mpldrawer.py deleted file mode 100644 index 709408aae8..0000000000 --- a/src/qibo/imaging/mpldrawer.py +++ /dev/null @@ -1,544 +0,0 @@ -# Some functions in MPLDrawer are from code provided by Rick Muller -# Simplified Plotting Routines for Quantum Circuits -# https://github.com/rpmuller/PlotQCircuit -# -import matplotlib -import numpy as np - -from .plot_styles import _get_style - - -class MPLDrawer: - def __init__(self): - pass - - global plot_params - plot_params = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - facecolor="w", - edgecolor="#000000", - fillcolor="#000000", - linecolor="k", - textcolor="k", - gatecolor="w", - controlcolor="#000000", - ) - - def _plot_quantum_schedule( - self, schedule, inits, labels=[], plot_labels=True, **kwargs - ): - """Use Matplotlib to plot a quantum circuit. - schedule List of time steps, each containing a sequence of gates during that step. - Each gate is a tuple containing (name,target,control1,control2...). - Targets and controls initially defined in terms of labels. - inits Initialization list of gates - labels List of qubit labels, optional - - kwargs Can override plot_parameters - """ - plot_params.update(kwargs) - scale = plot_params["scale"] - - # Create labels from gates. This will become slow if there are a lot - # of gates, in which case move to an ordered dictionary - if not labels: - labels = [] - for i, gate in self._enumerate_gates(schedule, schedule=True): - for label in gate[1:]: - if label not in labels: - labels.append(label) - - nq = len(labels) - nt = len(schedule) - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, nt * scale, scale, dtype=float) - - fig, ax = self._setup_figure(nq, nt, gate_grid, wire_grid, plot_params) - - measured = self._measured_wires(schedule, labels, schedule=True) - self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) - - if plot_labels: - self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - self._draw_gates( - ax, - schedule, - labels, - gate_grid, - wire_grid, - plot_params, - measured, - schedule=True, - ) - return ax - - def _plot_quantum_circuit( - self, gates, inits, labels=[], plot_labels=True, **kwargs - ): - """Use Matplotlib to plot a quantum circuit. - gates List of tuples for each gate in the quantum circuit. - (name,target,control1,control2...). Targets and controls initially - defined in terms of labels. - inits Initialization list of gates - labels List of qubit labels. optional - - kwargs Can override plot_parameters - """ - plot_params.update(kwargs) - scale = plot_params["scale"] - - # Create labels from gates. This will become slow if there are a lot - # of gates, in which case move to an ordered dictionary - if not labels: - labels = [] - for i, gate in self._enumerate_gates(gates): - for label in gate[1:]: - if label not in labels: - labels.append(label) - - nq = len(labels) - ng = len(gates) - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, ng * scale, scale, dtype=float) - - fig, ax = self._setup_figure(nq, ng, gate_grid, wire_grid, plot_params) - - measured = self._measured_wires(gates, labels) - self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) - - if plot_labels: - self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - self._draw_gates(ax, gates, labels, gate_grid, wire_grid, plot_params, measured) - return ax - - def _plot_lines_circuit(self, inits, labels, plot_labels=True, **kwargs): - """Use Matplotlib to plot a quantum circuit. - inits Initialization list of gates - labels List of qubit labels - - kwargs Can override plot_parameters - """ - - plot_params.update(kwargs) - scale = plot_params["scale"] - - nq = len(labels) - - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, nq * scale, scale, dtype=float) - - fig, ax = self._setup_figure(nq, nq, gate_grid, wire_grid, plot_params) - - self._draw_wires(ax, nq, gate_grid, wire_grid, plot_params) - - if plot_labels: - self._draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - return ax - - def _enumerate_gates(self, l, schedule=False): - "Enumerate the gates in a way that can take l as either a list of gates or a schedule" - if schedule: - for i, gates in enumerate(l): - for gate in gates: - yield i, gate - else: - for i, gate in enumerate(l): - yield i, gate - - def _measured_wires(self, l, labels, schedule=False): - "measured[i] = j means wire i is measured at step j" - measured = {} - for i, gate in self._enumerate_gates(l, schedule=schedule): - name, target = gate[:2] - j = self._get_flipped_index(target, labels) - if name.startswith("M"): - measured[j] = i - return measured - - def _draw_gates( - self, - ax, - l, - labels, - gate_grid, - wire_grid, - plot_params, - measured={}, - schedule=False, - ): - for i, gate in self._enumerate_gates(l, schedule=schedule): - self._draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) - if len(gate) > 2: # Controlled - self._draw_controls( - ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured - ) - - def _draw_controls( - self, ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured={} - ): - linewidth = plot_params["linewidth"] - scale = plot_params["scale"] - control_radius = plot_params["control_radius"] - - name, target = gate[:2] - target_index = self._get_flipped_index(target, labels) - controls = gate[2:] - control_indices = self._get_flipped_indices(controls, labels) - gate_indices = control_indices + [target_index] - min_wire = min(gate_indices) - max_wire = max(gate_indices) - self._line( - ax, - gate_grid[i], - gate_grid[i], - wire_grid[min_wire], - wire_grid[max_wire], - plot_params, - ) - ismeasured = False - for index in control_indices: - if measured.get(index, 1000) < i: - ismeasured = True - if ismeasured: - dy = 0.04 # TODO: put in plot_params - self._line( - ax, - gate_grid[i] + dy, - gate_grid[i] + dy, - wire_grid[min_wire], - wire_grid[max_wire], - plot_params, - ) - - for ci in control_indices: - x = gate_grid[i] - y = wire_grid[ci] - if name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: - self._swapx(ax, x, y, plot_params) - else: - self._cdot(ax, x, y, plot_params) - - def _draw_target(self, ax, i, gate, labels, gate_grid, wire_grid, plot_params): - target_symbols = dict( - # CNOT="X", - CPHASE="Z", - NOP="", - CX="X", - CY="Y", - CZ="Z", - CCX="X", - DEUTSCH="DE", - UNITARY="U", - MEASURE="M", - SX=r"$\rm\sqrt{X}$", - CSX=r"$\rm\sqrt{X}$", - ) - name, target = gate[:2] - symbol = target_symbols.get(name, name) # override name with target_symbols - x = gate_grid[i] - target_index = self._get_flipped_index(target, labels) - y = wire_grid[target_index] - if not symbol: - return - if name in ["CNOT", "TOFFOLI"]: - self._oplus(ax, x, y, plot_params) - elif name in ["CPHASE"]: - self._cdot(ax, x, y, plot_params) - elif name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: - self._swapx(ax, x, y, plot_params) - else: - self._text(ax, x, y, symbol, plot_params, box=True) - - def _line(self, ax, x1, x2, y1, y2, plot_params): - Line2D = matplotlib.lines.Line2D - line = Line2D( - (x1, x2), - (y1, y2), - color=plot_params["linecolor"], - lw=plot_params["linewidth"], - ) - ax.add_line(line) - - def _text(self, ax, x, y, textstr, plot_params, box=False): - linewidth = plot_params["linewidth"] - fontsize = plot_params["fontsize"] - if box: - bbox = dict( - ec=plot_params["edgecolor"], - fc=plot_params["gatecolor"], - fill=True, - lw=linewidth, - ) - else: - bbox = dict(fill=False, lw=0) - ax.text( - x, - y, - textstr, - color=plot_params["textcolor"], - ha="center", - va="center", - bbox=bbox, - size=fontsize, - ) - - def _oplus(self, ax, x, y, plot_params): - Line2D = matplotlib.lines.Line2D - Circle = matplotlib.patches.Circle - not_radius = plot_params["not_radius"] - linewidth = plot_params["linewidth"] - c = Circle( - (x, y), - not_radius, - ec=plot_params["edgecolor"], - fc=plot_params["gatecolor"], - fill=True, - lw=linewidth, - ) - ax.add_patch(c) - self._line(ax, x, x, y - not_radius, y + not_radius, plot_params) - - def _cdot(self, ax, x, y, plot_params): - Circle = matplotlib.patches.Circle - control_radius = plot_params["control_radius"] - scale = plot_params["scale"] - linewidth = plot_params["linewidth"] - c = Circle( - (x, y), - control_radius * scale, - ec=plot_params["edgecolor"], - fc=plot_params["controlcolor"], - fill=True, - lw=linewidth, - ) - ax.add_patch(c) - - def _swapx(self, ax, x, y, plot_params): - d = plot_params["swap_delta"] - linewidth = plot_params["linewidth"] - self._line(ax, x - d, x + d, y - d, y + d, plot_params) - self._line(ax, x - d, x + d, y + d, y - d, plot_params) - - def _setup_figure(self, nq, ng, gate_grid, wire_grid, plot_params): - scale = plot_params["scale"] - fig = matplotlib.pyplot.figure( - figsize=(ng * scale, nq * scale), - facecolor=plot_params["facecolor"], - edgecolor=plot_params["edgecolor"], - ) - ax = fig.add_subplot(1, 1, 1, frameon=True) - ax.set_axis_off() - offset = 0.5 * scale - ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) - ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) - ax.set_aspect("equal") - return fig, ax - - def _draw_wires(self, ax, nq, gate_grid, wire_grid, plot_params, measured={}): - scale = plot_params["scale"] - linewidth = plot_params["linewidth"] - xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) - for i in range(nq): - self._line( - ax, - gate_grid[0] - scale, - gate_grid[-1] + scale, - wire_grid[i], - wire_grid[i], - plot_params, - ) - - # Add the doubling for measured wires: - dy = 0.04 # TODO: add to plot_params - for i in measured: - j = measured[i] - self._line( - ax, - gate_grid[j], - gate_grid[-1] + scale, - wire_grid[i] + dy, - wire_grid[i] + dy, - plot_params, - ) - - def _draw_labels(self, ax, labels, inits, gate_grid, wire_grid, plot_params): - scale = plot_params["scale"] - label_buffer = plot_params["label_buffer"] - fontsize = plot_params["fontsize"] - nq = len(labels) - xdata = (gate_grid[0] - scale, gate_grid[-1] + scale) - for i in range(nq): - j = self._get_flipped_index(labels[i], labels) - self._text( - ax, - xdata[0] - label_buffer, - wire_grid[j], - self._render_label(labels[i], inits), - plot_params, - ) - - def _get_flipped_index(self, target, labels): - """Get qubit labels from the rest of the line,and return indices - - >>> _get_flipped_index('q0', ['q0', 'q1']) - 1 - >>> _get_flipped_index('q1', ['q0', 'q1']) - 0 - """ - nq = len(labels) - i = labels.index(target) - return nq - i - 1 - - def _get_flipped_indices(self, targets, labels): - return [self._get_flipped_index(t, labels) for t in targets] - - def _render_label(self, label, inits={}): - """Slightly more flexible way to render labels. - - >>> _render_label('q0') - '$|q0\\\\rangle$' - >>> _render_label('q0', {'q0':'0'}) - '$|0\\\\rangle$' - """ - if label in inits: - s = inits[label] - if s is None: - return "" - else: - return r"$|%s\rangle$" % inits[label] - return r"$|%s\rangle$" % label - - def _make_cluster_gates(self, gates_items): - cluster_gates = [] - temp_gates = [] - temp_mgates = [] - for i in list(range(len(gates_items))): - item = gates_items[i] - - if (len(item) == 2) and i > 0 and "MEASURE" not in item[0]: - if len(temp_gates) > 0 and item[1] == gates_items[i - 1][1]: - gates = [] - temp_gates.append(item) - elif "MEASURE" in item[0]: - temp_mgates.append(item) - else: - if len(temp_gates) != 0: - cluster_gates.append(temp_gates) - temp_gates = [] - - if len(temp_mgates) != 0: - cluster_gates.append(temp_mgates) - temp_mgates = [] - - if "MEASURE" not in item[0]: - cluster_gates.append([item]) - i = i + 1 - - if len(temp_gates) > 0: - cluster_gates.append(temp_gates) - - if len(temp_mgates) > 0: - cluster_gates.append(temp_mgates) - - temp_gates = [] - temp_mgates = [] - - return cluster_gates - - def _set_style(self, style): - - if style is None: - default_values = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - facecolor="w", - edgecolor="#000000", - fillcolor="#000000", - linecolor="k", - textcolor="k", - gatecolor="w", - controlcolor="#000000", - ) - - plot_params.update(default_values) - else: - if type(style) is str: - plot_params.update(_get_style(style)) - elif type(style) is dict: - plot_params.update(style) - - def plot_qibo_circuit(self, circuit, scale, cluster_gates, style): - - self._set_style(style) - - inits = list(range(circuit.nqubits)) - - labels = [] - for i in range(circuit.nqubits): - labels.append("q_" + str(i)) - - if len(circuit.queue) > 0: - gates_plot = [] - - for gate in circuit.queue: - init_label = gate.name.upper() - if "CCX" in init_label: - init_label = "TOFFOLI" - - if "CX" in init_label: - init_label = "CNOT" - - if ( - len(gate._control_qubits) > 0 - and "C" in init_label[0] - and "CNOT" not in init_label - ): - init_label = init_label[1:] - - item = () - item += (init_label,) - - for qbit in gate._target_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - for qbit in gate._control_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - gates_plot.append(item) - - if cluster_gates: - gates_cluster = self._make_cluster_gates(gates_plot) - return self._plot_quantum_schedule( - gates_cluster, inits, labels, scale=scale - ) - - return self._plot_quantum_circuit(gates_plot, inits, labels, scale=scale) - else: - return self._plot_lines_circuit(inits, labels, scale=scale) - - @staticmethod - def save_fig(fig, path_file): - """Save matpltlib image to file - path_file Path to file with filename and extension - """ - return fig.savefig(path_file, bbox_inches="tight") diff --git a/src/qibo/imaging/plot_styles.py b/src/qibo/imaging/plot_styles.py deleted file mode 100644 index b0c3f93bca..0000000000 --- a/src/qibo/imaging/plot_styles.py +++ /dev/null @@ -1,45 +0,0 @@ -def _get_style(style_name): - - if "garnacha" in style_name: - new_values = dict() - new_values["facecolor"] = "#5e2129" - new_values["edgecolor"] = "#FFFFFF" - new_values["linecolor"] = "#FFFFFF" - new_values["textcolor"] = "#FFFFFF" - new_values["fillcolor"] = "#FFFFFF" - new_values["gatecolor"] = "#5e2129" - new_values["controlcolor"] = "#FFFFFF" - return new_values - - if "fardelejo" in style_name: - new_values = dict() - new_values["facecolor"] = "#e17a02" - new_values["edgecolor"] = "#fef1e2" - new_values["linecolor"] = "#fef1e2" - new_values["textcolor"] = "#FFFFFF" - new_values["fillcolor"] = "#fef1e2" - new_values["gatecolor"] = "#8b4513" - new_values["controlcolor"] = "#fef1e2" - return new_values - - if "quantumspain" in style_name: - new_values = dict() - new_values["facecolor"] = "#EDEDF4" - new_values["edgecolor"] = "#092D4E" - new_values["linecolor"] = "#092D4E" - new_values["textcolor"] = "#8561C3" - new_values["fillcolor"] = "#092D4E" - new_values["gatecolor"] = "#53E7CA" - new_values["controlcolor"] = "#092D4E" - return new_values - - if "color-blind" in style_name: - new_values = dict() - new_values["facecolor"] = "#d55e00" - new_values["edgecolor"] = "#f0e442" - new_values["linecolor"] = "#f0e442" - new_values["textcolor"] = "#f0e442" - new_values["fillcolor"] = "#cc79a7" - new_values["gatecolor"] = "#d55e00" - new_values["controlcolor"] = "#f0e442" - return new_values From 7fbabcce4fa5cf8ffaffd748e366895f08eab684 Mon Sep 17 00:00:00 2001 From: Sergio Date: Mon, 24 Jun 2024 12:47:39 +0200 Subject: [PATCH 040/116] Update src/qibo/ui/plot_styles.py Thanks! I will apply this to all other styles Co-authored-by: Alessandro Candido --- src/qibo/ui/plot_styles.py | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-) diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py index b0c3f93bca..5dff2cf040 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/plot_styles.py @@ -1,15 +1,15 @@ def _get_style(style_name): if "garnacha" in style_name: - new_values = dict() - new_values["facecolor"] = "#5e2129" - new_values["edgecolor"] = "#FFFFFF" - new_values["linecolor"] = "#FFFFFF" - new_values["textcolor"] = "#FFFFFF" - new_values["fillcolor"] = "#FFFFFF" - new_values["gatecolor"] = "#5e2129" - new_values["controlcolor"] = "#FFFFFF" - return new_values + return { + "facecolor": "#5e2129", + "edgecolor": "#ffffff", + "linecolor": "#ffffff", + "textcolor": "#ffffff", + "fillcolor": "#ffffff", + "gatecolor": "#5e2129", + "controlcolor": "#ffffff", + } if "fardelejo" in style_name: new_values = dict() From 6b07d4894f6ade7d409bb1c4d349dde9ba3f6129 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 12:57:15 +0200 Subject: [PATCH 041/116] rework styles dictionary and return default style --- src/qibo/ui/plot_styles.py | 64 ++++++++++++++++++++++---------------- 1 file changed, 37 insertions(+), 27 deletions(-) diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py index 5dff2cf040..858b8cbeee 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/plot_styles.py @@ -12,34 +12,44 @@ def _get_style(style_name): } if "fardelejo" in style_name: - new_values = dict() - new_values["facecolor"] = "#e17a02" - new_values["edgecolor"] = "#fef1e2" - new_values["linecolor"] = "#fef1e2" - new_values["textcolor"] = "#FFFFFF" - new_values["fillcolor"] = "#fef1e2" - new_values["gatecolor"] = "#8b4513" - new_values["controlcolor"] = "#fef1e2" - return new_values + return { + "facecolor": "#e17a02", + "edgecolor": "#fef1e2", + "linecolor": "#fef1e2", + "textcolor": "#FFFFFF", + "fillcolor": "#fef1e2", + "gatecolor": "#8b4513", + "controlcolor": "#fef1e2", + } if "quantumspain" in style_name: - new_values = dict() - new_values["facecolor"] = "#EDEDF4" - new_values["edgecolor"] = "#092D4E" - new_values["linecolor"] = "#092D4E" - new_values["textcolor"] = "#8561C3" - new_values["fillcolor"] = "#092D4E" - new_values["gatecolor"] = "#53E7CA" - new_values["controlcolor"] = "#092D4E" - return new_values + return { + "facecolor": "#EDEDF4", + "edgecolor": "#092D4E", + "linecolor": "#092D4E", + "textcolor": "#8561C3", + "fillcolor": "#092D4E", + "gatecolor": "#53E7CA", + "controlcolor": "#092D4E", + } if "color-blind" in style_name: - new_values = dict() - new_values["facecolor"] = "#d55e00" - new_values["edgecolor"] = "#f0e442" - new_values["linecolor"] = "#f0e442" - new_values["textcolor"] = "#f0e442" - new_values["fillcolor"] = "#cc79a7" - new_values["gatecolor"] = "#d55e00" - new_values["controlcolor"] = "#f0e442" - return new_values + return { + "facecolor": "#d55e00", + "edgecolor": "#f0e442", + "linecolor": "#f0e442", + "textcolor": "#f0e442", + "fillcolor": "#cc79a7", + "gatecolor": "#d55e00", + "controlcolor": "#f0e442", + } + + return { + "facecolor": "w", + "edgecolor": "#000000", + "linecolor": "k", + "textcolor": "k", + "fillcolor": "#000000", + "gatecolor": "w", + "controlcolor": "#000000", + } From 93943ce21314b3c1a0c505f70508650edb380690 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 13:07:17 +0200 Subject: [PATCH 042/116] deleted save plot to file --- src/qibo/ui/mpldrawer.py | 21 +++++++-------------- 1 file changed, 7 insertions(+), 14 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 5b46994a02..ef99613488 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -473,7 +473,7 @@ def _set_style(style): plot_params.update(style) -def _plot_qibo_circuit(circuit, scale, cluster_gates, style): +def plot(circuit, scale=0.6, cluster_gates=True, style=None, save_file=None): _set_style(style) @@ -520,18 +520,11 @@ def _plot_qibo_circuit(circuit, scale, cluster_gates, style): if cluster_gates: gates_cluster = _make_cluster_gates(gates_plot) - return _plot_quantum_schedule(gates_cluster, inits, labels, scale=scale) + ax = _plot_quantum_schedule(gates_cluster, inits, labels, scale=scale) + return ax, ax.figure - return _plot_quantum_circuit(gates_plot, inits, labels, scale=scale) + ax = _plot_quantum_circuit(gates_plot, inits, labels, scale=scale) + return ax, ax.figure else: - return _plot_lines_circuit(inits, labels, scale=scale) - - -def plot(circuit, scale=0.6, cluster_gates=True, style=None, save_file=None): - - ax = _plot_qibo_circuit(circuit, scale, cluster_gates, style) - - if save_file: - ax.figure.savefig(save_file, bbox_inches="tight") - - return ax, ax.figure + ax = _plot_lines_circuit(inits, labels, scale=scale) + return ax, ax.figure From 2ed13be66c1ce260326bf118c9066c1d309ce9f0 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 13:31:49 +0200 Subject: [PATCH 043/116] added documentation on plot function --- src/qibo/ui/mpldrawer.py | 12 ++++++++++-- 1 file changed, 10 insertions(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index ef99613488..1243928b3a 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -473,8 +473,16 @@ def _set_style(style): plot_params.update(style) -def plot(circuit, scale=0.6, cluster_gates=True, style=None, save_file=None): - +def plot(circuit, scale=0.6, cluster_gates=True, style=None): + """Main matplotlib plot function for Qibo circuit + circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) + scale Scale the ouput plot + cluster_gates Group single-qubit gates + style Style applied to the circuit (built-in styles: garnacha, fardelejo, quantumspain, color-blind) + + ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) + fig A Figure object (type: matplotlib.figure.Figure) + """ _set_style(style) inits = list(range(circuit.nqubits)) From fcf73bebeabe331f08b40160c50e3a364a06cbbb Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 13:53:42 +0200 Subject: [PATCH 044/116] added one last built-in style in red and black --- src/qibo/ui/mpldrawer.py | 2 +- src/qibo/ui/plot_styles.py | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 1243928b3a..b22f017b6b 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -478,7 +478,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) scale Scale the ouput plot cluster_gates Group single-qubit gates - style Style applied to the circuit (built-in styles: garnacha, fardelejo, quantumspain, color-blind) + style Style applied to the circuit (built-in styles: garnacha, fardelejo, quantumspain, color-blind and cachirulo) ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) fig A Figure object (type: matplotlib.figure.Figure) diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py index 858b8cbeee..b61270eb0f 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/plot_styles.py @@ -44,6 +44,17 @@ def _get_style(style_name): "controlcolor": "#f0e442", } + if "cachirulo" in style_name: + return { + "facecolor":"#ffffff", + "edgecolor":"#800000", + "linecolor":"#800000", + "textcolor":"#000000", + "fillcolor":"#ffffff", + "gatecolor":"#ffffff", + "controlcolor":"#800000", + } + return { "facecolor": "w", "edgecolor": "#000000", From 0d3ce920d035ac41af6c30add14288949edfe3eb Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 24 Jun 2024 11:54:28 +0000 Subject: [PATCH 045/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/plot_styles.py | 14 +++++++------- 1 file changed, 7 insertions(+), 7 deletions(-) diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py index b61270eb0f..9c4a33fbf0 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/plot_styles.py @@ -46,13 +46,13 @@ def _get_style(style_name): if "cachirulo" in style_name: return { - "facecolor":"#ffffff", - "edgecolor":"#800000", - "linecolor":"#800000", - "textcolor":"#000000", - "fillcolor":"#ffffff", - "gatecolor":"#ffffff", - "controlcolor":"#800000", + "facecolor": "#ffffff", + "edgecolor": "#800000", + "linecolor": "#800000", + "textcolor": "#000000", + "fillcolor": "#ffffff", + "gatecolor": "#ffffff", + "controlcolor": "#800000", } return { From ff1a8e25238afa6721fe76d98978b782be0bd7bc Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 14:06:20 +0200 Subject: [PATCH 046/116] converted style dictionary to constant --- src/qibo/ui/mpldrawer.py | 4 +- src/qibo/ui/plot_styles.py | 108 +++++++++++++++++-------------------- 2 files changed, 51 insertions(+), 61 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index b22f017b6b..fdd052d38a 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -5,7 +5,7 @@ import matplotlib import numpy as np -from .plot_styles import _get_style +from .plot_styles import STYLE plot_params = dict( scale=1.0, @@ -483,7 +483,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) fig A Figure object (type: matplotlib.figure.Figure) """ - _set_style(style) + _set_style(STYLE[style] if style in list(STYLE.keys()) else STYLE["default"]) inits = list(range(circuit.nqubits)) diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py index b61270eb0f..552c32fabf 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/plot_styles.py @@ -1,61 +1,50 @@ -def _get_style(style_name): - - if "garnacha" in style_name: - return { - "facecolor": "#5e2129", - "edgecolor": "#ffffff", - "linecolor": "#ffffff", - "textcolor": "#ffffff", - "fillcolor": "#ffffff", - "gatecolor": "#5e2129", - "controlcolor": "#ffffff", - } - - if "fardelejo" in style_name: - return { - "facecolor": "#e17a02", - "edgecolor": "#fef1e2", - "linecolor": "#fef1e2", - "textcolor": "#FFFFFF", - "fillcolor": "#fef1e2", - "gatecolor": "#8b4513", - "controlcolor": "#fef1e2", - } - - if "quantumspain" in style_name: - return { - "facecolor": "#EDEDF4", - "edgecolor": "#092D4E", - "linecolor": "#092D4E", - "textcolor": "#8561C3", - "fillcolor": "#092D4E", - "gatecolor": "#53E7CA", - "controlcolor": "#092D4E", - } - - if "color-blind" in style_name: - return { - "facecolor": "#d55e00", - "edgecolor": "#f0e442", - "linecolor": "#f0e442", - "textcolor": "#f0e442", - "fillcolor": "#cc79a7", - "gatecolor": "#d55e00", - "controlcolor": "#f0e442", - } - - if "cachirulo" in style_name: - return { - "facecolor":"#ffffff", - "edgecolor":"#800000", - "linecolor":"#800000", - "textcolor":"#000000", - "fillcolor":"#ffffff", - "gatecolor":"#ffffff", - "controlcolor":"#800000", - } - - return { +STYLE = { + "garnacha": { + "facecolor": "#5e2129", + "edgecolor": "#ffffff", + "linecolor": "#ffffff", + "textcolor": "#ffffff", + "fillcolor": "#ffffff", + "gatecolor": "#5e2129", + "controlcolor": "#ffffff", + }, + "fardelejo": { + "facecolor": "#e17a02", + "edgecolor": "#fef1e2", + "linecolor": "#fef1e2", + "textcolor": "#FFFFFF", + "fillcolor": "#fef1e2", + "gatecolor": "#8b4513", + "controlcolor": "#fef1e2", + }, + "quantumspain": { + "facecolor": "#EDEDF4", + "edgecolor": "#092D4E", + "linecolor": "#092D4E", + "textcolor": "#8561C3", + "fillcolor": "#092D4E", + "gatecolor": "#53E7CA", + "controlcolor": "#092D4E", + }, + "color-blind": { + "facecolor": "#d55e00", + "edgecolor": "#f0e442", + "linecolor": "#f0e442", + "textcolor": "#f0e442", + "fillcolor": "#cc79a7", + "gatecolor": "#d55e00", + "controlcolor": "#f0e442", + }, + "cachirulo": { + "facecolor": "#ffffff", + "edgecolor": "#800000", + "linecolor": "#800000", + "textcolor": "#000000", + "fillcolor": "#ffffff", + "gatecolor": "#ffffff", + "controlcolor": "#800000", + }, + "default": { "facecolor": "w", "edgecolor": "#000000", "linecolor": "k", @@ -63,4 +52,5 @@ def _get_style(style_name): "fillcolor": "#000000", "gatecolor": "w", "controlcolor": "#000000", - } + }, +} From 96c47edd040e51c7ab6cb1b8483d7b9dae92dc28 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 14:08:44 +0200 Subject: [PATCH 047/116] fixed merge confict --- src/qibo/ui/plot_styles.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/plot_styles.py index ea7fcf277c..552c32fabf 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/plot_styles.py @@ -1,4 +1,3 @@ -<<<<<<< HEAD STYLE = { "garnacha": { "facecolor": "#5e2129", From 14ebac495ea107bd30763c30d61e6badf796f810 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 24 Jun 2024 14:29:30 +0200 Subject: [PATCH 048/116] review set_style function --- src/qibo/ui/mpldrawer.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index fdd052d38a..53c849b032 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -483,8 +483,14 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) fig A Figure object (type: matplotlib.figure.Figure) """ - _set_style(STYLE[style] if style in list(STYLE.keys()) else STYLE["default"]) - + if style is not None: + if type(style) is dict: + _set_style(style) + else: + _set_style(STYLE[style] if style in list(STYLE.keys()) else STYLE["default"]) + else: + _set_style(STYLE["default"]) + inits = list(range(circuit.nqubits)) labels = [] From 9b1e1f7f4736395d6ee570868a74860a309dce9d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 24 Jun 2024 12:30:53 +0000 Subject: [PATCH 049/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 6 ++++-- 1 file changed, 4 insertions(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 53c849b032..8956bd7c4f 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -487,10 +487,12 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): if type(style) is dict: _set_style(style) else: - _set_style(STYLE[style] if style in list(STYLE.keys()) else STYLE["default"]) + _set_style( + STYLE[style] if style in list(STYLE.keys()) else STYLE["default"] + ) else: _set_style(STYLE["default"]) - + inits = list(range(circuit.nqubits)) labels = [] From 974fbdfea71920c32eee339a879a60ee65dffaa4 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Tue, 25 Jun 2024 09:15:30 +0200 Subject: [PATCH 050/116] redraw symbols in matplotlib for complex gates --- src/qibo/ui/mpldrawer.py | 63 ++++++++++++++++++++++++++++------------ 1 file changed, 45 insertions(+), 18 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 8956bd7c4f..1fdda86ff9 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -24,6 +24,26 @@ controlcolor="#000000", ) +symbols = dict( + NOP="", + CPHASE="Z", + ID="I", + CX="X", + CY="Y", + CZ="Z", + FSIM="F", + SYC="SYC", + GENERALIZEDFSIM="GF", + DEUTSCH="DE", + UNITARY="U", + MEASURE="M", + ISWAP="I", + SISWAP="SI", + FSWAP="FX", + SX=r"$\rm\sqrt{X}$", + CSX=r"$\rm\sqrt{X}$", +) + def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwargs): """Use Matplotlib to plot a quantum circuit. @@ -202,29 +222,34 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu for ci in control_indices: x = gate_grid[i] y = wire_grid[ci] - if name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: + if name in ["SWAP"]: _swapx(ax, x, y, plot_params) + elif name in [ + "ISWAP", + "SISWAP", + "FSWAP", + "FSIM", + "SYC", + "GENERALIZEDFSIM", + "RXX", + "RYY", + "RZZ", + "RZX", + "RXXYY", + "G", + "RBS", + "ECR", + "MS", + ]: + symbol = symbols.get(name, name) + _text(ax, x, y, symbol, plot_params, box=True) else: _cdot(ax, x, y, plot_params) def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): - target_symbols = dict( - # CNOT="X", - CPHASE="Z", - NOP="", - CX="X", - CY="Y", - CZ="Z", - CCX="X", - DEUTSCH="DE", - UNITARY="U", - MEASURE="M", - SX=r"$\rm\sqrt{X}$", - CSX=r"$\rm\sqrt{X}$", - ) name, target = gate[:2] - symbol = target_symbols.get(name, name) # override name with target_symbols + symbol = symbols.get(name, name) # override name with symbols x = gate_grid[i] target_index = _get_flipped_index(target, labels) y = wire_grid[target_index] @@ -234,9 +259,11 @@ def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): _oplus(ax, x, y, plot_params) elif name in ["CPHASE"]: _cdot(ax, x, y, plot_params) - elif name in ["SWAP", "ISWAP", "SISWAP", "FSWAP"]: + elif name in ["SWAP"]: _swapx(ax, x, y, plot_params) else: + if name == "ALIGN": + symbol = "A({0})".format(target[2:]) _text(ax, x, y, symbol, plot_params, box=True) @@ -481,7 +508,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): style Style applied to the circuit (built-in styles: garnacha, fardelejo, quantumspain, color-blind and cachirulo) ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) - fig A Figure object (type: matplotlib.figure.Figure) + ax.figure A Figure object (type: matplotlib.figure.Figure) """ if style is not None: if type(style) is dict: From 8fd7e0f985e61b33cc16b7172cb96c4cb6ea502f Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 25 Jun 2024 07:16:12 +0000 Subject: [PATCH 051/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 1fdda86ff9..b008e4ebda 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -263,7 +263,7 @@ def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): _swapx(ax, x, y, plot_params) else: if name == "ALIGN": - symbol = "A({0})".format(target[2:]) + symbol = "A({})".format(target[2:]) _text(ax, x, y, symbol, plot_params, box=True) From 7b966561bb55cbda215413be7bded8147229788c Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Tue, 25 Jun 2024 10:13:23 +0200 Subject: [PATCH 052/116] deleted _set_style function for code reduction --- src/qibo/ui/mpldrawer.py | 42 +++++++--------------------------------- 1 file changed, 7 insertions(+), 35 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index b008e4ebda..395a848548 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -72,7 +72,7 @@ def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwarg wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) gate_grid = np.arange(0.0, nt * scale, scale, dtype=float) - fig, ax = _setup_figure(nq, nt, gate_grid, wire_grid, plot_params) + ax, _ = _setup_figure(nq, nt, gate_grid, wire_grid, plot_params) measured = _measured_wires(schedule, labels, schedule=True) _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) @@ -113,7 +113,7 @@ def _plot_quantum_circuit(gates, inits, labels=[], plot_labels=True, **kwargs): wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) gate_grid = np.arange(0.0, ng * scale, scale, dtype=float) - fig, ax = _setup_figure(nq, ng, gate_grid, wire_grid, plot_params) + ax, _ = _setup_figure(nq, ng, gate_grid, wire_grid, plot_params) measured = _measured_wires(gates, labels) _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) @@ -141,7 +141,7 @@ def _plot_lines_circuit(inits, labels, plot_labels=True, **kwargs): wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) gate_grid = np.arange(0.0, nq * scale, scale, dtype=float) - fig, ax = _setup_figure(nq, nq, gate_grid, wire_grid, plot_params) + ax, _ = _setup_figure(nq, nq, gate_grid, wire_grid, plot_params) _draw_wires(ax, nq, gate_grid, wire_grid, plot_params) @@ -352,7 +352,7 @@ def _setup_figure(nq, ng, gate_grid, wire_grid, plot_params): ax.set_xlim(gate_grid[0] - offset, gate_grid[-1] + offset) ax.set_ylim(wire_grid[0] - offset, wire_grid[-1] + offset) ax.set_aspect("equal") - return fig, ax + return ax, fig def _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured={}): @@ -472,34 +472,6 @@ def _make_cluster_gates(gates_items): return cluster_gates -def _set_style(style): - - if style is None: - default_values = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - facecolor="w", - edgecolor="#000000", - fillcolor="#000000", - linecolor="k", - textcolor="k", - gatecolor="w", - controlcolor="#000000", - ) - - plot_params.update(default_values) - else: - if type(style) is str: - plot_params.update(_get_style(style)) - elif type(style) is dict: - plot_params.update(style) - - def plot(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) @@ -512,13 +484,13 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): """ if style is not None: if type(style) is dict: - _set_style(style) + plot_params.update(style) else: - _set_style( + plot_params.update( STYLE[style] if style in list(STYLE.keys()) else STYLE["default"] ) else: - _set_style(STYLE["default"]) + plot_params.update(STYLE["default"]) inits = list(range(circuit.nqubits)) From 5cbdbc7abd101fe7ce5a98f83ad506092790fd3f Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Tue, 25 Jun 2024 12:44:48 +0200 Subject: [PATCH 053/116] rework clustering method to make it simple --- src/qibo/ui/mpldrawer.py | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 395a848548..e2a4321ac2 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -435,20 +435,27 @@ def _render_label(label, inits={}): def _make_cluster_gates(gates_items): - cluster_gates = [] + temp_gates = [] temp_mgates = [] - for i in list(range(len(gates_items))): - item = gates_items[i] - - if (len(item) == 2) and i > 0 and "MEASURE" not in item[0]: - if len(temp_gates) > 0 and item[1] == gates_items[i - 1][1]: - gates = [] - temp_gates.append(item) - elif "MEASURE" in item[0]: - temp_mgates.append(item) + cluster_gates = [] + + for item in gates_items: + if len(item) == 2: # single qubit gates + if "MEASURE" in item[0]: + temp_mgates.append(item) + else: + if len(temp_gates) > 0: + if item[1] in [tup[1] for tup in temp_gates]: + cluster_gates.append(temp_gates) + temp_gates = [] + temp_gates.append(item) + else: + temp_gates.append(item) + else: + temp_gates.append(item) else: - if len(temp_gates) != 0: + if len(temp_gates) > 0: cluster_gates.append(temp_gates) temp_gates = [] @@ -456,9 +463,7 @@ def _make_cluster_gates(gates_items): cluster_gates.append(temp_mgates) temp_mgates = [] - if "MEASURE" not in item[0]: - cluster_gates.append([item]) - i = i + 1 + cluster_gates.append([item]) if len(temp_gates) > 0: cluster_gates.append(temp_gates) From 0a5a78452e0d38f142b03a036450ebf78450fd82 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Tue, 25 Jun 2024 14:54:34 +0200 Subject: [PATCH 054/116] draw invaric input form I and M gates --- src/qibo/ui/mpldrawer.py | 32 +++++++++++++++++++------------- 1 file changed, 19 insertions(+), 13 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index e2a4321ac2..9ac85cdd61 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -521,22 +521,28 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ): init_label = init_label[1:] - item = () - item += (init_label,) - - for qbit in gate._target_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: + if init_label in ["ID", "MEASURE"]: + for qbit in gate._target_qubits: + item = (init_label,) item += ("q_" + str(qbit),) + gates_plot.append(item) + else: + item = () + item += (init_label,) - for qbit in gate._control_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) + for qbit in gate._target_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + for qbit in gate._control_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) - gates_plot.append(item) + gates_plot.append(item) if cluster_gates: gates_cluster = _make_cluster_gates(gates_plot) From 2a83750713041f5c0f8450ac9e139a0a204a43ec Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 25 Jun 2024 12:56:04 +0000 Subject: [PATCH 055/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 9ac85cdd61..9b0c1998dd 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -532,7 +532,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): for qbit in gate._target_qubits: if qbit is tuple: - item += ("q_" + str(qbit[0]),) + item += ("q_" + str(qbit[0]),) else: item += ("q_" + str(qbit),) From 7525fcd2994ee9311e962f783b0cd2b8b4f94814 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 26 Jun 2024 08:53:21 +0200 Subject: [PATCH 056/116] added noise and channels to plot --- src/qibo/ui/mpldrawer.py | 73 ++++++++++++++++++---------------------- src/qibo/ui/symbols.py | 29 ++++++++++++++++ 2 files changed, 62 insertions(+), 40 deletions(-) create mode 100644 src/qibo/ui/symbols.py diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 9b0c1998dd..777f3f73b8 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -6,43 +6,24 @@ import numpy as np from .plot_styles import STYLE - -plot_params = dict( - scale=1.0, - fontsize=14.0, - linewidth=1.0, - control_radius=0.05, - not_radius=0.15, - swap_delta=0.08, - label_buffer=0.0, - facecolor="w", - edgecolor="#000000", - fillcolor="#000000", - linecolor="k", - textcolor="k", - gatecolor="w", - controlcolor="#000000", -) - -symbols = dict( - NOP="", - CPHASE="Z", - ID="I", - CX="X", - CY="Y", - CZ="Z", - FSIM="F", - SYC="SYC", - GENERALIZEDFSIM="GF", - DEUTSCH="DE", - UNITARY="U", - MEASURE="M", - ISWAP="I", - SISWAP="SI", - FSWAP="FX", - SX=r"$\rm\sqrt{X}$", - CSX=r"$\rm\sqrt{X}$", -) +from .symbols import SYMBOLS + +plot_params = { + "scale": 1.0, + "fontsize": 14.0, + "linewidth": 1.0, + "control_radius": 0.05, + "not_radius": 0.15, + "swap_delta": 0.08, + "label_buffer": 0.0, + "facecolor": "w", + "edgecolor": "#000000", + "fillcolor": "#000000", + "linecolor": "k", + "textcolor": "k", + "gatecolor": "w", + "controlcolor": "#000000", +} def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwargs): @@ -241,7 +222,7 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu "ECR", "MS", ]: - symbol = symbols.get(name, name) + symbol = SYMBOLS.get(name, name) _text(ax, x, y, symbol, plot_params, box=True) else: _cdot(ax, x, y, plot_params) @@ -249,7 +230,7 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): name, target = gate[:2] - symbol = symbols.get(name, name) # override name with symbols + symbol = SYMBOLS.get(name, name) # override name with symbols x = gate_grid[i] target_index = _get_flipped_index(target, labels) y = wire_grid[target_index] @@ -521,11 +502,23 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ): init_label = init_label[1:] - if init_label in ["ID", "MEASURE"]: + if init_label in [ + "ID", + "MEASURE", + "KRAUSCHANNEL", + "UNITARYCHANNEL", + "DEPOLARIZINGCHANNEL", + "READOUTERRORCHANNEL", + ]: for qbit in gate._target_qubits: item = (init_label,) item += ("q_" + str(qbit),) gates_plot.append(item) + elif init_label in "ENTANGLEMENTENTROPY": + for qbit in list(range(circuit.nqubits)): + item = (init_label,) + item += ("q_" + str(qbit),) + gates_plot.append(item) else: item = () item += (init_label,) diff --git a/src/qibo/ui/symbols.py b/src/qibo/ui/symbols.py new file mode 100644 index 0000000000..c366e8cf15 --- /dev/null +++ b/src/qibo/ui/symbols.py @@ -0,0 +1,29 @@ +SYMBOLS = { + "NOP": "", + "CPHASE": "Z", + "ID": "I", + "CX": "X", + "CY": "Y", + "CZ": "Z", + "FSIM": "F", + "SYC": "SYC", + "GENERALIZEDFSIM": "GF", + "DEUTSCH": "DE", + "UNITARY": "U", + "MEASURE": "M", + "ISWAP": "I", + "SISWAP": "SI", + "FSWAP": "FX", + "SX": r"$\rm\sqrt{X}$", + "CSX": r"$\rm\sqrt{X}$", + "KRAUSCHANNEL": "K", + "UNITARYCHANNEL": "U", + "PAULINOISECHANNEL": "PN", + "DEPOLARIZINGCHANNEL": "D", + "THERMALRELAXATIONCHANNEL": "TR", + "AMPLITUDEDAMPINGCHANNEL": "AD", + "PHASEDAMPINGCHANNEL": "PD", + "READOUTERRORCHANNEL": "RE", + "RESETCHANNEL": "R", + "ENTANGLEMENTENTROPY": "EE", +} From c83c4302a924762c880840a443e93c241bf72a5b Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 26 Jun 2024 13:34:00 +0200 Subject: [PATCH 057/116] added json files for styles and symbols --- src/qibo/ui/default.mplstyle | 8 ++++++ src/qibo/ui/mpldrawer.py | 30 +++++++++++++++++++-- src/qibo/ui/{plot_styles.py => styles.json} | 2 +- src/qibo/ui/{symbols.py => symbols.json} | 4 +-- 4 files changed, 38 insertions(+), 6 deletions(-) create mode 100644 src/qibo/ui/default.mplstyle rename src/qibo/ui/{plot_styles.py => styles.json} (95%) rename src/qibo/ui/{symbols.py => symbols.json} (85%) diff --git a/src/qibo/ui/default.mplstyle b/src/qibo/ui/default.mplstyle new file mode 100644 index 0000000000..9e9cb40584 --- /dev/null +++ b/src/qibo/ui/default.mplstyle @@ -0,0 +1,8 @@ +axes.facecolor: w +axes.edgecolor: "#000000" +lines.linecolor: k +text.textcolor: k +text.fillcolor: "#000000" +circle.fc: w +circle.controlcolor: "#000000" +circle.ec: "#000000" diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 777f3f73b8..c7276033a6 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -4,9 +4,14 @@ # import matplotlib import numpy as np +import json +from os import path -from .plot_styles import STYLE -from .symbols import SYMBOLS +global STYLE +STYLE = {} + +global SYMBOLS +SYMBOLS = {} plot_params = { "scale": 1.0, @@ -458,6 +463,13 @@ def _make_cluster_gates(gates_items): return cluster_gates +def _build_path(filename): + file_path = path.abspath(__file__) # full path of current file + dir_path = path.dirname(file_path) # full path of the directory from file + final_path = path.join(dir_path, filename) # absolute file path of given file + return final_path + + def plot(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) @@ -468,6 +480,17 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) ax.figure A Figure object (type: matplotlib.figure.Figure) """ + + json_file = _build_path("symbols.json") + + with open(json_file) as file: + SYMBOLS.update(json.load(file)) + + json_file = _build_path("styles.json") + + with open(json_file) as file: + STYLE.update(json.load(file)) + if style is not None: if type(style) is dict: plot_params.update(style) @@ -495,6 +518,9 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): if "CX" in init_label: init_label = "CNOT" + if init_label in ["SX", "CSX"]: + init_label = r"$\rm\sqrt{X}$" + if ( len(gate._control_qubits) > 0 and "C" in init_label[0] diff --git a/src/qibo/ui/plot_styles.py b/src/qibo/ui/styles.json similarity index 95% rename from src/qibo/ui/plot_styles.py rename to src/qibo/ui/styles.json index 552c32fabf..6e9baa319d 100644 --- a/src/qibo/ui/plot_styles.py +++ b/src/qibo/ui/styles.json @@ -1,4 +1,4 @@ -STYLE = { +{ "garnacha": { "facecolor": "#5e2129", "edgecolor": "#ffffff", diff --git a/src/qibo/ui/symbols.py b/src/qibo/ui/symbols.json similarity index 85% rename from src/qibo/ui/symbols.py rename to src/qibo/ui/symbols.json index c366e8cf15..d49c4034aa 100644 --- a/src/qibo/ui/symbols.py +++ b/src/qibo/ui/symbols.json @@ -1,4 +1,4 @@ -SYMBOLS = { +{ "NOP": "", "CPHASE": "Z", "ID": "I", @@ -14,8 +14,6 @@ "ISWAP": "I", "SISWAP": "SI", "FSWAP": "FX", - "SX": r"$\rm\sqrt{X}$", - "CSX": r"$\rm\sqrt{X}$", "KRAUSCHANNEL": "K", "UNITARYCHANNEL": "U", "PAULINOISECHANNEL": "PN", From 3209b4bc08989e3efb14710fefc41beee261746a Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 26 Jun 2024 11:34:49 +0000 Subject: [PATCH 058/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index c7276033a6..49d213d2e5 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -2,11 +2,12 @@ # Simplified Plotting Routines for Quantum Circuits # https://github.com/rpmuller/PlotQCircuit # -import matplotlib -import numpy as np import json from os import path +import matplotlib +import numpy as np + global STYLE STYLE = {} From b91ea54ff4fe21604bdf9463bb9637b03e4e96a3 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 26 Jun 2024 14:32:04 +0200 Subject: [PATCH 059/116] added fix due to black breaks json files --- src/qibo/ui/styles.json | 12 ++++++------ src/qibo/ui/symbols.json | 2 +- 2 files changed, 7 insertions(+), 7 deletions(-) diff --git a/src/qibo/ui/styles.json b/src/qibo/ui/styles.json index 6e9baa319d..508864e2dc 100644 --- a/src/qibo/ui/styles.json +++ b/src/qibo/ui/styles.json @@ -6,7 +6,7 @@ "textcolor": "#ffffff", "fillcolor": "#ffffff", "gatecolor": "#5e2129", - "controlcolor": "#ffffff", + "controlcolor": "#ffffff" }, "fardelejo": { "facecolor": "#e17a02", @@ -15,7 +15,7 @@ "textcolor": "#FFFFFF", "fillcolor": "#fef1e2", "gatecolor": "#8b4513", - "controlcolor": "#fef1e2", + "controlcolor": "#fef1e2" }, "quantumspain": { "facecolor": "#EDEDF4", @@ -24,7 +24,7 @@ "textcolor": "#8561C3", "fillcolor": "#092D4E", "gatecolor": "#53E7CA", - "controlcolor": "#092D4E", + "controlcolor": "#092D4E" }, "color-blind": { "facecolor": "#d55e00", @@ -33,7 +33,7 @@ "textcolor": "#f0e442", "fillcolor": "#cc79a7", "gatecolor": "#d55e00", - "controlcolor": "#f0e442", + "controlcolor": "#f0e442" }, "cachirulo": { "facecolor": "#ffffff", @@ -42,7 +42,7 @@ "textcolor": "#000000", "fillcolor": "#ffffff", "gatecolor": "#ffffff", - "controlcolor": "#800000", + "controlcolor": "#800000" }, "default": { "facecolor": "w", @@ -51,6 +51,6 @@ "textcolor": "k", "fillcolor": "#000000", "gatecolor": "w", - "controlcolor": "#000000", + "controlcolor": "#000000" }, } diff --git a/src/qibo/ui/symbols.json b/src/qibo/ui/symbols.json index d49c4034aa..10d9c443d3 100644 --- a/src/qibo/ui/symbols.json +++ b/src/qibo/ui/symbols.json @@ -23,5 +23,5 @@ "PHASEDAMPINGCHANNEL": "PD", "READOUTERRORCHANNEL": "RE", "RESETCHANNEL": "R", - "ENTANGLEMENTENTROPY": "EE", + "ENTANGLEMENTENTROPY": "EE" } From 7922b4a7f3793f76014dcb5dbcf8380c74a15b5b Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 26 Jun 2024 14:41:40 +0200 Subject: [PATCH 060/116] fix json for styles --- src/qibo/ui/styles.json | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/ui/styles.json b/src/qibo/ui/styles.json index 508864e2dc..24a3d4578d 100644 --- a/src/qibo/ui/styles.json +++ b/src/qibo/ui/styles.json @@ -52,5 +52,5 @@ "fillcolor": "#000000", "gatecolor": "w", "controlcolor": "#000000" - }, + } } From 703ee945cba122fad6252da1eb245f0c429ec489 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 26 Jun 2024 14:49:25 +0200 Subject: [PATCH 061/116] deleted mplstyle file --- src/qibo/ui/default.mplstyle | 8 -------- 1 file changed, 8 deletions(-) delete mode 100644 src/qibo/ui/default.mplstyle diff --git a/src/qibo/ui/default.mplstyle b/src/qibo/ui/default.mplstyle deleted file mode 100644 index 9e9cb40584..0000000000 --- a/src/qibo/ui/default.mplstyle +++ /dev/null @@ -1,8 +0,0 @@ -axes.facecolor: w -axes.edgecolor: "#000000" -lines.linecolor: k -text.textcolor: k -text.fillcolor: "#000000" -circle.fc: w -circle.controlcolor: "#000000" -circle.ec: "#000000" From ca5a9cc4eb05ba191fced8cfc3bb11f8d0f24252 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 27 Jun 2024 19:16:13 +0200 Subject: [PATCH 062/116] added support to plot fused gates --- src/qibo/ui/mpldrawer.py | 29 +++++++++++++++++++++++------ src/qibo/ui/symbols.json | 4 +++- 2 files changed, 26 insertions(+), 7 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 49d213d2e5..5c3fa0b1ee 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -4,9 +4,9 @@ # import json from os import path - import matplotlib import numpy as np +from qibo import gates global STYLE STYLE = {} @@ -446,7 +446,7 @@ def _make_cluster_gates(gates_items): cluster_gates.append(temp_gates) temp_gates = [] - if len(temp_mgates) != 0: + if len(temp_mgates) > 0: cluster_gates.append(temp_mgates) temp_mgates = [] @@ -509,16 +509,33 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): labels.append("q_" + str(i)) if len(circuit.queue) > 0: - gates_plot = [] + all_gates = [] for gate in circuit.queue: + if isinstance(gate, gates.FusedGate): + all_gates += gate.gates + else: + all_gates.append(gate) + + gates_plot = [] + + for gate in all_gates: init_label = gate.name.upper() - if "CCX" in init_label: + if init_label == "CCX": init_label = "TOFFOLI" - if "CX" in init_label: + if init_label == "CX": init_label = "CNOT" + if init_label == "Y": + init_label = "GATEY" + + if init_label == "CY": + init_label = "GATECY" + + if init_label == "RY": + init_label = "GATERY" + if init_label in ["SX", "CSX"]: init_label = r"$\rm\sqrt{X}$" @@ -527,7 +544,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): and "C" in init_label[0] and "CNOT" not in init_label ): - init_label = init_label[1:] + init_label = gate.draw_label.upper() if init_label in [ "ID", diff --git a/src/qibo/ui/symbols.json b/src/qibo/ui/symbols.json index 10d9c443d3..70bbe4bf6c 100644 --- a/src/qibo/ui/symbols.json +++ b/src/qibo/ui/symbols.json @@ -3,10 +3,12 @@ "CPHASE": "Z", "ID": "I", "CX": "X", - "CY": "Y", "CZ": "Z", "FSIM": "F", "SYC": "SYC", + "GATEY": "Y", + "GATECY": "Y", + "GATERY": "RY", "GENERALIZEDFSIM": "GF", "DEUTSCH": "DE", "UNITARY": "U", From 607e05bd177a4fbf6240460c0e6937b767ead7ff Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 27 Jun 2024 17:16:56 +0000 Subject: [PATCH 063/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 5c3fa0b1ee..e38478cfb5 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -4,8 +4,10 @@ # import json from os import path + import matplotlib import numpy as np + from qibo import gates global STYLE From a58550c24e04fb354fc28f5a8c2974a384129109 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 1 Jul 2024 08:26:57 +0200 Subject: [PATCH 064/116] review for gate plotting enhancement --- src/qibo/ui/mpldrawer.py | 19 +++++-------------- src/qibo/ui/symbols.json | 3 --- 2 files changed, 5 insertions(+), 17 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index e38478cfb5..0d642c695d 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -211,7 +211,7 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu for ci in control_indices: x = gate_grid[i] y = wire_grid[ci] - if name in ["SWAP"]: + if name == "SWAP": _swapx(ax, x, y, plot_params) elif name in [ "ISWAP", @@ -246,9 +246,9 @@ def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): return if name in ["CNOT", "TOFFOLI"]: _oplus(ax, x, y, plot_params) - elif name in ["CPHASE"]: + elif name == "CPHASE": _cdot(ax, x, y, plot_params) - elif name in ["SWAP"]: + elif name == "SWAP": _swapx(ax, x, y, plot_params) else: if name == "ALIGN": @@ -431,7 +431,7 @@ def _make_cluster_gates(gates_items): for item in gates_items: if len(item) == 2: # single qubit gates - if "MEASURE" in item[0]: + if item[0] == "MEASURE": temp_mgates.append(item) else: if len(temp_gates) > 0: @@ -529,15 +529,6 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): if init_label == "CX": init_label = "CNOT" - if init_label == "Y": - init_label = "GATEY" - - if init_label == "CY": - init_label = "GATECY" - - if init_label == "RY": - init_label = "GATERY" - if init_label in ["SX", "CSX"]: init_label = r"$\rm\sqrt{X}$" @@ -560,7 +551,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): item = (init_label,) item += ("q_" + str(qbit),) gates_plot.append(item) - elif init_label in "ENTANGLEMENTENTROPY": + elif init_label == "ENTANGLEMENTENTROPY": for qbit in list(range(circuit.nqubits)): item = (init_label,) item += ("q_" + str(qbit),) diff --git a/src/qibo/ui/symbols.json b/src/qibo/ui/symbols.json index 70bbe4bf6c..8d455bfcbb 100644 --- a/src/qibo/ui/symbols.json +++ b/src/qibo/ui/symbols.json @@ -6,9 +6,6 @@ "CZ": "Z", "FSIM": "F", "SYC": "SYC", - "GATEY": "Y", - "GATECY": "Y", - "GATERY": "RY", "GENERALIZEDFSIM": "GF", "DEUTSCH": "DE", "UNITARY": "U", From 7b2ea6a77455e38bfdafc06db698f1a2c3960ed4 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Mon, 1 Jul 2024 12:17:11 +0200 Subject: [PATCH 065/116] added support for dagger operator in gate plot --- src/qibo/ui/mpldrawer.py | 36 ++++++++++++++++++++++++++++++++++-- 1 file changed, 34 insertions(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 0d642c695d..3bd4a60add 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -211,6 +211,12 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu for ci in control_indices: x = gate_grid[i] y = wire_grid[ci] + + is_dagger = False + if name[-2:] == "DG": + name = name.replace("DG", "") + is_dagger = True + if name == "SWAP": _swapx(ax, x, y, plot_params) elif name in [ @@ -230,7 +236,12 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu "ECR", "MS", ]: + symbol = SYMBOLS.get(name, name) + + if is_dagger: + symbol += r"$\rm{^{\dagger}}$" + _text(ax, x, y, symbol, plot_params, box=True) else: _cdot(ax, x, y, plot_params) @@ -238,7 +249,17 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): name, target = gate[:2] + + is_dagger = False + if name[-2:] == "DG": + name = name.replace("DG", "") + is_dagger = True + symbol = SYMBOLS.get(name, name) # override name with symbols + + if is_dagger: + symbol += r"$\rm{^{\dagger}}$" + x = gate_grid[i] target_index = _get_flipped_index(target, labels) y = wire_grid[target_index] @@ -473,6 +494,13 @@ def _build_path(filename): return final_path +def _check_list_str(list, str): + for item in list: + if item in str: + return True + return False + + def plot(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) @@ -523,14 +551,18 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): for gate in all_gates: init_label = gate.name.upper() + if init_label == "CCX": init_label = "TOFFOLI" if init_label == "CX": init_label = "CNOT" - if init_label in ["SX", "CSX"]: - init_label = r"$\rm\sqrt{X}$" + if _check_list_str(["SX", "CSX"], init_label): + is_dagger = init_label[-2:] == "DG" + init_label = ( + r"$\rm{\sqrt{X}}^{\dagger}$" if is_dagger else r"$\rm{\sqrt{X}}$" + ) if ( len(gate._control_qubits) > 0 From 880b66ff8c3aafd7574157e593385d83a4d8a016 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Tue, 2 Jul 2024 12:24:04 +0200 Subject: [PATCH 066/116] review gate size on plot --- src/qibo/ui/mpldrawer.py | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 3bd4a60add..82da829b2f 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -287,7 +287,12 @@ def _line(ax, x1, x2, y1, y2, plot_params): def _text(ax, x, y, textstr, plot_params, box=False): linewidth = plot_params["linewidth"] - fontsize = plot_params["fontsize"] + fontsize = ( + 12.0 + if _check_list_str(["dagger", "sqrt"], textstr) + else plot_params["fontsize"] + ) + if box: bbox = dict( ec=plot_params["edgecolor"], From 9d6e7738666130900a9312df205978f41c8580c5 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 4 Jul 2024 14:12:51 +0200 Subject: [PATCH 067/116] added support for framing clutered gates --- src/qibo/ui/FusedGateBarrier.py | 32 ++++ src/qibo/ui/mpldrawer.py | 309 +++++++++++++++++++++----------- 2 files changed, 235 insertions(+), 106 deletions(-) create mode 100644 src/qibo/ui/FusedGateBarrier.py diff --git a/src/qibo/ui/FusedGateBarrier.py b/src/qibo/ui/FusedGateBarrier.py new file mode 100644 index 0000000000..53381c55e1 --- /dev/null +++ b/src/qibo/ui/FusedGateBarrier.py @@ -0,0 +1,32 @@ +from qibo.gates.abstract import Gate + + +class FusedStartGateBarrier(Gate): + def __init__(self, q_ctrl, q_trgt, nfused, equal_qbits=False): + + super().__init__() + self.name = ( + "FusedStartGateBarrier" + + str(nfused) + + ("" if not equal_qbits else "@EQUAL") + ) + self.draw_label = "" + self.control_qubits = (q_ctrl,) + self.target_qubits = (q_trgt,) if q_ctrl != q_trgt else () + self.init_args = [q_trgt, q_ctrl] if q_ctrl != q_trgt else [q_ctrl] + self.unitary = False + self.is_controlled_by = False + self.nfused = nfused + + +class FusedGateEndBarrier(Gate): + def __init__(self, q_ctrl, q_trgt): + + super().__init__() + self.name = "FusedGateEndBarrier" + self.draw_label = "" + self.control_qubits = (q_ctrl,) + self.target_qubits = (q_trgt,) if q_ctrl != q_trgt else () + self.init_args = [q_trgt, q_ctrl] if q_ctrl != q_trgt else [q_ctrl] + self.unitary = False + self.is_controlled_by = False diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 82da829b2f..2db094f8e2 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -9,6 +9,7 @@ import numpy as np from qibo import gates +from .FusedGateBarrier import FusedStartGateBarrier, FusedGateEndBarrier global STYLE STYLE = {} @@ -174,82 +175,111 @@ def _draw_gates( def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measured={}): + + name, target = gate[:2] + + if "FUSEDGATEENDBARRIER" in name: + return + linewidth = plot_params["linewidth"] scale = plot_params["scale"] control_radius = plot_params["control_radius"] - name, target = gate[:2] target_index = _get_flipped_index(target, labels) controls = gate[2:] control_indices = _get_flipped_indices(controls, labels) gate_indices = control_indices + [target_index] min_wire = min(gate_indices) max_wire = max(gate_indices) - _line( - ax, - gate_grid[i], - gate_grid[i], - wire_grid[min_wire], - wire_grid[max_wire], - plot_params, - ) - ismeasured = False - for index in control_indices: - if measured.get(index, 1000) < i: - ismeasured = True - if ismeasured: - dy = 0.04 # TODO: put in plot_params + + if "FUSEDSTARTGATEBARRIER" in name: + equal_qbits = False + if "@EQUAL" in name: + name = name.replace("@EQUAL", "") + equal_qbits = True + nfused = int(name.replace("FUSEDSTARTGATEBARRIER", "")) + dx_right = 0.30 + dx_left = 0.30 + dy = 0.25 + _rectangle( + ax, + gate_grid[i + 1] - dx_left, + gate_grid[i + nfused] + dx_right, + wire_grid[min_wire] - dy - (0 if not equal_qbits else -0.9 * scale), + wire_grid[max_wire] + dy, + plot_params, + ) + else: + _line( ax, - gate_grid[i] + dy, - gate_grid[i] + dy, + gate_grid[i], + gate_grid[i], wire_grid[min_wire], wire_grid[max_wire], plot_params, ) + ismeasured = False + for index in control_indices: + if measured.get(index, 1000) < i: + ismeasured = True + if ismeasured: + dy = 0.04 # TODO: put in plot_params + _line( + ax, + gate_grid[i] + dy, + gate_grid[i] + dy, + wire_grid[min_wire], + wire_grid[max_wire], + plot_params, + ) - for ci in control_indices: - x = gate_grid[i] - y = wire_grid[ci] - - is_dagger = False - if name[-2:] == "DG": - name = name.replace("DG", "") - is_dagger = True - - if name == "SWAP": - _swapx(ax, x, y, plot_params) - elif name in [ - "ISWAP", - "SISWAP", - "FSWAP", - "FSIM", - "SYC", - "GENERALIZEDFSIM", - "RXX", - "RYY", - "RZZ", - "RZX", - "RXXYY", - "G", - "RBS", - "ECR", - "MS", - ]: + for ci in control_indices: + x = gate_grid[i] + y = wire_grid[ci] + + is_dagger = False + if name[-2:] == "DG": + name = name.replace("DG", "") + is_dagger = True + + if name == "SWAP": + _swapx(ax, x, y, plot_params) + elif name in [ + "ISWAP", + "SISWAP", + "FSWAP", + "FSIM", + "SYC", + "GENERALIZEDFSIM", + "RXX", + "RYY", + "RZZ", + "RZX", + "RXXYY", + "G", + "RBS", + "ECR", + "MS", + ]: - symbol = SYMBOLS.get(name, name) + symbol = SYMBOLS.get(name, name) - if is_dagger: - symbol += r"$\rm{^{\dagger}}$" + if is_dagger: + symbol += r"$\rm{^{\dagger}}$" - _text(ax, x, y, symbol, plot_params, box=True) - else: - _cdot(ax, x, y, plot_params) + _text(ax, x, y, symbol, plot_params, box=True) + + else: + _cdot(ax, x, y, plot_params) def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): name, target = gate[:2] + if "FUSEDSTARTGATEBARRIER" in name or "FUSEDGATEENDBARRIER" in name: + return + is_dagger = False if name[-2:] == "DG": name = name.replace("DG", "") @@ -415,6 +445,24 @@ def _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params): ) +def _get_min_max_qbits(gates): + def _get_all_tuple_items(iterable): + t = [] + for each in iterable: + t.extend(list(each) if isinstance(each, tuple) else [each]) + return tuple(t) + + all_qbits = [] + c_qbits = [t._control_qubits for t in gates.gates] + t_qbits = [t._target_qubits for t in gates.gates] + c_qbits = _get_all_tuple_items(c_qbits) + t_qbits = _get_all_tuple_items(t_qbits) + all_qbits.append(c_qbits + t_qbits) + + flatten_arr = _get_all_tuple_items(all_qbits) + return min(flatten_arr), max(flatten_arr) + + def _get_flipped_index(target, labels): """Get qubit labels from the rest of the line,and return indices @@ -428,6 +476,28 @@ def _get_flipped_index(target, labels): return nq - i - 1 +def _rectangle(ax, x1, x2, y1, y2, plot_style): + Rectangle = matplotlib.patches.Rectangle + x = min(x1, x2) + y = min(y1, y2) + w = abs(x2 - x1) + h = abs(y2 - y1) + xm = x + w / 2.0 + ym = y + h / 2.0 + + rect = Rectangle( + (x, y), + w, + h, + ec=plot_style["edgecolor"], + fc=plot_style["fillcolor"], + fill=False, + lw=plot_style["linewidth"], + label="", + ) + ax.add_patch(rect) + + def _get_flipped_indices(targets, labels): return [_get_flipped_index(t, labels) for t in targets] @@ -506,6 +576,69 @@ def _check_list_str(list, str): return False +def _process_gates(array_gates): + gates_plot = [] + + for gate in array_gates: + init_label = gate.name.upper() + + if init_label == "CCX": + init_label = "TOFFOLI" + + if init_label == "CX": + init_label = "CNOT" + + if _check_list_str(["SX", "CSX"], init_label): + is_dagger = init_label[-2:] == "DG" + init_label = ( + r"$\rm{\sqrt{X}}^{\dagger}$" if is_dagger else r"$\rm{\sqrt{X}}$" + ) + + if ( + len(gate._control_qubits) > 0 + and "C" in init_label[0] + and "CNOT" != init_label + ): + init_label = gate.draw_label.upper() + + if init_label in [ + "ID", + "MEASURE", + "KRAUSCHANNEL", + "UNITARYCHANNEL", + "DEPOLARIZINGCHANNEL", + "READOUTERRORCHANNEL", + ]: + for qbit in gate._target_qubits: + item = (init_label,) + item += ("q_" + str(qbit),) + gates_plot.append(item) + elif init_label == "ENTANGLEMENTENTROPY": + for qbit in list(range(circuit.nqubits)): + item = (init_label,) + item += ("q_" + str(qbit),) + gates_plot.append(item) + else: + item = () + item += (init_label,) + + for qbit in gate._target_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + for qbit in gate._control_qubits: + if qbit is tuple: + item += ("q_" + str(qbit[0]),) + else: + item += ("q_" + str(qbit),) + + gates_plot.append(item) + + return gates_plot + + def plot(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) @@ -548,68 +681,32 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): all_gates = [] for gate in circuit.queue: if isinstance(gate, gates.FusedGate): - all_gates += gate.gates - else: - all_gates.append(gate) + min_q, max_q = _get_min_max_qbits(gate) - gates_plot = [] + fgates = None - for gate in all_gates: - init_label = gate.name.upper() - - if init_label == "CCX": - init_label = "TOFFOLI" + if cluster_gates: + fgates = _make_cluster_gates(_process_gates(gate.gates)) + else: + fgates = _process_gates(gate.gates) - if init_label == "CX": - init_label = "CNOT" + l_gates = len(gate.gates) + equal_qbits = False + if min_q != max_q: + l_gates = len(fgates) + else: + max_q += 1 + equal_qbits = True - if _check_list_str(["SX", "CSX"], init_label): - is_dagger = init_label[-2:] == "DG" - init_label = ( - r"$\rm{\sqrt{X}}^{\dagger}$" if is_dagger else r"$\rm{\sqrt{X}}$" + all_gates.append( + FusedStartGateBarrier(min_q, max_q, l_gates, equal_qbits) ) - - if ( - len(gate._control_qubits) > 0 - and "C" in init_label[0] - and "CNOT" not in init_label - ): - init_label = gate.draw_label.upper() - - if init_label in [ - "ID", - "MEASURE", - "KRAUSCHANNEL", - "UNITARYCHANNEL", - "DEPOLARIZINGCHANNEL", - "READOUTERRORCHANNEL", - ]: - for qbit in gate._target_qubits: - item = (init_label,) - item += ("q_" + str(qbit),) - gates_plot.append(item) - elif init_label == "ENTANGLEMENTENTROPY": - for qbit in list(range(circuit.nqubits)): - item = (init_label,) - item += ("q_" + str(qbit),) - gates_plot.append(item) + all_gates += gate.gates + all_gates.append(FusedGateEndBarrier(min_q, max_q)) else: - item = () - item += (init_label,) - - for qbit in gate._target_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) - - for qbit in gate._control_qubits: - if qbit is tuple: - item += ("q_" + str(qbit[0]),) - else: - item += ("q_" + str(qbit),) + all_gates.append(gate) - gates_plot.append(item) + gates_plot = _process_gates(all_gates) if cluster_gates: gates_cluster = _make_cluster_gates(gates_plot) From a993caac57bd3223061ee2a39f77c2f3b583ce21 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 4 Jul 2024 12:13:35 +0000 Subject: [PATCH 068/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 2db094f8e2..fdaeb1e439 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -9,7 +9,8 @@ import numpy as np from qibo import gates -from .FusedGateBarrier import FusedStartGateBarrier, FusedGateEndBarrier + +from .FusedGateBarrier import FusedGateEndBarrier, FusedStartGateBarrier global STYLE STYLE = {} From ed0d2be7822036fbe2c3fe150bc9c6389adfe7f7 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 11:17:17 +0200 Subject: [PATCH 069/116] added new drawing cells and information in drawing notebook example --- .../qibo-draw-circuit-matplotlib.ipynb | 296 ++++++------------ 1 file changed, 88 insertions(+), 208 deletions(-) diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index 22a1f4431c..5ed83ef92f 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -1,8 +1,50 @@ { "cells": [ + { + "cell_type": "markdown", + "id": "738e41db", + "metadata": {}, + "source": [ + "## Matplotlib circuit drawing for Qibo" + ] + }, + { + "cell_type": "markdown", + "id": "7869858c", + "metadata": {}, + "source": [ + "Qibo now uses matplotlib to draw circuit, this new feature is base on `plot` function, you can pass the Qibo circuit along a built-in or custom style among other options." + ] + }, + { + "cell_type": "markdown", + "id": "0bfdad51", + "metadata": {}, + "source": [ + "Follow the examples below to learn how to use it." + ] + }, + { + "cell_type": "markdown", + "id": "805b65b1", + "metadata": {}, + "source": [ + "The default function signature for `plot`:\n", + " \n", + "```python\n", + "plot(circuit, scale=0.6, cluster_gates=True, style=None)\n", + "```\n", + "The parameters on nthis function are:\n", + "\n", + "- `circuit`: Qibo circuit (mandatory)\n", + "- `scale`: Scale up or down the output plot (optional, default value: 0.6)\n", + "- `cluster_gates`: Group gates (optional, default value: True)\n", + "- `style`: Style your circuit with a built-n style or custom style (optional, default vale: None)" + ] + }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 1, "id": "66e4921b-c1ea-479d-9926-d93a7c784be9", "metadata": {}, "outputs": [], @@ -22,7 +64,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 2, "id": "eda54008", "metadata": {}, "outputs": [ @@ -62,7 +104,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "id": "ea99c3d4-e36f-46ca-81c4-c8f10d6bcbe5", "metadata": {}, "outputs": [ @@ -72,7 +114,7 @@ "(,
)" ] }, - "execution_count": 4, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" }, @@ -93,25 +135,25 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "id": "81b65ea2-06a0-437d-b8f3-2ac176ea9b25", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "(,
)" + "(,
)" ] }, - "execution_count": 5, + "execution_count": 4, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -124,7 +166,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "id": "62d00656-b40d-44f1-b56a-6733eeed6759", "metadata": {}, "outputs": [ @@ -158,7 +200,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", "metadata": {}, "outputs": [ @@ -168,13 +210,13 @@ "(,
)" ] }, - "execution_count": 7, + "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAACeCAYAAADQbRsSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAw40lEQVR4nO3dfVzN9/8/8Me7Cx3RIslFSamhqVGu2kRpI9frysZctdKVmA+KtZmrtqHJQrR8VKi52KikpA8RbY2Uq2znMzYlvqY0IiKl1+8Pv85HOtU5p/e56Hjeb7dz223v9+u83o9T5/3u6fW+eHGMMQZCCCGEEDWjoewAhBBCCCHyQEUOIYQQQtQSFTmEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtQSFTmEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtQSFTmEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtQSFTmEEEIIUUtayg5ACCGEvE5KSkpQXl4ut/4NDQ1hamrKW3/yzvsqPvNTkUMIIYQoSElJCaysrFBVVSW3bejq6kIoFPJSKCgi76v4zE9FDiGEEKIg5eXlqKqqQmJiIqysrHjvXygUYubMmSgvL+elSJB33lfxnZ+KHEIIIUTBrKysYGdnp+wYEmtreevRhceEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtSSTEXOqlWrwHEciouLeY5DCCGEEMIPlR/JyczMBMdx2Ldvn7KjEEIIIXK1ZcsWcByH2bNni11///59GBsbQ1dXF1evXlVwOvGKi4vBcRw4jkP37t1RW1srtp1QKBS1MzMzU0g2lS9ynJ2doa+vj5SUFGVHIYQQQuRq/vz5cHJyQkJCAg4dOtRofVBQEG7fvo1169ahb9++SkjYNC0tLZSWluLIkSNi18fGxkJDQwMaGoorPVS+yNHW1sbEiRNx5MgRVFdXKzsOIYQQIjccxyE+Ph4dO3aEn59fg+kUDhw4gL1792L06NFYsGCBElOK9+6770JfXx9xcXGN1tXW1iIxMRHvv/8+tLW1FZaJ9yKnqqoKYWFh6Nu3LwQCAfr06YOIiAhcuHABHMchJCRE6j7d3d1RWVmJrKwsvuMSQgghKsXMzAwREREoKytDYGAgAKC0tBSBgYHQ09NDfHw8OI5TcsrG2rdvj2nTpiE9PR1lZWUN1qWlpaG0tBTe3t4KzcTrE48rKyvh7OyM/Px8ODs7w83NDX/++SdCQkIwduxYAICtra3U/Y4bNw4CgQDJycmYMGECn5GJimGMIS0tDZcvX0aPHj0wY8YM6OjoKDuWRM6cOYNTp06hQ4cO+Oijj9C1a1dlRyKEoG3um35+fkhKShKN3uzbtw/l5eWIjY1F7969lR2vSd7e3oiJiUFCQgKWLFkiWh4XFwcDAwO4uroqNhCTwcqVKxkAVlRU1GC5p6cn09DQYAkJCQ2Wf/vttwwAA8B+++03WTbJpkyZwoyMjNjz589lej9pG+bPn88AMC0tLQaADR06lFVVVSk7VotiY2MZx3FMU1OTcRzHunXrxoqLi5Udi5DXnqrtmwUFBQwAKygoaLHtrVu3WKdOnZiOjg4DwCZNmsRr/5KQpL+ioiIGgLm4uDDGGLO2tmYDBgwQrf/777+ZlpYWW7BgAWOMMR0dHda7d2+F5OftdFVWVhYOHDgAPz8/zJw5s8G6OXPmAHgxlNWvXz+Z+nd3d0dZWRlyc3NbnZWoptzcXERFRQGA6Or8goICbN68WZmxWvTw4UMEBASAMYbnz5+DMYby8nIEBwcrOxohr7W2vm8aGxtj/vz5qK6uhra2NrZv367sSBLx9vbGb7/9hrNnzwIAdu3ahdraWoWfqgJ4PF21detWAMDSpUsbrTMwMAAA2NjYQFNTU7R806ZN2LhxI0pLSzFkyBBs3boVAwcOFNv/5MmToaWlheTkZDg4OIhtc/78+dZ+DKJEJ06caLSM4zjk5eWp9O+2qKgINTU1DZY9f/4cFy9eVOnchKg7Vdw3hUKhxG3LysoQExMDAKipqUFaWhp8fX153w7f/cycORPLli1DXFwchg8fjvj4eNja2mLQoEG8bVfiyUJlGf4Rd7pKT0+PWVpaim1/8+ZNBoD5+/uLlv3www9MR0eH7dq1i125coXNmTOHdevWjT148KDJ7Q4YMIDZ29s3uR7//5QYvehFL3rRi16q/JLkdIybmxsDwNatW8cMDQ2Znp4eu3HjRrPvqT/do8i8r56uYowxd3d39sYbb7Bjx44xAGzLli2idZKcrmrpJSleRnIqKipQWVmJIUOGiF1//PhxAGhQxX333XcICAgQPfBox44d6N69O/bs2YOAgIBGfZSWlkIoFDZ7d1ZBQUErPgVRBevXr8ePP/4IDQ0N1NXVwdzcHImJiRAIBMqO1qxDhw5hzZo14DgOjDG88cYb2LNnD3r06KHsaIS81lRt3xQKhY0u6RAnISEBycnJmDRpEpYtWwYzMzNMmzYNPj4+OHbsWIvvT0xMhJWVlcLyvsrHxwdJSUnw8vKCQCDAjBkzpHo/X/l5Gcl59OgRA8AGDhzYqG11dTWzsrJiANiZM2dEyzQ1Ndnhw4cbtPXw8GCzZ88Wu82YmJgGfRD1VFdXx1JTU9m8efMYAPbrr78qO5LEfv31V7ZgwQIGgB0/flzZcQgh/58q7ZuSXFhbf8GxgYEBu337tmi5p6cnA8C+//77VvXPd15xIzm1tbXM2NiYAWDTpk1r0L7NXXjcoUMH9O7dG4WFhSgsLBQtr66uhpeXF4RCITQ0NGBjYwMAKC8vx/Pnz9GtW7cG/RgZGeHOnTtit5GUlISePXti2LBhfEQmKorjOEyePBk+Pj4AgHbt2ik5keTs7e3h5eUFAOjcubNywxBCRNravunj44OKigpERUU1GHHatm0bunbtipCQENy4cUOJCVumqamJlJQUJCcnY+3atUrLwdvdVcHBwairq8OoUaMQGBiIRYsW4a233sLdu3chEAjQr18/6OrqytT3gwcPcOLECbi6uqrkA5AIIYQQPsTExCAzMxOenp6YPn16g3Vdu3ZFdHQ0Kisr4e3tDcaYklJKZsiQIXB1dVXYPFXi8FbkBAUFISwsDB06dEBcXByOHj0Kf39/REVF4enTpw2uxzE0NISmpiZKS0sb9FFWVobu3bs36js9PR01NTVwc3PjKy4hhBCiUoqKihAcHAwjIyNER0eLbePh4YHp06fjxIkTTbYh/8PbLeQcx2H58uVYvnx5g+VJSUkAGj7puF27drC1tUVWVhYmTZoE4MVzUbKzs/HVV1816js5ORmdO3eGk5MTX3EJIYQQlWJubo7KysoW2+3Zswd79uxRQCLJmJmZSTWq9PTpUzmmaYjXaR3EuXTpEgA0uj9+0aJF8PHxweDBg2FnZ4cNGzZAS0sLH3/8cYN2T58+RUZGBtzd3aGlJfe4hBBCCFETcq8aLl68CKDxnFUff/wx7t69i88//1z0MMDMzEy88cYbDdrl5ORAIBDA09NT3lEJIYQQokYUMpJjbGwMQ0PDRusWLlyIhQsXNvv+MWPGNJhqnhBCCCFEEjIVOfXXxnTq1KnFtsXFxbJsghBCCCGkVWQucugiYEIIIYSoMt5uISeEEEIIUSVU5BBCCCFELdE92YQQQoiCCYVC6lcB26EihxBCCFEQQ0ND6OrqyjSzt6R0dXXF3tEsC0XkfRWf+anIIYQQQhTE1NQUQqFQro9GMTQ0hKmpKS99KSLvq/jMT0UOIYQQokCmpqa8/RFXhLaW92V04TEhhBBC1BIVOYQQQghRS1TkEEIIIUQtUZFDCCGEELVERQ4hhBBC1BIVOYQQQghRS1TkEEIIIUQtUZFDCCGEELVERQ4hhBBC1BIVOYQQQghRS1TkEEIIIUQtUZFDCCGEELX0Wk7QWVJSopAZVfmcSbWeIrLLIzch6kpRx5OXybqPKiNrc17XY428fw98/1wV/b2hWchboaSkBFZWVqiqqpL7tnR1dSEUCnn7ZSkqO9+5CVFXijyevEyWfVRZWZvzOh5rFPF74PPnqozvDZ/5X7sip7y8HFVVVUhMTISVlZXctiMUCjFz5kyUl5fztgMrIrs8chOirhR1PHmZrPuoMrI253U91sj798D3z1XR3xu+8792RU49Kysr2NnZKTuGTNpydkLUUVvaJ9tSVnXW1n4PbS1vPbrwmBBCCCFqiYocQgghhKglKnIIIYQQopZkKnJWrVoFjuNQXFzMcxxCCCGEEH6o/EhOZmYmOI7Dvn37FLbN4uJicByHcePGNdkmOzsbHMchICBAYblasmXLFnAch9mzZ4tdf//+fRgbG0NXVxdXr15VcDpCZPfPP/9I9Y8qxhjOnz8vv0BSePz4Mb755hvY2dmhY8eO0NHRgYmJCUaOHInQ0FD89ddforZOTk7gOA537txReM76415zr4qKCpw/fx7a2tro168fnjx5IravCRMmgOM4JCYmKvhTtH1t8Tj+8nene/fuqK2tFdtOKBSK2pmZmSkkm8rfXeXs7Ax9fX2kpKRg2rRpyo6j0ubPn4+kpCQkJCTAw8MDH3zwQYP1QUFBuH37NjZt2oS+ffsqKSUh0vP398e5c+eQnZ0Nc3PzZtsyxrBo0SJs3boVf/zxB/r06aOglI1VVlbCwcEBly9fhqWlJWbOnIkuXbqgvLwceXl5WLduHSwsLGBhYaG0jK+ysLDAzJkzxa4TCASws7PDF198gdWrVyM0NBSRkZEN2mzfvh0ZGRlwc3Nrsh/StLZ8HNfS0kJpaSmOHDmCKVOmNFofGxsLDQ3Fjq2ofJGjra2NiRMn4vDhw6iuroaOjo6yI6ksjuMQHx8PGxsb+Pn5YcSIETA0NAQAHDhwAHv37sXo0aOxYMECJSclRDqRkZFwcnKCk5NTs4VOfYGzadMmbNu2TakFDvAi9+XLlzF37lxs374dHMc1WF9UVITq6molpRPP0tISq1atarbNF198gdTUVGzevBlubm5wdHQE8OLzLFmyBF27dkVMTIwC0qqftnwcf/fdd3Hp0iXExcU1KnJqa2uRmJiI999/H6dOnVJYJt5LqqqqKoSFhaFv374QCATo06cPIiIicOHCBXAch5CQEKn7dHd3R2VlJbKysviOq3bMzMwQERGBsrIyBAYGAgBKS0sRGBgIPT09xMfHNzrQEqLqTExMkJ2dDW1tbTg5OaGoqKhRm1cLnPrvvzL9+uuvAF7861vcfmdubo7+/fsrOlaraWtrY/fu3dDW1sYnn3yCR48eoa6uDl5eXnj06BFiYmLQtWtXZcdss9rqcbx9+/aYNm0a0tPTUVZW1mBdWloaSktL4e3trdBMvBY5lZWVcHR0xIoVK9CrVy8sXLgQtra2CAkJQWhoKADA1tZW6n7HjRsHgUCA5ORkPuOqLT8/P7i4uIiqfj8/P5SXlyMyMhK9e/dWdjy1dffuXZw9exYAmjwnrYoeP36MU6dOITs7G5WVlcqO06TmCh1VLHAAoEuXLgCgMtdO8Mna2hqrV68Wjd5ERkbi9OnTmDVrFtzc3JQdr4G2uG+21eO4t7c3amtrkZCQ0GB5XFwcDAwM4OrqqtA8vJ6u8vb2xvnz55GQkNDgXOyGDRtEIziDBg2Sut8OHTpg7NixSE1NRUxMjMLO6f35559NDtuq+p1lsbGxsLa2xieffILq6mpMmjRJ4RX06+T06dOYPHkyHj58CADw9fXFzz//DD09PSUna15xcTHee+89XL9+HQDQq1cvZGVl4c0331RyMvHqC52XT12ZmZmpZIEDAFOnTkViYiLmzp2LvLw8jB07FoMHDxYVP6qoqePeuHHjYG9v32BZSEgIUlJSsH37drRr1w4mJibYvHmzgpJKpq3um0DbPI4PGzYM1tbWiI+Px5IlSwAAd+7cQUZGBgIDAxV/yQmTwcqVKxkAVlRUJFp2/PhxBoAFBAQ0al9WVsYAsPbt27Pa2lpZNsl27tzJALCcnByZ3l+voKCAAWAFBQVNtikqKmIAJHr5+/vLvB15ZH/Z8uXLGQCmra3Nbt++LZdtyIuq5JBEVVUVMzAwYBoaGqLvhYaGhth9QdWMHDmSaWlpiXJramoyOzs7Zcdq0c2bN5mFhQUzNTVlXl5eDADbtm2bwnNI8j2NiIhgHTt2bHDcsLCwYEFBQezq1asN2jo6OjIA7O+//27VNmV5X0vHve+++07s++qP/QDYgQMHeMvDB1XcN+V9HOf75yrN30wXFxfGGGMbN25kANiZM2cYY4ytW7eOAWAXLlxgjDGmo6PDevfurZD8vI3kbN26FQCwdOnSRusMDAwAADY2NtDU1AQAJCUlITo6GgUFBbh//z6KioqavaVs8uTJ0NLSQnJyMhwcHMS2keSWUaFQ2GKbei4uLjh69KjYddnZ2Rg9ejSv2+Ozr7KyMtGFfzU1NUhLS4Ovr69ctiUP9dtXdg5JFBUV4d69ew2W1dXV4cSJEypzG3NTzp4922D4/vnz57hw4QLy8/MVfheEtDZv3owPP/wQO3fuhI+PD4YPH67wn7ck38/FixfD19cXR48eRW5uLvLz83H27Fls3boVsbGx2L9/v9g7UfjYtiztmzvuvYoxhq+++kr0/0lJSfDw8JBLLlmo4r6pqOM4Xz9XWfqZOXMmli1bhri4OAwfPhzx8fGwtbWV6kxOS9uVeB4tWSojcSM5enp6zNLSUmz7mzdvNhr12L17N1uzZg3bsmVLo76aMmDAAGZvb9/kekg4+gIpq1JxTp48KdFIjjxeklS4bm5uDABbt24dMzQ0ZHp6euzGjRstvk+euelFL3V9SfuvzoqKCjZv3jwGgBkaGrLq6mrGmHQjOXxnleS496rIyEgGgM2aNUuUPTk5WaL3vu7HGnkdx+X1c5X2b6a7uzt744032LFjxxgAtmXLFtE6SUZyWnpJipeRnIqKClRWVmLIkCFi1x8/fhxAw+txZs2aBQC4cuWKRNsoLS2FUChs9u6sgoKCFvupn8ZdUficnl7S7AkJCUhOTsakSZOwbNkymJmZYdq0afDx8cGxY8ck2hafuWVR/1mVnUNSERER2LNnj+j/NTU1sWPHDrz99ttKTNWyI0eO4MsvvwTHcWCMAXhxe7C7u7uSkzWNMYaIiAjs3bsXXl5e2LlzJ4yMjKChoYHt27fD2NhYYVlkPZ7o6+sjKioK6enpuHHjBgoLCzF48GCp+pB23+D72Hf16lWEhobCxMQEW7ZswT///IO3334bAQEBGDlypMTXHcl7H1e1fVNRx3G+fq6yfm98fHyQlJQELy8vCAQCzJgxQ6r38/a9kLgcesmrIzmPHj1iANjAgQMbta2urmZWVlYM+N/5uZcVFhY26KspMTExTfYhDVnOL4oj6UiOoq/JuXXrFuvUqRMzMDBocP7W09OTAWDff/99q7ehCKqSQ1J1dXUsOjqavf/++wwAS0hIUHYkiaWlpbHx48czAOzbb79Vdpxm1dXVsYULFzLgxTU49d+TI0eOiK7RuX79usLytPZ7+tZbbzEALD8/nzGmGtfkSDKSU1tby+zt7RkAdvToUdHyqKgoBoBNmzat1Xn4omr7pryP46pwTQ5jL74jxsbGYr8Pirwmh5eT7h06dEDv3r1RWFiIwsJC0fLq6mp4eXlBKBRCQ0MDNjY2Mm8jKSkJPXv2xLBhw/iIrLZ8fHxQUVGBqKgo9OjRQ7R827Zt6Nq1K0JCQnDjxg0lJlRP9VN8rF+/HgDw1ltvKTmR5CZOnCi6rsLZ2VnJaZrGmrlNvFu3bi0+R0cZYmJicO7cObHrUlJSIBQK0alTJ1hbWys4WeuEh4fjzJkzotuc682bNw/Ozs7Yt28fkpKSlJjwf9rivqkOx3FNTU2kpKQgOTkZa9euVVoO3q4sDA4ORl1dHUaNGoXAwEAsWrQIb731Fu7evQuBQIB+/fpBV1dXpr4fPHiAEydOwNXVVSUfgKQqYmJikJmZCU9PT0yfPr3Buq5duyI6OhqVlZXw9vYWnZogpC1orsCpJ8kDAxUtIyMDw4YNw5tvvgkvLy98/vnnWLhwIUaNGgU3NzdwHIdt27a1qSe5FxYWYtWqVTA3N0dERESDdRzHITY2Fh07dkRgYCDKy8uVlLLtUqfj+JAhQ+Dq6qqwearE4a3ICQoKQlhYGDp06IC4uDgcPXoU/v7+iIqKwtOnT2V6Pk699PR01NTUqNwDplRJUVERgoODYWRkhOjoaLFtPDw8MH36dJw4caLJNoSooqVLl0r0HJxXC51bt24pMGVj69evR3h4OMzNzXH69Gl899132L59O27fvo05c+YgLy+v0R8yVVZTU4PZs2ejpqYGcXFx6NixY6M2Lz+td968eUpI2XbRcZx/vN1CznEcli9fjuXLlzdYXj9kKcuTjuslJyejc+fOcHJyak1EiZmZmbVYITs5OalUFW1ubi7R02r37NnT4CI8QtoCBwcHWFhYICAgoMW29YXO2rVrlT61QL9+/RASEiLxdDbZ2dnyDdQMSY572trauHDhQot9+fn5wc/Pj69or422ehyX5LvzsqdPn8oxTUNyn6Dz0qVLABo/6fjevXsoKSnBX3/9BQD4/fffUVFRAVNTU9FzdYAXP4yMjAy4u7tDS0vl5xMlhMjBqzMxt8TExET07C5CyOtL7k/7unjxIoDGIzmpqamwtbWFp6cngBcXP9ra2iI1NbVBu5ycHAgEAlE7QgghhBBJKGQkx9jYWDRVfD0vLy94eXm1+P4xY8bQxWuEEEIIkZpMRU79tTGdOnVqsa2qT2RJCCGEEPUkc5GjqIuACSGEEEJkodoz8BFCCCGEyIiKHEIIIYSopdf2nmy+pqFXRv9ttW9C1JUi95vWbktV9nFVyaEs8vr8ba1feW/ntStyDA0Noaurq5CZyHV1dRvdVdYaisrOd25C1JUijycvk2UfVVbW5ryOxxpF/B74/Lkq43vDZ/7XrsgxNTWFUChUyG3phoaGMDU15a0/RWXnOzch6krWfVIoFGLmzJlITEyElZWV1NuVZR/l6/jR2uwvex2PNYo4jvP5c1Xk38x6fOZ/7Yoc4MUvra3uWG05OyHqqDX7pJWVFezs7HhO1DQ+jx+Kzq5O2tpxvK3lfRldeEwIIYQQtURFDiGEEELUEhU5hBBCCFFLVOQQQgghRC1RkUMIIYQQtURFDiGEEELUEhU5hBBCCFFLVOQQQgghRC1RkUMIIYQQtURFDiGEEELU0ms5rYOqKykpUeg8IdJoaU4RvrLXz0TL14y0r+McOYQQ8rqjIkfFlJSUwMrKClVVVcqOIpauri6EQqHYgkEe2fma+ba53IQQQtQTFTkqpry8HFVVVbzM8Mu3+tmHy8vLxRYLqpq9pdyEtIYso5etHamUdWSSj5FWPkdZJfkcNDpMWoOKHBXVlmf4bcvZCZFGa0cvZR2plGVkku+RVj5GWVv6HDQ6TFqLihxCCJGRMkYvZR2ZVLWRVkk+h6plrkejw20HFTmE8KC0tBSXLl3C2bNnAQD5+fmwsrJC+/btlZyseQ8fPsSFCxeQk5MDAPjll1/Qp08fdOrUSbnB2pi2NHrZlrLWa4uZiWqgW8gJkVFxcTFCQ0NhamqK7t27w8XFBStWrAAA+Pv7Q09PD++88w7i4+Px5MkTJaf9n3v37mHjxo2wsbGBvr4+nJyc8OWXXwIAPv30U3Tu3BlWVlYIDw9X2bv8CCFEElTkECKlqqoq/Otf/0KfPn0QHR2NKVOm4Mcff8S1a9fw73//GwAQFhaGrVu3onPnzvDx8YGZmRkOHjyo1Nx1dXXYvHkzevXqhc8++wzW1tbYuXMnCgsLsX37dgDA+vXrsXv3bgwZMgQrVqxAr1698O233+L58+dKzU4IIbKgIkcNcRzHy4tyNyYUCjFw4EDExMRg/fr1+L//+z9ERUVh6tSpsLS0FJ2eMjc3h7+/P44cOYJr167h3XffhaenJ2bPno1nz57JNaM49+7dw3vvvYeFCxfik08+wc2bN7F3717MmTMH1tbW0NXVBQAYGxtj1qxZSEhIwK1btxAYGIhly5Zh5MiRKCsrU3huQghpDZmKnFWrVoHjOBQXF/Mch7TWw4cPER4eDsZYq1+Uu6Hff/8do0aNgkAgwKVLlxASEoIOHTq0+D4LCwskJSVh9+7d2L9/Pzw8PFBTUyO3nK+6f/8+nJ2dceXKFZw4cQJRUVHo1q1bi+8zNDTExo0bkZOTg6KiIjg6OuLu3bsKSEwIIfxQ+ZGczMxMcByHffv2KTtKm5CRkYHx48crO4bUVD13ZWUlJk6ciB49euDUqVPo27evVO/nOA6zZs1CamoqMjMzsXTpUjklbYgxhunTp+PWrVvIzs7G6NGjpe5jxIgROH36NO7fv4+pU6eirq5ODkmbV1NTg8ePH0v1noqKCvmEkdLjx4/xzTffwM7ODh07doSOjg5MTEwwcuRIhIaG4q+//hK1dXJyAsdxuHPnjsJzFhcXtzhKWlFRgfPnz0NbWxv9+vVr8lqzCRMmgOM4JCYmKjyzrq4uevbsiffeew8rVqxo8POtl52d3eJndXJykmt2ohgqf3eVs7Mz9PX1kZKSgmnTpik7jsq7cuUKPvroI2XHkJqq5162bBnu3r2LrKwsGBgYyNyPi4sL1q5di5CQEHh4eMDBwYHHlI3FxcUhMzMT6enpGDBggMz9vPnmm9i7dy+cnZ2xdetWLFiwgMeULfP398e1a9eQkZGBjh07tth+586dCA4Oxrlz52Bubq6AhOJVVlbCwcEBly9fhqWlJWbOnIkuXbqgvLwceXl5WLduHSwsLGBhYaG0jK+ysLBo8lkyAoEAdnZ2+OKLL7B69WqEhoYiMjKyQZvt27cjIyMDbm5uvD2TpiUvZ66urkZZWRny8vIQFhaGb775BkuXLsXXX3/d6HT24MGDMWnSJLF9mpmZyTs2UQQmg5UrVzIArKioSJa3S+3jjz9menp67OnTpwrZnjIVFBQwAKygoEDq99bU1LA1a9Y0WDZjxgymo6PD/vjjj0bt165dywCww4cP85JN1uzKzt2S33//nQFgmzdvbrFtYmIiA8ASExObbFNbW8vs7e3ZkCFDZMojqaqqKmZgYMDmzJnTYltJcjPGWGBgIOvYsSN7+PAhTyklk5uby/T09JiDgwOrrKwULRf3u42Pj2ccxzE/Pz/2/PlzueZq6bu1Zs0aBoDNnTuX1dXVNVp//fp1JhQKRf/v6OjIALC///5b5m3K+r6ioiIGgLm4uLTY17Nnz5itrS3jOI5lZ2eLll+/fp117NiRde3alZWVlbUqDx+Zc3JymJmZGQPAli9fLlp+8uRJBoD5+/s3m7E12Ylq4P10VVVVFcLCwtC3b18IBAL06dMHERERuHDhAjiOQ0hIiNR9uru7o7KyEllZWXzHVSunTp3CqFGjGizbuHEjdHV1ERAQ0GB5UVER1qxZAw8Pjyb/JaMoqp47OjoaRkZG8Pf356U/TU1NLF++HPn5+Th37hwvfYrz448/4t69e1i+fDlvfX7++ed48uSJ3E9DvOqdd95BZmYmLl26hPHjx+PRo0di2+3cuRPe3t7w9fVFdHQ0NDSUe0b+119/BQAEBQWJvSje3Nwc/fv3V3SsVtPW1sbu3buhra2NTz75BI8ePUJdXR28vLzw6NEjxMTEoGvXrsqOCQcHBxw9ehQ6OjoIDw/HzZs3lR2JKBivR4DKyko4OjqKbj1duHAhbG1tERISgtDQUACAra2t1P2OGzcOAoEAycnJfMZVOz///HOj0x9GRkZYv349Tp48iV27domWz5s3D9ra2ti0aZOiYzaiyrnr6uqQkJAAb29vtGvXjrd+x40bB1NT0wafjW+7d+/GmDFjYGlpyVufJiYmmDRpklxzN6WlQkfVChwA6NKlCwDg6tWrSk7CP2tra6xevRpFRUVYsmQJIiMjcfr0acyaNQtubm7KjifSr18/fPjhh3j27BlSUlKUHYcoGK/X5Hh7e+P8+fNISEhocC52w4YNohGcQYMGSd1vhw4dMHbsWKSmpiImJkYlDl6qqLa2Fpqamo2Wz507F7t27UJwcDAmTZqEY8eO4ejRo9i8eTOMjY2VkLQhVc597do1VFRUwNnZmdd+NTU14eTkhLy8PF77rVdXV4dz587h888/571vZ2dnhISE4NmzZ7wWfpKoL3RcXFwwfvx4rF27FgCQmpqKNWvWqFSBAwBTp05FYmIi5s6di7y8PIwdOxaDBw8WFT+q6M8//8SqVasaLR83bhzs7e0bLAsJCUFKSgq2b9+Odu3awcTEBJs3b1ZQUsk5OTkhISGh0chpfn6+2M8KiP+8pO3hrcjJysrCgQMHEBAQ0Ohiszlz5iAkJATt27dHv379ZOrf3d0dqampyM3NlfvFmqru9u3b+OabbxAVFSVadvHixSYLSI7jEBMTA1tbWwQGBiInJwdDhgxBUFCQghK/0BZzX7x4EcCLCxT5NnjwYOzfvx/Pnz8XW+S1xvXr11FZWSm33M+ePRM9M0jRXi506i+AVsUCBwCmTJmCiIgIrFy5EhEREYiIiADw4kLZcePGYeHChXjzzTeVnLKhv/76C6tXr260vFOnTo3+6GtqauLrr7/G+++/j2fPniEyMlIlpwTp2bMnADR6gndBQQEKCgrEvkfc5yVtD29FztatWwFA7K2x9Xej2NjYiA7ma9euxcGDB/HHH39AV1cXjo6OCA8Pb/KK9smTJ0NLSwvJyclNFjnnz5/n4ZMol1AobLHNpUuXRA+Zqz9AZmZmNvvHf8CAAQgODsbatWuhqamJ9PR0mf8YNJWxpeyqmrs5Fy5cgKamJoqLiyV6LlRRUZHovy19H6uqqlBdXY3c3FyJnrcjjStXrgB48RBASfYLaXLX/6E4c+aM0p6ErKOjg82bN8PPzw/Ai2svfH19RUWpokjynVq8eDF8fX1x9OhR5ObmIj8/H2fPnsXWrVsRGxuL/fv3Y8qUKXLZtiztXVxccPToUYnaMsbw1Vdfif4/KSkJHh4evOWSZZ+Vhr+/P77//nuZ3y/vfKRpEs9lJsvVyuLurtLT02OWlpZi29+8ebPRlewuLi5s586d7LfffmPnz59n7733Huvfvz+rqalpcrsDBgxg9vb2Ta4HoDavlq7aX7lyJQsPDxf9/8t3DjQlIiKCAWC9evVi1dXVLbZ/Vf0dBa3Jrsq56UUvWV/S3mVTUVHB5s2bxwAwQ0ND0fdamrur+M4qzd1V9SIjIxkANmvWLFH25ORkid4rzedobebY2FgGgM2ePZsxxt/dVfRS3ktSvIzkVFRUoLKyEkOGDBG7/vjx4wAaXo/z6r8U/v3vf6NPnz74/fff8fbbbzfqo7S0FEKhsNm7s5oadmxLhEKhRM+WcHV1RVBQEEJCQnDz5k2Ympo22/7mzZtYuXIlrK2tceXKFYSHh8t8101iYiKsrKxkyq6KuZuTnZ2NJUuWICMjA0ZGRi22v3jxInx8fBAbG9vi9Wfx8fGIi4vDqVOneD/FUlpaigkTJmDjxo1wdHRssb00uc+cOYOgoCAcPHhQac8Sqb8GZ/LkyRg4cCAiIiLQt29fbNmyRTRFhSJIur++Sl9fH1FRUUhPT8eNGzdQWFgo9alFab/PsmZtytWrVxEaGgoTExNs2bIF//zzD95++20EBARg5MiREl931Nzn4CtzdnY2AGDo0KGt7utlshxTiGLxUuRoa2sDeDE0/qpnz54hPDwcQPN3Vj148AAAmnzQ2qFDh1BXV9fsVfsSD1+pgUGDBuHOnTsoLS1FWloaXF1dm20/f/58AC+eLLx48WJ8/fXX+Pjjj9GnTx+pt21lZSXzz7qt5TYyMsKSJUtQXV0t1XsHDRrUYvu1a9di6NChTf7joDUYYzAyMsL9+/d5z/2f//wHenp6cHV1Vcr1Lzt37mx0Dc748ePh4uKC0NBQiR8YqGwcx7XqNGVr9sPWev78OebMmYMnT55gx44d0NfXh76+PtavX4/58+dj/vz52Lt3r0R9yftzXL16FT/++CN0dHR4v+tLmb8DIhlejlAdOnRA7969UVhYiMLCQtHy6upqeHl5QSgUQkNDAzY2NmLf//z5cwQHB2PChAkwMTER2yYpKQk9e/bEsGHD+IisFiZPnozDhw/j9u3b6NGjR5PtkpOTkZqairCwMJiYmCAyMhLt2rVT+IXH9dpSbmNjY5iamiItLY3Xfp88eYKsrCyMGDGC137rcRyHESNGIC0tjff5vNLT0/HOO+8orcARd5u4pM/RUbSYmJgmn4WUkpICoVCITp06wdraWsHJWic8PBxnzpyBn58fXFxcRMvnzZsHZ2dn7Nu3D0lJSUpM+MIvv/wCFxcXVFdX47PPPlOJu0mJYvF24XFwcDAWLFiAUaNGYdq0aRAIBEhNTUWfPn0gEAhgbm4udhiZMYaAgACUlJTgl19+Edv3gwcPcOLECfj6+ipldmxV9cEHH2DFihXNjoZUVlbi008/ha2trehOlJ49eyIsLAwLFy7ETz/9hKlTpyoo8QttKTfHcZg7dy7WrVuHDRs2QF9fn5d+9+/fj4qKCnh7e/PSnzhz587FxIkTkZeXh+HDh/PS5+XLl/Hzzz/jp59+4qU/abT0HJxXby9XhRGdjIwMBAQEwNLSEiNGjEDPnj3x+PFjXLhwATk5OdDQ0MC2bdugo6Oj1JzSKCwsxKpVq2Bubi66W6wex3GIjY2FjY0NAgMDMWrUKBgaGso908u3vT979kw0rUNhYaHo4ZsrV65s9L7mbiEXCAT47LPP5JiaKIQsF12Ju/C4rq6OhYWFMWNjY9auXTvWv39/tn79evbf//6XAWDTp09v1E9dXR0LCAhgZmZmrKSkpMnt/fDDDwwAO3bsmCxx2xRpHhdeW1vLDAwM2G+//dZkm08//ZRpaGiwvLy8Ru+1s7NjPXv2lPgR/XxN66BquVty+/ZtpqOjwxYvXszLtiorK5m5uTmbNGmSTHkkVVtbyywtLZmTk1OL0xtIkruuro6NHz+emZiYsGfPnvEdt1nSTNXQ1BQQ8tDSz+2///0vCw8PZ2PGjGHm5uZMIBAwgUDALCws2Jw5c1h+fn6D9qo+rcOzZ8/YoEGDGMdx7OTJk022i4mJYQDY1KlTZc4jTeaXX+3bt2c9evRgo0ePZl9++SX7888/G72v/sLj5l76+vqtyk5Ug9znrjp48CAD0OCOGsZeHDADAwNZr1692PXr15vtw9PTk3Xu3LnZO6/UhbQ7z44dO5pcl5+fzzQ1Ndn8+fPFrs/Ly2MaGhrs008/5SWbNNlVKbckvv32W8ZxHDt9+nSrtxUYGMh0dXXFHnz5lpWVxYCW592SJPeOHTsYAJaWlsZ3zBZ99dVXUs1FlZuby+zt7Vlpaalccynjj528ihxF46PIURZVzUUak/ss5JcuXQLQ+EnHQUFB2Lt3Lw4fPoz27dvjzp07AF5cePzyU1SfPn2KjIwMuLu7Q0tL5SdNVzgfH58m1w0ePBi1tbVNrh86dKjSnnPS1nIvWrQIhw4dgru7O06ePCnzNRQRERGIjo7Gtm3bFDLztLOzM+bPn4/FixfD1NQUH3zwgUz9ZGZmYt68efDx8cHEiRN5TtmyL774AowxiU9Xv/POO8jNzaXT24S85uR+5WD9w7levbMqOjoaFRUVGDlyJHr06CF65ebmNmiXk5MDgUAAT09PeUclpEmampo4dOgQjI2N4ejoKPUcOFVVVfjXv/6F4OBghIaGIjAwUD5Bxfjuu+/g6uoKT09PbNy4UaoCsa6uDlFRUZgyZQrGjh2Lbdu2yTFp86QtWKjAIYTIvci5dOkSjI2NG118xl6cKmv0cnJyatBuzJgxKC8vl+mJoITwycDAANnZ2XBwcICbmxs++ugj0UhlU2pqavDTTz9h0KBBiImJwaZNm/D1118rKPELWlpa2Lt3LxYuXIjg4GCMHDkSx48fb/auK8YYsrOz4ezsjAULFsDX1xcHDx5U+FxVhBDSGjKd/6kvRCSZo0SSR+ET0lZ06tQJKSkp2LNnD5YuXYpBgwZh+PDhcHR0hJ2dHe7fvw8AOHDgAKKjo5Geno6///4bo0ePxuHDh2Weu621tLS0sGHDBri6umLevHkYM2YM+vbtK5ow8smTJwCAtLQ07Nq1C8eOHYNQKET//v2RlZXF+wSlhBCiCDIXOa+OuBDyuuA4DjNmzMCHH36I1NRU/PDDD9izZ4/ooZcAsH79etjY2MDDwwO+vr5in+KtDA4ODrh06RJycnIQFxeH//znPw0mTF25ciUsLS1hb2+PqKgojB49mk77EELaLLqSlxAZaWtrw8PDQzQh4T///IM7d+6guLgY9vb2Ej/WXtE4jsOoUaMwatQoAC+eSXTr1i1cu3YNQ4cObfYBjYQQ0pZQkUMIT7p06YIuXbpgwIAByo4iFT09PVhZWdEcPIQQtUNFDiGEtJJQKGwz21Jk1uZIk0NVMtdTtTykaVTkqChV3IkkzaRq2VUtD1EfhoaG0NXV5XV2b0no6upKPV2CsrI2p6XPoYqZ68nyOyCKx7Hm7iMlCldSUgIrKytUVVUpO4pYurq6EAqFMDU1bbROlbM3l5uQ1igpKUF5eblCt2loaCjTd1kZWZsjyedQtcz1ZP0dEMWiIkcFqepODbS8Y6tqdjogEULI64eKHEIIIYSoJbk/8ZgQQgghRBmoyCGEEEKIWqIihxBCCCFqiYocQgghhKglKnIIIYQQopaoyCGEEEKIWqIihxBCCCFqiYocQgghhKglKnIIIYQQopaoyCGEEEKIWqIihxBCCCFqiYocQgghhKglKnIIIYQQopaoyCGEEEKIWvp/uB6Hj9G0XlUAAAAASUVORK5CYII=", "text/plain": [ "
" ] @@ -189,7 +231,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 7, "id": "5f5896a5-e639-401c-992a-19b960720ec4", "metadata": {}, "outputs": [ @@ -214,7 +256,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 8, "id": "afa80613-6330-4a85-928f-4cb884d81990", "metadata": {}, "outputs": [ @@ -230,12 +272,12 @@ } ], "source": [ - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\", save_file = \"file2.png\")" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\")" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 9, "id": "916f7b83-1ad7-4984-8573-eb55dfeb125d", "metadata": {}, "outputs": [ @@ -256,7 +298,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 10, "id": "b9e1176c-d8dc-47e4-9607-ad24f6f536b9", "metadata": {}, "outputs": [ @@ -277,7 +319,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 11, "id": "eaefdf76-af68-4187-996d-bdc9c33a4242", "metadata": {}, "outputs": [ @@ -298,7 +340,7 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 12, "id": "56f4f3cc-6864-4ef2-aa19-9c209fc217e5", "metadata": {}, "outputs": [ @@ -314,217 +356,55 @@ } ], "source": [ - "custom_style = dict()\n", - "custom_style[\"facecolor\"]=\"#6497bf\"\n", - "custom_style[\"edgecolor\"]=\"#01016f\"\n", - "custom_style[\"linecolor\"]=\"#01016f\"\n", - "custom_style[\"textcolor\"]=\"#01016f\"\n", - "custom_style[\"fillcolor\"]=\"#ffb9b9\"\n", - "custom_style[\"gatecolor\"]=\"#d8031c\"\n", - "custom_style[\"controlcolor\"]=\"#360000\"\n", - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=custom_style)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "id": "d549425d-0d8c-4b07-8349-db873b6ae9b0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─U─U─\n", - "q1: ─U─U─\n" - ] - } - ], - "source": [ - "c = models.Circuit(2)\n", - "c.add(gates.Unitary(np.random.random((4, 4)), 0, 1))\n", - "c.add(gates.Unitary(np.random.random((2, 2)), 0))\n", - "c.add(gates.Unitary(np.random.random((2, 2)), 1))\n", - "\n", - "print(c.draw())" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "id": "edacdee7-3f48-4a63-adb9-3c898d62fc9d", - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAA3wAAAD7CAYAAAAxSZbfAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA0EklEQVR4nO3df1xVdYL/8fdFsCtkKIstkxMqDze6q1bgr0dNKfmo0DEsSX34SLaIHibmmDMFtvp1DLR96DqaU+aYpagjts5uC3jHH1loNOzguIY/hh7dcm1imG2TIkejSBC53z98wIj8uvd67j33Hl/Px6PHPOacc895HznAeXPO+Ryb2+12CwAAAABgOWFmBwAAAAAA+AeFDwAAAAAsisIHAAAAABZF4QMAAAAAi6LwAQAAAIBFUfgAAAAAwKIofAAAAABgURQ+AAAAALAoCh8AAAAAWBSFDwAAAAAsisIHAAAAABZF4QMAAAAAi6LwAQAAAIBFUfgAAAAAwKIofAAAAABgURQ+AAAAALCocLMDmKGmpkZ1dXV+305sbKzi4+O9/lyg8nnLk/0J1ezkNpavxz4AAECwCvR5l1HnU9dc4aupqZHD4VBDQ4PftxUZGSmXy+XVFyqQ+bzV0/6EanZyG8+XYx8AACBYmXHeZdT51DVX+Orq6tTQ0KDCwkI5HA6/bcflcikjI0N1dXVefZEClc9bnuxPqGYnt7F8PfYBAACCVaDPu4w8n7rmCl8rh8Oh5ORks2N0KdjzdSdUs5MbAAAA3QnF8y4GbQEAAAAAi6LwAQAAAIBFUfgAAAAAwKJ8Knx5eXmy2Wyqrq42OA4AAAAAwChBf4Vv//79stls2rlzZ8C2WV1dLZvNpokTJ3a5TFlZmWw2m7KzswOW68ptZ2ZmerXM8ePHtXjxYqWmpmrAgAGy2WxKSUnxe97uMnmyDLl9E6q5AQDA1XO73X5dHu219gebzaa4uDg1Nzd3upzL5WpbbvDgwQHJFvSFb8KECYqOjlZJSYnZUUJeSUmJVqxYobKyMsXFxZkdx2PkDqxQzQ0AAC75l3/5F2VnZ6ulpcWj5Q8dOqS77rpLX375pZ+TWV94eLhqa2u1d+/eTudv3rxZYWFhCgsLXA0L+sIXERGhyZMna+/evWpsbDQ7TkibPn26Kisr9e233+rdd981O47HyB1YoZobAABcMnDgQL3xxhuaO3duj6Xv0KFDSk1NVXh4uCIjIwOU0LruuusuRUdHq6CgoMO85uZmFRYW6r777lNERETAMhle+BoaGrR8+XLdcsststvtSkhI0Jo1a3Ts2DHZbDbl5uZ6vc709HTV19frwIEDRse9pgwbNkzJyckBPcCMQO7ACtXcAADgkszMTBUUFPRY+lrL3u233659+/bp+uuvD3BS6+nTp49mzpypPXv2dLhiunv3btXW1iorKyugmQwtfPX19Ro/fryWLl2qm2++WQsWLFBSUpJyc3O1aNEiSVJSUpLX6504caLsdruKi4uNjAsAAABYUk+lj7LnP1lZWWpubtb27dvbTS8oKFBMTIwefvjhgOYJN3JlWVlZOnr0qLZv366MjIy26atXr267snfHHXd4vd6oqCg98MADcjqd2rhxY8DueT116pTy8vI6nccIpQAAAAhmrYOytV5R2rBhg8LCwih7fjZmzBgNHz5cW7Zs0XPPPSdJOn36tPbt26e5c+fquuuuC2gewwrfgQMH9NZbbyk7O7td2ZOkxx9/XLm5uerTp48SExN9Wn96erqcTqcqKip09913GxG5R59++qny8/MDsi0AAADAaFeWvscee0yTJk2i7PlZVlaWnn32WR0+fFhjx47Vtm3b1NzcHPDbOSUDC9/69eslSQsXLuwwLyYmRpI0YsQI9erVq236yy+/rJdeekm1tbUaNWqU1q9fr9tvv73T9aelpSk8PFzFxcVdFr6jR4/2mNPlcvW4TKvU1FS9/fbbnc4rKyvTvffea+j2fFk+0LrLF6rZye0fwZ4PAIBrxW233aalS5cqPz9fmzdv1j/+4z9qxYoVOnnypNnRQoa35zUZGRl6/vnnVVBQoLFjx2rLli1KSkry+m7HnrabnJzc4zoMK3ylpaUaOnSohgwZ0mHeF198Ian983tvvvmmnn/+eb3++usaOXKkfvGLXyg1NVUnT57UDTfc0GEdMTExSkxMVEVFRZcZRo4cacCeGOvKq51GaL2ltbtRl1rnGX3769Xsj5m5Jd+zk9s3/jj2AQDA1bl48aKqqqp0zz33mB3F0gYMGKC0tDTt3LlT06dP1yeffKJ169Z5vZ6ezqc8eX+iIYXv7Nmzqq+v16hRozqdX1paKqn983tr165Vdna2HnvsMUnSpk2bFBcXpzfffLPTl5nX1tbK5XJ1O8pnZWVlj1ldLldAT0QLCwvlcDg8Xt6TfNHR0ZKkr7/+ustl6urq2i1rlO72p6fsZuaWus5O7sDmBgAAgfXHP/5RP/nJTzRw4MC2q3rp6elatGhRQN8HF8p86RBPPvmkioqKlJmZKbvdrlmzZnm9XSPOpwwpfK3Dt585c6bDvKamJq1atUrS367wNTU16dixY3rhhRf+FiQ8XCkpKTp06FCnhW/Xrl1qaWnR1KlTu8zhySXNQHM4HIbnSkxMVO/evXXkyBE1NzcrPLzjl/HQoUOSLl3CN9LV7I+ZuSXfs5PbN/449gEAgHcOHTqkZ555RklJSVqxYoXuuecevfDCC1q2bJliY2PbBnKB8VJTUzVw4EB9/vnnmjlzpvr37+/1Oow4nzLkqxsVFaVBgwapqqpKVVVVbdMbGxuVmZkpl8ulsLAwjRgxQtKlqwoXL17U3//937dbz4033qjTp093uo2ioiLddNNNGjNmjBGRQ5rdbteMGTP01Vdf6cUXX+wwv6qqSps2bVLfvn27LciBRu7ACtXcAADAGFeOxtn6YvUpU6Z49J4+XJ1evXqppKRExcXFWrFihWk5DHuGLycnR/Pnz9e4ceM0c+ZM2e12OZ1OJSQkyG63a8iQIW0HmbfOnTungwcPavbs2bLZbEZFDmlr1qzR4cOHlZ+fr927d2v8+PGy2+06efKknE6n3G63duzYoX79+rV95uOPP9bKlSslSd9//33btNbRmyRp69at5Ca36bkBAMDV6enVC129sgHGGjVqVJePvQWKYYVv3rx5Onv2rF577TUVFBQoISFBc+bM0UMPPaRbb7213fN7sbGx6tWrl2pra9ut48svv1RcXFyHde/Zs0cXLlzgKsRlbrzxRh05ckRr165VSUmJNm7cqKamJsXFxWnatGnKycnp8JL706dPa9u2be2m1dbWtpvm7xN5cpMbAAD4l6fv2aP0XRsMK3w2m01LlizRkiVL2k0vKiqS1H6Ezt69eyspKUkHDhzQgw8+KElqbm5WWVlZp7eeFRcXq3///kpJSTEqbrcGDx7c44g3KSkpHo2K40/R0dHKy8vr8uXwVwqGzBK5Ay1UcwMAAN+88cYbHr9nr7X05eTk6J//+Z87HXEfPfOkP1zu/PnzfkzTnmGFrysnTpyQpA7vnPjZz36mJ598UiNHjlRycrJWr16t8PBwPfroo+2WO3/+vPbt26f09PROB50AAAAA8Detd/RERUV5tHxmZqYefvjhdo94wDr83qCOHz8uSR1uG3v00Uf11VdfafHixW0vXt+/f3+Hd/CVl5fLbrdr2rRp/o4KAAAAhLyIiIi2UfQ9RdmzroBc4Rs4cKBiY2M7zFuwYIEWLFjQ7efvv//+tneFAQAAAAA851Pha32WzpO/BFRXV/uyCQAAAADAVfK58AVqABUAAAAAgG8YdxUAAAAALIrCBwAAAAAWdc2+58DlcgX1+v2dz1ve5AnV7OQ2RrDlAQAAMEqgznOM3M41V/hiY2MVGRmpjIwMv28rMjKy09FJuxPIfN7qaX9CNTu5jefLsQ8AABCszDjvMup8yub25pXwFlFTUxOQVz3ExsYqPj7e688Zlc/lcikjI0OFhYVyOBxXvT5P9idUs5M78McKAAAIrKNHj2rkyJGqrKxUcnKy2XFCTqA6RCujzqeuuSt8khQfHx/UJ6NG53M4HAH7pg7V7OS+JJDHCgAAQCgJ9g7RFQZtAQAAAACLovABAAAAgEVR+AAAAADAoih8AAAAAGBRFD4AAAAAsCgKHwAAAABYFIUPAAAAACyKwgcAAAAAFkXhAwAAAACLovABAAAAgEVR+AAAAADAoih8AAAAAGBR4WYHAIBWNTU1qqur8/t2YmNjFR8f7/XnApXPW57sT6hmD9XcAADrCfTvJKN+11D4AASFmpoaORwONTQ0+H1bkZGRcrlcXv0QDWQ+b/W0P6GaPVRzAwCsx4zfSUb9rqHwAQgKdXV1amhoUGFhoRwOh9+243K5lJGRobq6Oq9+gAYqn7c82Z9QzR6quQEA1hPo30lG/q6h8AEIKg6HQ8nJyWbH6FKw5+tOqGYP1dwAAOsJxd9JDNoCAAAAABZF4QMAAAAAi6LwAQAAAIBF+VT48vLyZLPZVF1dbXAcAAAAAIBRgv4K3/79+2Wz2bRz506zowAwWXV1tWw2myZOnNjlMmVlZbLZbMrOzg5gsvbbzszM9GqZ48ePa/HixUpNTdWAAQNks9mUkpLi97zdZfJkGXIDAHBJ6zmKzWZTXFycmpubO13O5XK1LTd48OCAZAv6wjdhwgRFR0erpKTE7CgA4BclJSVasWKFysrKFBcXZ3Ycj5EbAGCkDz/8UAsXLlRLS4tHy3///feaO3euamtr/ZzMc+Hh4aqtrdXevXs7nb9582aFhYUpLCxwNSzoC19ERIQmT56svXv3qrGx0ew4AGC46dOnq7KyUt9++63effdds+N4jNwAACOdOHFCq1ev1ty5c3ssfd9//72mTJmiX//61zp16lSAEvbsrrvuUnR0tAoKCjrMa25uVmFhoe677z5FREQELJPhha+hoUHLly/XLbfcIrvdroSEBK1Zs0bHjh2TzWZTbm6u1+tMT09XfX29Dhw4YHRcADDdsGHDlJycHNAf/kYgNwDASLNmzVJBQYHeeOONbktfa9mrqKjQnj179KMf/SjASbvWp08fzZw5U3v27NGXX37Zbt7u3btVW1urrKysgGYytPDV19dr/PjxWrp0qW6++WYtWLBASUlJys3N1aJFiyRJSUlJXq934sSJstvtKi4uNjIuAAAAgCCSmZnZbem7suwF4zPYWVlZam5u1vbt29tNLygoUExMjB5++OGA5gk3cmVZWVk6evSotm/froyMjLbpq1evbruyd8cdd3i93qioKD3wwANyOp3auHFjQO95DVWnT5/WqlWrJEnr16/XK6+8oqioKJNTAcY4deqU8vLyOp3H6MEAAIS21oG2Wq+EbdiwQWFhYSFR9iRpzJgxGj58uLZs2aLnnntO0qVz83379mnu3Lm67rrrAprHsMJ34MABvfXWW8rOzm5X9iTp8ccfV25urvr06aPExESf1p+eni6n06mKigrdfffdRkS2rLq6Oo0cObLtAdatW7fqww8/VHl5uXr37m1yOuDqffrpp8rPzzc7BgAA8JMrS99LL72khx9+OOjLXqusrCw9++yzOnz4sMaOHatt27apubk54LdzSgYWvvXr10uSFi5c2GFeTEyMJGnEiBHq1auXJKmoqEgbNmxQZWWl/vrXv+qzzz7rdmjStLQ0hYeHq7i4uMvCd/To0avcC2vYvHmzTp8+3XYJvKWlRf/93/+tV155RRMmTDA5nWdcLle7/w0V5L76DJ5ITU3V22+/3em8srIy3XvvvYZuz5flA627fKGaPVRzA0CwCobf99647bbbtHTpUuXn5+s//uM/9N1332ndunW64YYbAn7e7+2/WUZGhp5//nkVFBRo7Nix2rJli5KSkry+27Gn7SYnJ/e4DsMKX2lpqYYOHaohQ4Z0mPfFF19Iav/83nfffadx48bpoYce0vz583tcf0xMjBITE1VRUdHlMiNHjvQh+bXDlwFzzHbl1eJQQe7g5499bb3dvLuRxVrnGX1r+tXsj5m5Jd+zh2puADBbKP78+utf/ypJmjNnjslJPDNgwAClpaVp586dmj59uj755BOtW7fO6/X09LVyu909rsOQwnf27FnV19dr1KhRnc4vLS2V1P75vX/6p3+SdOl9G56ora2Vy+XqtrRUVlZ6mNja9u/fr8WLF3eYXlhYKIfDYUIi77lcLmVkZIRUZoncRmQIFG/31ZN80dHRkqSvv/66y2Xq6uraLWuU7vanp+xm5pa6zh6quQEgWAXD73tvnD9/Xs8++6yOHTumpqYmSZce81q0aFHAx/Tw5TzlySefVFFRkTIzM2W32zVr1iyvt2vE18qQwtc6tPWZM2c6zGtqamobPMSXETpb7dq1Sy0tLZo6dWqXy3hySfNakJSUpC+++KLtrwhhYWF6+eWXfTrIzOZwOELy60ru4OePfU1MTFTv3r115MgRNTc3Kzy844/YQ4cOSbp0m4qRrmZ/zMwt+Z49VHMDgNlC4edX6wAtVVVVWrdunebMmaMXXnhBy5YtU2xsbNtALsEsNTVVAwcO1Oeff66ZM2eqf//+Xq/DiK+VIf9KUVFRGjRokKqqqlRVVdU2vbGxUZmZmXK5XAoLC9OIESN83kZRUZFuuukmjRkzxojIlmaz2fTKK6+oqqpKb7/9tv7nf/5HP/nJT8yOBVie3W7XjBkz9NVXX+nFF1/sML+qqkqbNm1S3759u/3jVaCRGwAQTK4cjbP1LsIpU6Z49J6+YNGrVy+VlJSouLhYK1asMC2HYc/w5eTkaP78+Ro3bpxmzpwpu90up9OphIQE2e12DRkyRJGRkT6t+9y5czp48KBmz54tm81mVGTLGz58uIYPH252DOCasmbNGh0+fFj5+fnavXu3xo8fL7vdrpMnT8rpdMrtdmvHjh3q169f22c+/vhjrVy5UtKlX3Kt01pHKJMujbZLbuvkBgB0rrNXL1w+QEtXr2wIVqNGjerysbdAMazwzZs3T2fPntVrr72mgoICJSQkaM6cOXrooYd06623+vT+vVZ79uzRhQsX+AstgKB344036siRI1q7dq1KSkq0ceNGNTU1KS4uTtOmTVNOTk6H29tPnz6tbdu2tZtWW1vbbpq/Cwi5A5sbANCRp+/ZC7XSZzbDCp/NZtOSJUu0ZMmSdtOLiookXd3ze8XFxerfv3/Qv28DgH8NHjy4x9GoUlJSPBqxyp+io6OVl5fX5cvhrxQMmSVyAwDM9ctf/tLj9+xdXvomTZqkhx9+2O/5uuPJOcrlzp8/78c07RlW+Lpy4sQJSepwhe/MmTOqqanRp59+Kkn66KOPdPbsWcXHx7e9t0+69I+xb98+paend/pAPgAAAIDQl5OTo8mTJ3s80FZmZqZGjBgR9APQmM3v1z6PHz8uqeMVPqfTqaSkJE2bNk2SNHnyZCUlJcnpdLZbrry8XHa7vW05AAAAANYTERHh9ajKI0eOZIyPHgTkCt/AgQMVGxvbbnpmZma7B+S7cv/997e9RwkAAAAA4DmfCl/rPbWXj3rWlerqal82AQAAAAC4Sj4XPgZQAQAAAIDgxvilAAAAAGBRFD4AAAAAsCjecwAgqLhcrqBev7/zecubPKGaPVRzAwCsJ1C/A4zcDoUPQFCIjY1VZGSkMjIy/L6tyMjIDiMH9ySQ+bzV0/6EavZQzQ0AsB4zficZ9buGwgcgKMTHx8vlcgXkNSyxsbGKj4/36jNG5nO5XMrIyFBhYaEcDsdVr6+n/QnV7KGaGwBgPYE8T2ll1O8aCh+AoBEfHx/UJ9FG53M4HEpOTjZsfd0J1eyhmhsAYD3Bfp7SFQZtAQAAAACLovABAAAAgEVR+AAAAADAoih8AAAAAGBRFD4AAAAAsCgKHwAAAABYFIUPAAAAACyKwgcAAAAAFkXhAwAAAACLovABAAAAgEVR+AAAAADAoih8AAAAAGBR4WYHAADgWlFTU6O6ujq/byc2Nlbx8fFefy5Q+bzV0/6Eam4ACAQKHwAAAVBTUyOHw6GGhga/bysyMlIul8urshHIfN7qbn9CNTcABAqFDwCAAKirq1NDQ4MKCwvlcDj8th2Xy6WMjAzV1dV5VTQClc9bPe1PqOYGgECh8AEAEEAOh0PJyclmx+hSsOfrSqjmBgB/Y9AWAAAAALAoCh8AAAAAWBSFDwAAAAAsyqfCl5eXJ5vNpurqaoPjAAAAAACMEvRX+Pbv3y+bzaadO3eaHQUAAL+qrq6WzWbTxIkTu1ymrKxMNptN2dnZAUzWftuZmZleLXP8+HEtXrxYqampGjBggGw2m1JSUvyet7tMnixjdm4AMELQF74JEyYoOjpaJSUlZkcBAAA+KCkp0YoVK1RWVqa4uDiz43gsVHMDwOWCvvBFRERo8uTJ2rt3rxobG82OAwAAvDR9+nRVVlbq22+/1bvvvmt2HI+Fam4AuJzhha+hoUHLly/XLbfcIrvdroSEBK1Zs0bHjh2TzWZTbm6u1+tMT09XfX29Dhw4YHRcAADgZ8OGDVNycrIiIiLMjuKVUM0NAJcz9MXr9fX1mjBhgj744ANNmDBBU6dO1alTp5Sbm6sHHnhAkpSUlOT1eidOnCi73a7i4mL9+Mc/NjIyAAAAAFiWoYUvKytLR48e1fbt25WRkdE2ffXq1W1X9u644w6v1xsVFaUHHnhATqdTGzduVFhY0N+JCh+53W7t3r1bb7/9tiSpqanJ5ESAsS5cuKDf/va3kqSDBw8qKSlJNpvN5FQINqdOnVJeXl6n8xghGwDgDcMK34EDB/TWW28pOzu7XdmTpMcff1y5ubnq06ePEhMTfVp/enq6nE6nKioqdPfddxsRGUHomWee0auvvqpevXpJkp588kl98MEH6tOnj8nJgKvX1NSk++67T+Xl5ZKk3NxcffTRR9q8eTOlD+18+umnys/PNzsGAMACDCt869evlyQtXLiww7yYmBhJ0ogRI9pO5FesWKH//M//1CeffKLIyEiNHz9eq1at0uDBgztdf1pamsLDw1VcXNxl4Tt69KgBewKznDhxQq+++qok6eLFi5Kkjz76SM8//3y3Q2kHE5fL1e5/Q0Wo5g41O3fubCt7rbZs2aLRo0dr7NixJqXyTqgeK8GQ25ttp6amtt3pcKWysjLde++9hm7Pl+UDrat8oZobMEMw/Cz0RajmDoTk5OQelzGs8JWWlmro0KEaMmRIh3lffPGFpPbP773//vuaP3++Ro8ercbGRuXm5mrSpEmqqqpSeHjHWDExMUpMTFRFRUWXGUaOHGnAniDYrFu3TuvWrTM7hleuvModKkI1d6h7+umnzY7gtVA9VkI1ty/8sa+tj1S0tLR0uUzrPKMfv7ia/QnV3IC/hOpxGaq5/cntdve4jCGF7+zZs6qvr9eoUaM6nV9aWiqp/fN7V/7l8o033lBCQoI++ugj3XbbbR3WUVtbK5fL1e0on5WVlT6kR7A4ceKEsrKyOkyfP39+SF3hy8jIUGFhoRwOh9lxPBaquUPNzp079Ytf/KLD9F/96lchdYUvFI+VYMjdmiFQvN1XT/JFR0dLkr7++usul6mrq2u3rFG62p9QzQ2YIRh+FvoiVHMHC0MKX+twxWfOnOkwr6mpSatWrZLU/Qid586dk/S32z+vtGvXLrW0tGjq1KldrsOTS5oIXsnJyTp69KheffVVhYeHq7m5WaNHj9a//uu/htwzfA6HIySPx1DNHSqGDx+uP/zhDyovL1evXr108eJFZWVlKTs7O+Se4QvVYyVUc/vCH/uamJio3r1768iRI2pubu70jpxDhw5JUqd/vL0aV7M/oZob8JdQPS5DNbfZDLlvISoqSoMGDVJVVZWqqqrapjc2NiozM1Mul0thYWEaMWJEp5+/ePGicnJy9OMf/1g//OEPO12mqKhIN910k8aMGWNEZASpV155RU6nU/n5+SooKFB5eXnIlT2gK71799aBAwe0detWLVu2TEVFRdq0aVPIlT1cu+x2u2bMmKGvvvpKL774Yof5VVVV2rRpk/r27dvtH2gDLVRzA4ARDHuGLycnR/Pnz9e4ceM0c+ZM2e12OZ1OJSQkyG63a8iQIYqMjOzwObfbrezsbNXU1Oj3v/99p+s+d+6cDh48qNmzZ3NiZHE2m01paWlKS0szOwrgFxEREXr88cfNjgH4bM2aNTp8+LDy8/O1e/dujR8/Xna7XSdPnpTT6ZTb7daOHTvUr1+/ts98/PHHWrlypSTp+++/b5t2+e36W7duJTcA+IFhhW/evHk6e/asXnvtNRUUFCghIUFz5szRQw89pFtvvbXT9++53W49/fTTKi0t1e9+9zsNGDCg03Xv2bNHFy5c4K9uAACY7MYbb9SRI0e0du1alZSUaOPGjWpqalJcXJymTZumnJycDo9wnD59Wtu2bWs3rba2tt00fxenUM0NAFfLsMJns9m0ZMkSLVmypN30oqIiSR2f33O73Zo3b5727Nmj999/XzfffHOX6y4uLlb//v2VkpJiVFwAAILO4MGDexxxLSUlxaNR2fwpOjpaeXl5Xb4c/krBkFkK3dwAcDUMK3xdOXHihCR1uMI3b948/du//Zt++9vfqk+fPjp9+rSkS4O29O7du2258+fPa9++fUpPT+/0IWsAAAAAQOf83qCOHz8uqeMVvg0bNkiS7rnnnnbT33vvvXZX8srLy2W32zVt2jS/5gQAAAAAqwnIFb6BAwcqNja23XRPb5G4//77296NAwAAAADwnE+Fr/UK3OUjWXWlurral00AAAAAAK6Sz4WPAVQAAAAAILgZ8uJ1AAAAAEDwofABAAAAgEVR+AAAAADAonixHQAAAeRyuYJ6/f7O5y1P84RqbgDwNwofAAABEBsbq8jISGVkZPh9W5GRkR1eh9STQObzVnf7E6q5ASBQKHwAAARAfHy8XC5XQN4tGxsbq/j4eK8+Y2Q+l8uljIwMFRYWyuFwXPX6utufUM0NAIFC4QMAIEDi4+ODugAYnc/hcCg5Odmw9XUlVHMDQCAwaAsAAAAAWBSFDwAAAAAsisIHAAAAABZF4QMAAAAAi6LwAQAAAIBFUfgAAAAAwKIofAAAAABgURQ+AAAAALAoCh8AAAAAWBSFDwAAAAAsisIHAAAAABZF4QMAAAAAiwo3OwAAAADaq6mpUV1dnd+3Exsbq/j4eK8/F6h83vJ1fwAro/ABAAAEkZqaGjkcDjU0NPh9W5GRkXK5XF6VpEDm85Yv+wNYHYUPAAAgiNTV1amhoUGFhYVyOBx+247L5VJGRobq6uq8KkiByuctX/cHsDoKHwAAQBByOBxKTk42O0aXgj0fgEsYtAUAAAAALIrCBwAAAAAW5VPhy8vLk81mU3V1tcFxAAAAAABGCforfPv375fNZtPOnTvNjgIAAGC66upq2Ww2TZw4sctlysrKZLPZlJ2dHcBk7bedmZnp1TLHjx/X4sWLlZqaqgEDBshmsyklJcXveQGrC/rCN2HCBEVHR6ukpMTsKAAAAPCTkpISrVixQmVlZYqLizM7Dkxw4cIF/fGPf/TqM5WVlXK73X5KZA1BX/giIiI0efJk7d27V42NjWbHAQAAgB9Mnz5dlZWV+vbbb/Xuu++aHQcmWL16te68806VlZV5tPzWrVs1evRo7dq1y7/BQpzhha+hoUHLly/XLbfcIrvdroSEBK1Zs0bHjh2TzWZTbm6u1+tMT09XfX29Dhw4YHRcAAAABIFhw4YpOTlZERERZkeBSX7605/qrrvu0uTJk3ssfVu3blVWVpZmz56tKVOmBCZgiDK08NXX12v8+PFaunSpbr75Zi1YsEBJSUnKzc3VokWLJElJSUler3fixImy2+0qLi42Mi4AAACAINGnTx85nc4eS9/lZW/Dhg0KCwv6mxZNZeiL17OysnT06FFt375dGRkZbdNXr17ddmXvjjvu8Hq9UVFReuCBB+R0OrVx40a+qAhKX331lQ4fPixJam5uNjkNYLzq6mpVVFSYHQNB7uLFi6qqqpIkff311yansbZTp04pLy+v03mMpI5Q1Vr6pkyZosmTJ2vPnj264YYb2uZT9rxnWOE7cOCA3nrrLWVnZ7cre5L0+OOPKzc3V3369FFiYqJP609PT5fT6VRFRYXuvvtuIyIDhvnd736ntLQ0ffPNN5Kk2bNn67/+67/Ut29fk5MBxti0aZOys7N18eJFSdKyZctUXFwsm81mcjIEk4aGBj344IN67733JElTpkyR0+nU/fffb3Iya/r000+Vn59vdgzAcFeWvrVr10qSnE6nli1bRtnzkmH/SuvXr5ckLVy4sMO8mJgYSdKIESPUq1cvSdLatWs1bNgwXX/99erXr58mTJjQdnWkM2lpaQoPD+e2TgSd77//XlOnTtW3337bNu3DDz/s9HsBCEUfffSR5syZ01b2JGnXrl0qKCgwMRWC0dKlS/X++++3/f/z58/rkUceaftjGIyVmpoqt9vd6X+tpRsIVZff3rlgwQJJouz5yLArfKWlpRo6dKiGDBnSYd4XX3whqf3ze4MGDdJLL72koUOHqrGxUb/85S+VmpqqTz/9VH/3d3/XYR0xMTFKTEzs9naio0ePGrAngHc+++wznTlzpt20lpYWHTx4MGSOSZfL1e5/gcvt3btXLS0t7ab16tVLe/fu9em5bDNwjAdGaWlph2Olvr5eu3fv1q233mpSKs8Fy3ES6O17u72elm89Eb/yWLhc6zx/nLSb/fULZsFyjHsjPz9fM2bM0Oeff67bb79ds2fP1vHjx82OFTSSk5N7XMaQwnf27FnV19dr1KhRnc4vLS2V1P75vfT09HbLrF69Wm+88YY+/PBDjR8/vsM6amtr5XK5uh3lc+TIkT6kB/zj5MmTIXdMXnk7NtCVixcvqqioSEVFRWZH8QrHuDlmzZpldgSvXGvHidH7Gx0dLan7Zzjr6uraLWuka+3r54tQ/Tc6fvy4Ro8ebXaMoOLJOwgNKXytw+deeZVDkpqamrRq1SpJXY/Q2dTUpNdff139+/fXiBEjOl1m165damlp0dSpU7vMUVlZ6W10wBBr1qzRm2++KUmy2WwKCwvTpk2bdNttt5mczDMul0sZGRkqLCyUw+EwOw6CTHNzs7Kzs3X8+HG53W6FhYWpb9+++s1vfqMBAwaYHc8jHOOB8fHHHyszM1PNzc1tJyFTp07VkiVLTE7mmWA5TlpzBIq3+9tTvsTERPXu3VtHjhxRc3OzwsM7nm4eOnRIkvzye9Lsr18wC5Zj3FOtz+ylpaVpypQpeu211/Thhx/q5Zdf7vJCEzoypPBFRUVp0KBBqqqqUlVVVVtpa2xs1BNPPCGXy6WwsLAOZa68vFyTJk3S999/r7i4OL377rttz/tdqaioSDfddJPGjBnTZQ5PLmkC/lBYWKh77rlHBw8e1PXXX6+nn346JH8QORwOvo/QqYqKCq1cuVJVVVX6wQ9+oEWLFmngwIFmx/Iax7h/JScna/jw4Xr55Zf1zTffaNy4cZo3b17IPWtzrR0nRu+v3W7XjBkzVFhYqBdffLHDSKJVVVXatGmT+vbt2+0f8n11rX39fBEK/0Zbt27t8Mzeo48+qilTpuhnP/uZ9uzZo5SUFLNjhgTDnuHLycnR/PnzNW7cOM2cOVN2u11Op1MJCQmy2+0aMmSIIiMj231m1KhROn78uL7++mu98cYbmjFjhg4fPqzY2Nh2y507d04HDx7U7NmzGREOQclmsyk7O1vZ2dlmRwH8wm63dzn8O3C52267TZs3bzY7Bky2Zs0aHT58WPn5+dq9e7fGjx8vu92ukydPyul0yu12a8eOHerXr1/bZz7++GOtXLlS0qUB0VqnZWZmti2zdevWAO4FzNLVqxc6e2UDpa9nhhW+efPm6ezZs3rttddUUFCghIQEzZkzRw899JBuvfXWTt+/16dPHw0dOlRDhw7V2LFj9Q//8A/asmVLh+f09uzZowsXLvjlr0AAAAAw1o033qgjR45o7dq1Kikp0caNG9XU1KS4uDhNmzZNOTk5HR71OX36tLZt29ZuWm1tbbtpFD7r6+k9e5Q+7xlW+Gw2m5YsWdLhPv3WB/o9GcnN7XarsbGxw/Ti4mL179+fLyYAALjmDR48uMeBGlJSUjwazMGfoqOjlZeX5/HdAcGQGebasWOHRy9Vv7L0vfPOO/rRj34U4LShw+831Z84cUKSOlzhe/755/X73/9ef/7zn3Xs2DHNnj1b//u//6tHHnmk3XLnz5/Xvn379OCDD3b60C8AAACA0Hf77bcrJyfHo/fstZa+xx57TEOHDg1QwtDk9wbV+p6MK6/w/d///Z9mzpypL7/8UjExMRo9erTKy8s7jBhUXl4uu92uadOm+TsqAAAAAJMMHz68bXR/T/Tp00cbNmzwYyJr8HvhO3HihAYOHNhhIJbt27d79Pn777+/7V0tAAAAAADP+VT4Wp+lu3xkpa5UV1f7sgkAAAAAwFXyufAxgAoAAAAABLfQehMqAAAAAMBjFD4AAAAAsCgKHwAAAABYFC+2AwAACEIulyuo1+/vfN4KtjxAsKDwAQAABJHY2FhFRkYqIyPD79uKjIzs8OqsngQyn7d82R/A6ih8AAAAQSQ+Pl4ulysg7yGOjY1VfHy8V58xMp/L5VJGRoYKCwvlcDiuen2+7A9gdRQ+AACAIBMfHx/UxcXofA6HQ8nJyYatD8DfMGgLAAAAAFgUhQ8AAAAALIrCBwAAAAAWReEDAAAAAIui8AEAAACARVH4AAAAAMCiKHwAAAAAYFEUPgAAAACwKAofAAAAAFgUhQ8AAAAALIrCBwAAAAAWReEDAAAAAIsKNzsAAAAAYKaamhrV1dX5fTuxsbGKj4/3+3aAy1H4AAAAcM2qqamRw+FQQ0OD37cVGRkpl8tF6UNAUfgAAABwzaqrq1NDQ4MKCwvlcDj8th2Xy6WMjAzV1dVR+BBQFD4AAABc8xwOh5KTk82OARiOQVsAAAAAwKIofAAAAABgUT4Vvry8PNlsNlVXVxscBwAAAABglKC/wrd//37ZbDbt3LnT7CgAAAC4BlVXV8tms2nixIldLlNWViabzabs7OwAJgN6FvSFb8KECYqOjlZJSYnZUQAAAICgd+HCBX333Xdefebs2bP+CQPTBX3hi4iI0OTJk7V37141NjaaHQcAAAAIanPmzNHEiRP17bfferT81q1bNXToUH322Wd+TgYzGF74GhoatHz5ct1yyy2y2+1KSEjQmjVrdOzYMdlsNuXm5nq9zvT0dNXX1+vAgQNGxwUAAAAsZfbs2Tpx4oQmTZrUY+nbunWrsrKy9Mgjj2jQoEEBSohAMrTw1dfXa/z48Vq6dKluvvlmLViwQElJScrNzdWiRYskSUlJSV6vd+LEibLb7SouLjYyLgAAAGA5d955p/bv399j6Wste7Nnz9aGDRsUFhb0N//BB4a+eD0rK0tHjx7V9u3blZGR0TZ99erVbVf27rjjDq/XGxUVpQceeEBOp1MbN27kYAQM1tDQYHYEwG/cbre++eYbs2MgBFy8eFGS1NLSYnKSa0Mofm+eOnVKeXl5nc4LttHrW0tfamqqJk2apH379rWbT9m7hrh98MILL7gluT/77LO2aaWlpW5J7uzs7A7Lf/nll25J7j59+ribm5t92aR769atbknu8vJynz4PoKNvvvnG/eCDD7oluSW5x44d6z5z5ozZsQDD/OlPf3IPHz687RifMWOGz7+HYG0FBQXuiIgItyT3DTfc4H733XfNjmRpwfS9WVlZ6Zbkrqys7HKZzz77rC1rT//NmTPH5+34Q0VFhbtv377uu+++211eXu6W5H7hhRfcNpvN/dRTT7kvXrwY0DwIPMOq/Pr16yVJCxcu7DAvJiZGkjRixAj16tWrw/y5c+fKZrPp1Vdf7XL9aWlpCg8P57ZOwEBPPfVUu7/4HTlyRE888YSJiQDjNDc3a9KkSXK5XG3T/v3f/10rV640MRWCUVlZmZ588klduHBB0qVHVNLS0vSnP/3J5GTWFMrfm6mpqXK73Z3+995775kdr1OX3945f/58SdKyZcu4sncNMeyWztLSUg0dOlRDhgzpMO+LL76Q1Pnze7t379ahQ4d00003dbv+mJgYJSYmqqKiostljh496mVq4Nq2a9eutluYpEu3Me3Zs0cffPABvwAQ8v7yl7/ok08+6TB9x44dmjRpkgmJEKy2bNmisLCwtp+Hbrdb58+f169//WtNmTLF5HTWE2zfm5cXTytuT5Kuu+46vfLKK3rqqackSXfffbdmz56t48ePBzwLjJWcnNzjMoYUvrNnz6q+vl6jRo3qdH5paamkjs/v1dbWau7cudq7d6/S0tK63UZtba1cLle3o3yOHDnSu+AAOmhubtbo0aPNjgH4jcvl4vcFPJKfn6/8/HyzY1wzrpXvzcvHuTBLeXk5v+stwu1297iMIYUvIiJCknTmzJkO85qamrRq1SpJHa/wPfHEE3rmmWc0YsSIHrexa9cutbS0aOrUqV0uU1lZ6U1s4Jr3q1/9Sps3b243bdasWXr22WdNSgQYx+12a/78+Tp8+HC7QThefPFFrvChnc8++0yzZs1SU1OT3G63wsLCFBMTo9/85jfq16+f2fEsJ9i+N10uV0BLWGFhoRwOR8C2J0lOp1PLli1TWlqabr/9dq1Zs0a33HKL1q1bp8jIyIBmQeAZUviioqI0aNAgVVVVqaqqqq3ANTY26oknnpDL5VJYWFi7Yvfqq6/qu+++03PPPefRNoqKinTTTTdpzJgxXS7jySVNAH/z+uuva9CgQdq2bZtaWlr06KOPKi8vT+Hhhg7gC5jmnXfe0U9/+lO98847uv7667Vw4UJlZmaaHQtBJjk5WT/84Q/1zDPP6C9/+YuGDRumjRs3KiEhwexolnUtf286HI6AnrNu3bq1wzN7kyZNUmpqqhYtWqR9+/bp+uuvD1geBJ5hZ3U5OTmaP3++xo0bp5kzZ8put8vpdCohIUF2u11Dhgxp+wvCxx9/rOXLl+vw4cMePSd07tw5HTx4ULNnz5bNZjMqMnDNCwsL089//nP9/Oc/NzsK4BfXX3+9Nm3aZHYMhICxY8fq8OHDZse4ZvC9GRhdvXqhs1c2UPqsy7BRGebNm6fly5crKipKBQUFevvttzVnzhy9+uqrOn/+fLvn9/7whz/oq6++0tChQxUeHq7w8HD9+c9/1oIFCzp9T9+ePXt04cKFbm/nBAAAAHBJT+/Z8/Tl7Ah9hl3hs9lsWrJkiZYsWdJuelFRkaT2z+89/PDDHQZ4SU1NVWZmZqdDwhcXF6t///5KSUkxKi4AAADgkcGDB/c4OEZKSopHA2gEgqcvVedK37XB7w/qnDhxQlL7ETr79evX4SHoiIgI/eAHP9DQoUPbTT9//rz27dun9PR0nisCAAAAevD55597/J691tL37LPPqqGhgcJnQX5vUK3v9+jsHXyeKC8vl91u17Rp0wxMBQAAAFjT//t//09ut9vjsS/uvPNOVVRUMFaGRQXkCt/AgQMVGxvb7XLV1dWdTr///vtVV1fnh2QAAACANXlb3ih71uVT4Wt9ls6Td9N0VeQAAAAAAP7lc+FjABUAAAAACG6GvZYBAAAAABBcKHwAAAAAYFEUPgAAAACwKF5sBwAAgGuey+UK6fUDXaHwAQAA4JoVGxuryMhIZWRk+H1bkZGRPb6qDDCaze12u80OAQAAAJilpqYmIO99jo2NVXx8vN+3A1yOwgcAAAAAFsWgLQAAAABgURQ+AAAAALAoCh8AAAAAWBSFDwAAAAAsisIHAAAAABZF4QMAAAAAi6LwAQAAAIBFUfgAAAAAwKIofAAAAABgURQ+AAAAALAoCh8AAAAAWBSFDwAAAAAsisIHAAAAABZF4QMAAAAAi6LwAQAAAIBF/X+4jBSAIpDU0wAAAABJRU5ErkJggg==", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "ax, fig = plot(c)" - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "id": "17bdbe2f-77c9-4b60-bd0e-ed7efdf20a17", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─U───\n", - "q1: ─|───\n", - "q2: ─U─U─\n", - "q3: ─U───\n", - "q4: ───U─\n", - "q5: ─────\n" - ] - } - ], - "source": [ - "c = models.Circuit(6)\n", - "\n", - "c.add(gates.Unitary(np.random.random((8, 8)), 0, 2, 3))\n", - "c.add(gates.Unitary(np.random.random((2, 2)), 2))\n", - "c.add(gates.Unitary(np.random.random((2, 2)), 4))\n", + "custom_style = {\n", + " \"facecolor\" : \"#6497bf\",\n", + " \"edgecolor\" : \"#01016f\",\n", + " \"linecolor\" : \"#01016f\",\n", + " \"textcolor\" : \"#01016f\",\n", + " \"fillcolor\" : \"#ffb9b9\",\n", + " \"gatecolor\" : \"#d8031c\",\n", + " \"controlcolor\" : \"#360000\"\n", + "}\n", "\n", - "print(c.draw())" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "id": "832527e0-2734-4fd4-a20c-73a48f9b096f", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 17, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(c, cluster_gates = True)" + "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=custom_style)" ] }, { "cell_type": "code", - "execution_count": 18, - "id": "5763dbf9-7c12-44d5-8cf5-adf763b045d6", + "execution_count": 13, + "id": "0a2c8489", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "q0: ─M─\n", - "q1: ─M─\n", - "q2: ───\n" + "q0: ─[─H─U1───]─U1─U1─U1─────────────────────────────────────x───M─\n", + "q1: ─[───o──H─]─|──|──|──[─U1───]─U1─U1──────────────────────|─x─M─\n", + "q2: ────────────o──|──|──[─o──H─]─|──|──[─U1───]─U1──────────|─|───\n", + "q3: ───────────────o──|───────────o──|──[─o──H─]─|──[─U1───]─|─x───\n", + "q4: ──────────────────o──────────────o───────────o──[─o──H─]─x─────\n" ] } ], "source": [ - "c = models.Circuit(3)\n", + "from qibo.models import QFT\n", + "c = QFT(5)\n", "c.add(gates.M(qubit) for qubit in range(2))\n", - "print(c.draw())" + "print(c.fuse().draw())" ] }, { "cell_type": "code", - "execution_count": 19, - "id": "bb9539ee-06d7-413b-8abb-164b8a57e9f8", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 19, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "plot(c)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "id": "5a14c98b-35e4-4ac8-9c9a-6eadf660f5e0", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─\n", - "q1: ─\n", - "q2: ─\n" - ] - } - ], - "source": [ - "c = models.Circuit(3)\n", - "print(c.draw())" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "id": "c7e1a83f-b24c-4308-b897-502d571d25fa", + "execution_count": 14, + "id": "63faa1ea", "metadata": {}, "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(,
)" - ] - }, - "execution_count": 21, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -532,7 +412,7 @@ } ], "source": [ - "plot(c)" + "ax, fig = plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\")" ] }, { @@ -560,7 +440,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.11.7" + "version": "3.11.3" } }, "nbformat": 4, From cce8a2b495785f9dfc7d3d496a8514e33f0028a1 Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 11:22:43 +0200 Subject: [PATCH 070/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index fdaeb1e439..b66ad0ea5f 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -557,9 +557,6 @@ def _make_cluster_gates(gates_items): if len(temp_mgates) > 0: cluster_gates.append(temp_mgates) - temp_gates = [] - temp_mgates = [] - return cluster_gates From 415c30e12e9bf979d096b11f93650c54d7b9502e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 11:23:02 +0200 Subject: [PATCH 071/116] review unused dead code on circuit drawing --- src/qibo/ui/FusedGateBarrier.py | 4 ++-- src/qibo/ui/mpldrawer.py | 25 ++++--------------------- 2 files changed, 6 insertions(+), 23 deletions(-) diff --git a/src/qibo/ui/FusedGateBarrier.py b/src/qibo/ui/FusedGateBarrier.py index 53381c55e1..f557476938 100644 --- a/src/qibo/ui/FusedGateBarrier.py +++ b/src/qibo/ui/FusedGateBarrier.py @@ -19,11 +19,11 @@ def __init__(self, q_ctrl, q_trgt, nfused, equal_qbits=False): self.nfused = nfused -class FusedGateEndBarrier(Gate): +class FusedEndGateBarrier(Gate): def __init__(self, q_ctrl, q_trgt): super().__init__() - self.name = "FusedGateEndBarrier" + self.name = "FusedEndGateBarrier" self.draw_label = "" self.control_qubits = (q_ctrl,) self.target_qubits = (q_trgt,) if q_ctrl != q_trgt else () diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index fdaeb1e439..ab4ce2816d 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -10,12 +10,9 @@ from qibo import gates -from .FusedGateBarrier import FusedGateEndBarrier, FusedStartGateBarrier +from .FusedGateBarrier import FusedEndGateBarrier, FusedStartGateBarrier -global STYLE STYLE = {} - -global SYMBOLS SYMBOLS = {} plot_params = { @@ -179,7 +176,7 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu name, target = gate[:2] - if "FUSEDGATEENDBARRIER" in name: + if "FUSEDENDGATEBARRIER" in name: return linewidth = plot_params["linewidth"] @@ -278,7 +275,7 @@ def _draw_controls(ax, i, gate, labels, gate_grid, wire_grid, plot_params, measu def _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params): name, target = gate[:2] - if "FUSEDSTARTGATEBARRIER" in name or "FUSEDGATEENDBARRIER" in name: + if "FUSEDSTARTGATEBARRIER" in name or "FUSEDENDGATEBARRIER" in name: return is_dagger = False @@ -415,20 +412,6 @@ def _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured={}): plot_params, ) - # Add the doubling for measured wires: - # dy = 0.04 # TODO: add to plot_params - # for i in measured: - # j = measured[i] - # _line( - # ax, - # gate_grid[j], - # gate_grid[-1] + scale, - # wire_grid[i] + dy, - # wire_grid[i] + dy, - # plot_params, - # ) - - def _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params): scale = plot_params["scale"] label_buffer = plot_params["label_buffer"] @@ -703,7 +686,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): FusedStartGateBarrier(min_q, max_q, l_gates, equal_qbits) ) all_gates += gate.gates - all_gates.append(FusedGateEndBarrier(min_q, max_q)) + all_gates.append(FusedEndGateBarrier(min_q, max_q)) else: all_gates.append(gate) From 20a8268af59c887dcb79431683a471a49d830860 Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 11:25:05 +0200 Subject: [PATCH 072/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 5 +---- 1 file changed, 1 insertion(+), 4 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index b66ad0ea5f..73122d68d4 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -568,10 +568,7 @@ def _build_path(filename): def _check_list_str(list, str): - for item in list: - if item in str: - return True - return False + return any(item in str for item in list) def _process_gates(array_gates): From 980318bc2d2aa19c641d3c38d7dd9e6603c4e71b Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 11:25:18 +0200 Subject: [PATCH 073/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 73122d68d4..c330319458 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -567,7 +567,7 @@ def _build_path(filename): return final_path -def _check_list_str(list, str): +def _check_list_str(substrings, string): return any(item in str for item in list) From 9d3f239587dc370336564a28b00b04325acc4cc2 Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 11:25:57 +0200 Subject: [PATCH 074/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index c330319458..2c949460e9 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -563,8 +563,7 @@ def _make_cluster_gates(gates_items): def _build_path(filename): file_path = path.abspath(__file__) # full path of current file dir_path = path.dirname(file_path) # full path of the directory from file - final_path = path.join(dir_path, filename) # absolute file path of given file - return final_path + return path.join(dir_path, filename) # absolute file path of given file def _check_list_str(substrings, string): From 106c4d718a1723178b8885149de6578f14b8fc2a Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 11:26:27 +0200 Subject: [PATCH 075/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 2 -- 1 file changed, 2 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 2c949460e9..d0f3e6fc54 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -12,10 +12,8 @@ from .FusedGateBarrier import FusedGateEndBarrier, FusedStartGateBarrier -global STYLE STYLE = {} -global SYMBOLS SYMBOLS = {} plot_params = { From 67776991d42faeb8f3501506f202ccce2ffd954a Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 11:39:35 +0200 Subject: [PATCH 076/116] review if clauses on gate clasification --- .../qibo-draw-circuit-matplotlib.ipynb | 255 ++++-------------- src/qibo/ui/mpldrawer.py | 11 +- 2 files changed, 51 insertions(+), 215 deletions(-) diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index 5ed83ef92f..fec8dc3687 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "markdown", - "id": "738e41db", + "id": "f3c96f32", "metadata": {}, "source": [ "## Matplotlib circuit drawing for Qibo" @@ -10,7 +10,7 @@ }, { "cell_type": "markdown", - "id": "7869858c", + "id": "e79c7a54", "metadata": {}, "source": [ "Qibo now uses matplotlib to draw circuit, this new feature is base on `plot` function, you can pass the Qibo circuit along a built-in or custom style among other options." @@ -18,7 +18,7 @@ }, { "cell_type": "markdown", - "id": "0bfdad51", + "id": "d54ec28a", "metadata": {}, "source": [ "Follow the examples below to learn how to use it." @@ -26,7 +26,7 @@ }, { "cell_type": "markdown", - "id": "805b65b1", + "id": "9fb3188e", "metadata": {}, "source": [ "The default function signature for `plot`:\n", @@ -47,7 +47,20 @@ "execution_count": 1, "id": "66e4921b-c1ea-479d-9926-d93a7c784be9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "expected ':' (mpldrawer.py, line 572)", + "output_type": "error", + "traceback": [ + "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", + "\u001b[0m File \u001b[0;32m~\\.conda\\envs\\qibo-env\\Lib\\site-packages\\IPython\\core\\interactiveshell.py:3508\u001b[0m in \u001b[0;35mrun_code\u001b[0m\n exec(code_obj, self.user_global_ns, self.user_ns)\u001b[0m\n", + "\u001b[0m Cell \u001b[0;32mIn[1], line 9\u001b[0m\n from qibo.ui import plot\u001b[0m\n", + "\u001b[1;36m File \u001b[1;32m~\\Desktop\\Optimizadores\\rotosolve\\qibo\\src\\qibo\\ui\\__init__.py:1\u001b[1;36m\n\u001b[1;33m from qibo.ui.mpldrawer import plot\u001b[1;36m\n", + "\u001b[1;36m File \u001b[1;32m~\\Desktop\\Optimizadores\\rotosolve\\qibo\\src\\qibo\\ui\\mpldrawer.py:572\u001b[1;36m\u001b[0m\n\u001b[1;33m else (\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m expected ':'\n" + ] + } + ], "source": [ "# General libraries\n", "import matplotlib.pyplot as plt\n", @@ -64,21 +77,10 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": null, "id": "eda54008", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─RY─o─o───o─────RY─o─o───o─────RY─o─o───o─────RY─M─\n", - "q1: ─RY─X─|─o─|─o───RY─X─|─o─|─o───RY─X─|─o─|─o───RY─M─\n", - "q2: ─RY───X─X─|─|─o─RY───X─X─|─|─o─RY───X─X─|─|─o─RY───\n", - "q3: ─RY───────X─X─X─RY───────X─X─X─RY───────X─X─X─RY───\n" - ] - } - ], + "outputs": [], "source": [ "nqubits = 4\n", "nlayers = 3\n", @@ -104,82 +106,30 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": null, "id": "ea99c3d4-e36f-46ca-81c4-c8f10d6bcbe5", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot(ansatz, scale = 0.6, cluster_gates = False)" ] }, { "cell_type": "code", - "execution_count": 4, + "execution_count": null, "id": "81b65ea2-06a0-437d-b8f3-2ac176ea9b25", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot(ansatz, scale = 0.7, cluster_gates = True)" ] }, { "cell_type": "code", - "execution_count": 5, + "execution_count": null, "id": "62d00656-b40d-44f1-b56a-6733eeed6759", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ──────o───o───────────o──X─M─\n", - "q1: ─H──X─|───o─o─x─si─fx─o──X─M─\n", - "q2: ─SX───CSX─X─X─x─si─fx─DE─────\n" - ] - } - ], + "outputs": [], "source": [ "c = models.Circuit(3)\n", "c.add(gates.H(1))\n", @@ -200,53 +150,20 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": null, "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjkAAACeCAYAAADQbRsSAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAw40lEQVR4nO3dfVzN9/8/8Me7Cx3RIslFSamhqVGu2kRpI9frysZctdKVmA+KtZmrtqHJQrR8VKi52KikpA8RbY2Uq2znMzYlvqY0IiKl1+8Pv85HOtU5p/e56Hjeb7dz223v9+u83o9T5/3u6fW+eHGMMQZCCCGEEDWjoewAhBBCCCHyQEUOIYQQQtQSFTmEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtQSFTmEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtQSFTmEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtQSFTmEEEIIUUtayg5ACCGEvE5KSkpQXl4ut/4NDQ1hamrKW3/yzvsqPvNTkUMIIYQoSElJCaysrFBVVSW3bejq6kIoFPJSKCgi76v4zE9FDiGEEKIg5eXlqKqqQmJiIqysrHjvXygUYubMmSgvL+elSJB33lfxnZ+KHEIIIUTBrKysYGdnp+wYEmtreevRhceEEEIIUUtU5BBCCCFELVGRQwghhBC1REUOIYQQQtSSTEXOqlWrwHEciouLeY5DCCGEEMIPlR/JyczMBMdx2Ldvn7KjEEIIIXK1ZcsWcByH2bNni11///59GBsbQ1dXF1evXlVwOvGKi4vBcRw4jkP37t1RW1srtp1QKBS1MzMzU0g2lS9ynJ2doa+vj5SUFGVHIYQQQuRq/vz5cHJyQkJCAg4dOtRofVBQEG7fvo1169ahb9++SkjYNC0tLZSWluLIkSNi18fGxkJDQwMaGoorPVS+yNHW1sbEiRNx5MgRVFdXKzsOIYQQIjccxyE+Ph4dO3aEn59fg+kUDhw4gL1792L06NFYsGCBElOK9+6770JfXx9xcXGN1tXW1iIxMRHvv/8+tLW1FZaJ9yKnqqoKYWFh6Nu3LwQCAfr06YOIiAhcuHABHMchJCRE6j7d3d1RWVmJrKwsvuMSQgghKsXMzAwREREoKytDYGAgAKC0tBSBgYHQ09NDfHw8OI5TcsrG2rdvj2nTpiE9PR1lZWUN1qWlpaG0tBTe3t4KzcTrE48rKyvh7OyM/Px8ODs7w83NDX/++SdCQkIwduxYAICtra3U/Y4bNw4CgQDJycmYMGECn5GJimGMIS0tDZcvX0aPHj0wY8YM6OjoKDuWRM6cOYNTp06hQ4cO+Oijj9C1a1dlRyKEoG3um35+fkhKShKN3uzbtw/l5eWIjY1F7969lR2vSd7e3oiJiUFCQgKWLFkiWh4XFwcDAwO4uroqNhCTwcqVKxkAVlRU1GC5p6cn09DQYAkJCQ2Wf/vttwwAA8B+++03WTbJpkyZwoyMjNjz589lej9pG+bPn88AMC0tLQaADR06lFVVVSk7VotiY2MZx3FMU1OTcRzHunXrxoqLi5Udi5DXnqrtmwUFBQwAKygoaLHtrVu3WKdOnZiOjg4DwCZNmsRr/5KQpL+ioiIGgLm4uDDGGLO2tmYDBgwQrf/777+ZlpYWW7BgAWOMMR0dHda7d2+F5OftdFVWVhYOHDgAPz8/zJw5s8G6OXPmAHgxlNWvXz+Z+nd3d0dZWRlyc3NbnZWoptzcXERFRQGA6Or8goICbN68WZmxWvTw4UMEBASAMYbnz5+DMYby8nIEBwcrOxohr7W2vm8aGxtj/vz5qK6uhra2NrZv367sSBLx9vbGb7/9hrNnzwIAdu3ahdraWoWfqgJ4PF21detWAMDSpUsbrTMwMAAA2NjYQFNTU7R806ZN2LhxI0pLSzFkyBBs3boVAwcOFNv/5MmToaWlheTkZDg4OIhtc/78+dZ+DKJEJ06caLSM4zjk5eWp9O+2qKgINTU1DZY9f/4cFy9eVOnchKg7Vdw3hUKhxG3LysoQExMDAKipqUFaWhp8fX153w7f/cycORPLli1DXFwchg8fjvj4eNja2mLQoEG8bVfiyUJlGf4Rd7pKT0+PWVpaim1/8+ZNBoD5+/uLlv3www9MR0eH7dq1i125coXNmTOHdevWjT148KDJ7Q4YMIDZ29s3uR7//5QYvehFL3rRi16q/JLkdIybmxsDwNatW8cMDQ2Znp4eu3HjRrPvqT/do8i8r56uYowxd3d39sYbb7Bjx44xAGzLli2idZKcrmrpJSleRnIqKipQWVmJIUOGiF1//PhxAGhQxX333XcICAgQPfBox44d6N69O/bs2YOAgIBGfZSWlkIoFDZ7d1ZBQUErPgVRBevXr8ePP/4IDQ0N1NXVwdzcHImJiRAIBMqO1qxDhw5hzZo14DgOjDG88cYb2LNnD3r06KHsaIS81lRt3xQKhY0u6RAnISEBycnJmDRpEpYtWwYzMzNMmzYNPj4+OHbsWIvvT0xMhJWVlcLyvsrHxwdJSUnw8vKCQCDAjBkzpHo/X/l5Gcl59OgRA8AGDhzYqG11dTWzsrJiANiZM2dEyzQ1Ndnhw4cbtPXw8GCzZ88Wu82YmJgGfRD1VFdXx1JTU9m8efMYAPbrr78qO5LEfv31V7ZgwQIGgB0/flzZcQgh/58q7ZuSXFhbf8GxgYEBu337tmi5p6cnA8C+//77VvXPd15xIzm1tbXM2NiYAWDTpk1r0L7NXXjcoUMH9O7dG4WFhSgsLBQtr66uhpeXF4RCITQ0NGBjYwMAKC8vx/Pnz9GtW7cG/RgZGeHOnTtit5GUlISePXti2LBhfEQmKorjOEyePBk+Pj4AgHbt2ik5keTs7e3h5eUFAOjcubNywxBCRNravunj44OKigpERUU1GHHatm0bunbtipCQENy4cUOJCVumqamJlJQUJCcnY+3atUrLwdvdVcHBwairq8OoUaMQGBiIRYsW4a233sLdu3chEAjQr18/6OrqytT3gwcPcOLECbi6uqrkA5AIIYQQPsTExCAzMxOenp6YPn16g3Vdu3ZFdHQ0Kisr4e3tDcaYklJKZsiQIXB1dVXYPFXi8FbkBAUFISwsDB06dEBcXByOHj0Kf39/REVF4enTpw2uxzE0NISmpiZKS0sb9FFWVobu3bs36js9PR01NTVwc3PjKy4hhBCiUoqKihAcHAwjIyNER0eLbePh4YHp06fjxIkTTbYh/8PbLeQcx2H58uVYvnx5g+VJSUkAGj7puF27drC1tUVWVhYmTZoE4MVzUbKzs/HVV1816js5ORmdO3eGk5MTX3EJIYQQlWJubo7KysoW2+3Zswd79uxRQCLJmJmZSTWq9PTpUzmmaYjXaR3EuXTpEgA0uj9+0aJF8PHxweDBg2FnZ4cNGzZAS0sLH3/8cYN2T58+RUZGBtzd3aGlJfe4hBBCCFETcq8aLl68CKDxnFUff/wx7t69i88//1z0MMDMzEy88cYbDdrl5ORAIBDA09NT3lEJIYQQokYUMpJjbGwMQ0PDRusWLlyIhQsXNvv+MWPGNJhqnhBCCCFEEjIVOfXXxnTq1KnFtsXFxbJsghBCCCGkVWQucugiYEIIIYSoMt5uISeEEEIIUSVU5BBCCCFELdE92YQQQoiCCYVC6lcB26EihxBCCFEQQ0ND6OrqyjSzt6R0dXXF3tEsC0XkfRWf+anIIYQQQhTE1NQUQqFQro9GMTQ0hKmpKS99KSLvq/jMT0UOIYQQokCmpqa8/RFXhLaW92V04TEhhBBC1BIVOYQQQghRS1TkEEIIIUQtUZFDCCGEELVERQ4hhBBC1BIVOYQQQghRS1TkEEIIIUQtUZFDCCGEELVERQ4hhBBC1BIVOYQQQghRS1TkEEIIIUQtUZFDCCGEELX0Wk7QWVJSopAZVfmcSbWeIrLLIzch6kpRx5OXybqPKiNrc17XY428fw98/1wV/b2hWchboaSkBFZWVqiqqpL7tnR1dSEUCnn7ZSkqO9+5CVFXijyevEyWfVRZWZvzOh5rFPF74PPnqozvDZ/5X7sip7y8HFVVVUhMTISVlZXctiMUCjFz5kyUl5fztgMrIrs8chOirhR1PHmZrPuoMrI253U91sj798D3z1XR3xu+8792RU49Kysr2NnZKTuGTNpydkLUUVvaJ9tSVnXW1n4PbS1vPbrwmBBCCCFqiYocQgghhKglKnIIIYQQopZkKnJWrVoFjuNQXFzMcxxCCCGEEH6o/EhOZmYmOI7Dvn37FLbN4uJicByHcePGNdkmOzsbHMchICBAYblasmXLFnAch9mzZ4tdf//+fRgbG0NXVxdXr15VcDpCZPfPP/9I9Y8qxhjOnz8vv0BSePz4Mb755hvY2dmhY8eO0NHRgYmJCUaOHInQ0FD89ddforZOTk7gOA537txReM76415zr4qKCpw/fx7a2tro168fnjx5IravCRMmgOM4JCYmKvhTtH1t8Tj+8nene/fuqK2tFdtOKBSK2pmZmSkkm8rfXeXs7Ax9fX2kpKRg2rRpyo6j0ubPn4+kpCQkJCTAw8MDH3zwQYP1QUFBuH37NjZt2oS+ffsqKSUh0vP398e5c+eQnZ0Nc3PzZtsyxrBo0SJs3boVf/zxB/r06aOglI1VVlbCwcEBly9fhqWlJWbOnIkuXbqgvLwceXl5WLduHSwsLGBhYaG0jK+ysLDAzJkzxa4TCASws7PDF198gdWrVyM0NBSRkZEN2mzfvh0ZGRlwc3Nrsh/StLZ8HNfS0kJpaSmOHDmCKVOmNFofGxsLDQ3Fjq2ofJGjra2NiRMn4vDhw6iuroaOjo6yI6ksjuMQHx8PGxsb+Pn5YcSIETA0NAQAHDhwAHv37sXo0aOxYMECJSclRDqRkZFwcnKCk5NTs4VOfYGzadMmbNu2TakFDvAi9+XLlzF37lxs374dHMc1WF9UVITq6molpRPP0tISq1atarbNF198gdTUVGzevBlubm5wdHQE8OLzLFmyBF27dkVMTIwC0qqftnwcf/fdd3Hp0iXExcU1KnJqa2uRmJiI999/H6dOnVJYJt5LqqqqKoSFhaFv374QCATo06cPIiIicOHCBXAch5CQEKn7dHd3R2VlJbKysviOq3bMzMwQERGBsrIyBAYGAgBKS0sRGBgIPT09xMfHNzrQEqLqTExMkJ2dDW1tbTg5OaGoqKhRm1cLnPrvvzL9+uuvAF7861vcfmdubo7+/fsrOlaraWtrY/fu3dDW1sYnn3yCR48eoa6uDl5eXnj06BFiYmLQtWtXZcdss9rqcbx9+/aYNm0a0tPTUVZW1mBdWloaSktL4e3trdBMvBY5lZWVcHR0xIoVK9CrVy8sXLgQtra2CAkJQWhoKADA1tZW6n7HjRsHgUCA5ORkPuOqLT8/P7i4uIiqfj8/P5SXlyMyMhK9e/dWdjy1dffuXZw9exYAmjwnrYoeP36MU6dOITs7G5WVlcqO06TmCh1VLHAAoEuXLgCgMtdO8Mna2hqrV68Wjd5ERkbi9OnTmDVrFtzc3JQdr4G2uG+21eO4t7c3amtrkZCQ0GB5XFwcDAwM4OrqqtA8vJ6u8vb2xvnz55GQkNDgXOyGDRtEIziDBg2Sut8OHTpg7NixSE1NRUxMjMLO6f35559NDtuq+p1lsbGxsLa2xieffILq6mpMmjRJ4RX06+T06dOYPHkyHj58CADw9fXFzz//DD09PSUna15xcTHee+89XL9+HQDQq1cvZGVl4c0331RyMvHqC52XT12ZmZmpZIEDAFOnTkViYiLmzp2LvLw8jB07FoMHDxYVP6qoqePeuHHjYG9v32BZSEgIUlJSsH37drRr1w4mJibYvHmzgpJKpq3um0DbPI4PGzYM1tbWiI+Px5IlSwAAd+7cQUZGBgIDAxV/yQmTwcqVKxkAVlRUJFp2/PhxBoAFBAQ0al9WVsYAsPbt27Pa2lpZNsl27tzJALCcnByZ3l+voKCAAWAFBQVNtikqKmIAJHr5+/vLvB15ZH/Z8uXLGQCmra3Nbt++LZdtyIuq5JBEVVUVMzAwYBoaGqLvhYaGhth9QdWMHDmSaWlpiXJramoyOzs7Zcdq0c2bN5mFhQUzNTVlXl5eDADbtm2bwnNI8j2NiIhgHTt2bHDcsLCwYEFBQezq1asN2jo6OjIA7O+//27VNmV5X0vHve+++07s++qP/QDYgQMHeMvDB1XcN+V9HOf75yrN30wXFxfGGGMbN25kANiZM2cYY4ytW7eOAWAXLlxgjDGmo6PDevfurZD8vI3kbN26FQCwdOnSRusMDAwAADY2NtDU1AQAJCUlITo6GgUFBbh//z6KioqavaVs8uTJ0NLSQnJyMhwcHMS2keSWUaFQ2GKbei4uLjh69KjYddnZ2Rg9ejSv2+Ozr7KyMtGFfzU1NUhLS4Ovr69ctiUP9dtXdg5JFBUV4d69ew2W1dXV4cSJEypzG3NTzp4922D4/vnz57hw4QLy8/MVfheEtDZv3owPP/wQO3fuhI+PD4YPH67wn7ck38/FixfD19cXR48eRW5uLvLz83H27Fls3boVsbGx2L9/v9g7UfjYtiztmzvuvYoxhq+++kr0/0lJSfDw8JBLLlmo4r6pqOM4Xz9XWfqZOXMmli1bhri4OAwfPhzx8fGwtbWV6kxOS9uVeB4tWSojcSM5enp6zNLSUmz7mzdvNhr12L17N1uzZg3bsmVLo76aMmDAAGZvb9/kekg4+gIpq1JxTp48KdFIjjxeklS4bm5uDABbt24dMzQ0ZHp6euzGjRstvk+euelFL3V9SfuvzoqKCjZv3jwGgBkaGrLq6mrGmHQjOXxnleS496rIyEgGgM2aNUuUPTk5WaL3vu7HGnkdx+X1c5X2b6a7uzt744032LFjxxgAtmXLFtE6SUZyWnpJipeRnIqKClRWVmLIkCFi1x8/fhxAw+txZs2aBQC4cuWKRNsoLS2FUChs9u6sgoKCFvupn8ZdUficnl7S7AkJCUhOTsakSZOwbNkymJmZYdq0afDx8cGxY8ck2hafuWVR/1mVnUNSERER2LNnj+j/NTU1sWPHDrz99ttKTNWyI0eO4MsvvwTHcWCMAXhxe7C7u7uSkzWNMYaIiAjs3bsXXl5e2LlzJ4yMjKChoYHt27fD2NhYYVlkPZ7o6+sjKioK6enpuHHjBgoLCzF48GCp+pB23+D72Hf16lWEhobCxMQEW7ZswT///IO3334bAQEBGDlypMTXHcl7H1e1fVNRx3G+fq6yfm98fHyQlJQELy8vCAQCzJgxQ6r38/a9kLgcesmrIzmPHj1iANjAgQMbta2urmZWVlYM+N/5uZcVFhY26KspMTExTfYhDVnOL4oj6UiOoq/JuXXrFuvUqRMzMDBocP7W09OTAWDff/99q7ehCKqSQ1J1dXUsOjqavf/++wwAS0hIUHYkiaWlpbHx48czAOzbb79Vdpxm1dXVsYULFzLgxTU49d+TI0eOiK7RuX79usLytPZ7+tZbbzEALD8/nzGmGtfkSDKSU1tby+zt7RkAdvToUdHyqKgoBoBNmzat1Xn4omr7pryP46pwTQ5jL74jxsbGYr8Pirwmh5eT7h06dEDv3r1RWFiIwsJC0fLq6mp4eXlBKBRCQ0MDNjY2Mm8jKSkJPXv2xLBhw/iIrLZ8fHxQUVGBqKgo9OjRQ7R827Zt6Nq1K0JCQnDjxg0lJlRP9VN8rF+/HgDw1ltvKTmR5CZOnCi6rsLZ2VnJaZrGmrlNvFu3bi0+R0cZYmJicO7cObHrUlJSIBQK0alTJ1hbWys4WeuEh4fjzJkzotuc682bNw/Ozs7Yt28fkpKSlJjwf9rivqkOx3FNTU2kpKQgOTkZa9euVVoO3q4sDA4ORl1dHUaNGoXAwEAsWrQIb731Fu7evQuBQIB+/fpBV1dXpr4fPHiAEydOwNXVVSUfgKQqYmJikJmZCU9PT0yfPr3Buq5duyI6OhqVlZXw9vYWnZogpC1orsCpJ8kDAxUtIyMDw4YNw5tvvgkvLy98/vnnWLhwIUaNGgU3NzdwHIdt27a1qSe5FxYWYtWqVTA3N0dERESDdRzHITY2Fh07dkRgYCDKy8uVlLLtUqfj+JAhQ+Dq6qqwearE4a3ICQoKQlhYGDp06IC4uDgcPXoU/v7+iIqKwtOnT2V6Pk699PR01NTUqNwDplRJUVERgoODYWRkhOjoaLFtPDw8MH36dJw4caLJNoSooqVLl0r0HJxXC51bt24pMGVj69evR3h4OMzNzXH69Gl899132L59O27fvo05c+YgLy+v0R8yVVZTU4PZs2ejpqYGcXFx6NixY6M2Lz+td968eUpI2XbRcZx/vN1CznEcli9fjuXLlzdYXj9kKcuTjuslJyejc+fOcHJyak1EiZmZmbVYITs5OalUFW1ubi7R02r37NnT4CI8QtoCBwcHWFhYICAgoMW29YXO2rVrlT61QL9+/RASEiLxdDbZ2dnyDdQMSY572trauHDhQot9+fn5wc/Pj69or422ehyX5LvzsqdPn8oxTUNyn6Dz0qVLABo/6fjevXsoKSnBX3/9BQD4/fffUVFRAVNTU9FzdYAXP4yMjAy4u7tDS0vl5xMlhMjBqzMxt8TExET07C5CyOtL7k/7unjxIoDGIzmpqamwtbWFp6cngBcXP9ra2iI1NbVBu5ycHAgEAlE7QgghhBBJKGQkx9jYWDRVfD0vLy94eXm1+P4xY8bQxWuEEEIIkZpMRU79tTGdOnVqsa2qT2RJCCGEEPUkc5GjqIuACSGEEEJkodoz8BFCCCGEyIiKHEIIIYSopdf2nmy+pqFXRv9ttW9C1JUi95vWbktV9nFVyaEs8vr8ba1feW/ntStyDA0Noaurq5CZyHV1dRvdVdYaisrOd25C1JUijycvk2UfVVbW5ryOxxpF/B74/Lkq43vDZ/7XrsgxNTWFUChUyG3phoaGMDU15a0/RWXnOzch6krWfVIoFGLmzJlITEyElZWV1NuVZR/l6/jR2uwvex2PNYo4jvP5c1Xk38x6fOZ/7Yoc4MUvra3uWG05OyHqqDX7pJWVFezs7HhO1DQ+jx+Kzq5O2tpxvK3lfRldeEwIIYQQtURFDiGEEELUEhU5hBBCCFFLVOQQQgghRC1RkUMIIYQQtURFDiGEEELUEhU5hBBCCFFLVOQQQgghRC1RkUMIIYQQtURFDiGEEELU0ms5rYOqKykpUeg8IdJoaU4RvrLXz0TL14y0r+McOYQQ8rqjIkfFlJSUwMrKClVVVcqOIpauri6EQqHYgkEe2fma+ba53IQQQtQTFTkqpry8HFVVVbzM8Mu3+tmHy8vLxRYLqpq9pdyEtIYso5etHamUdWSSj5FWPkdZJfkcNDpMWoOKHBXVlmf4bcvZCZFGa0cvZR2plGVkku+RVj5GWVv6HDQ6TFqLihxCCJGRMkYvZR2ZVLWRVkk+h6plrkejw20HFTmE8KC0tBSXLl3C2bNnAQD5+fmwsrJC+/btlZyseQ8fPsSFCxeQk5MDAPjll1/Qp08fdOrUSbnB2pi2NHrZlrLWa4uZiWqgW8gJkVFxcTFCQ0NhamqK7t27w8XFBStWrAAA+Pv7Q09PD++88w7i4+Px5MkTJaf9n3v37mHjxo2wsbGBvr4+nJyc8OWXXwIAPv30U3Tu3BlWVlYIDw9X2bv8CCFEElTkECKlqqoq/Otf/0KfPn0QHR2NKVOm4Mcff8S1a9fw73//GwAQFhaGrVu3onPnzvDx8YGZmRkOHjyo1Nx1dXXYvHkzevXqhc8++wzW1tbYuXMnCgsLsX37dgDA+vXrsXv3bgwZMgQrVqxAr1698O233+L58+dKzU4IIbKgIkcNcRzHy4tyNyYUCjFw4EDExMRg/fr1+L//+z9ERUVh6tSpsLS0FJ2eMjc3h7+/P44cOYJr167h3XffhaenJ2bPno1nz57JNaM49+7dw3vvvYeFCxfik08+wc2bN7F3717MmTMH1tbW0NXVBQAYGxtj1qxZSEhIwK1btxAYGIhly5Zh5MiRKCsrU3huQghpDZmKnFWrVoHjOBQXF/Mch7TWw4cPER4eDsZYq1+Uu6Hff/8do0aNgkAgwKVLlxASEoIOHTq0+D4LCwskJSVh9+7d2L9/Pzw8PFBTUyO3nK+6f/8+nJ2dceXKFZw4cQJRUVHo1q1bi+8zNDTExo0bkZOTg6KiIjg6OuLu3bsKSEwIIfxQ+ZGczMxMcByHffv2KTtKm5CRkYHx48crO4bUVD13ZWUlJk6ciB49euDUqVPo27evVO/nOA6zZs1CamoqMjMzsXTpUjklbYgxhunTp+PWrVvIzs7G6NGjpe5jxIgROH36NO7fv4+pU6eirq5ODkmbV1NTg8ePH0v1noqKCvmEkdLjx4/xzTffwM7ODh07doSOjg5MTEwwcuRIhIaG4q+//hK1dXJyAsdxuHPnjsJzFhcXtzhKWlFRgfPnz0NbWxv9+vVr8lqzCRMmgOM4JCYmKjyzrq4uevbsiffeew8rVqxo8POtl52d3eJndXJykmt2ohgqf3eVs7Mz9PX1kZKSgmnTpik7jsq7cuUKPvroI2XHkJqq5162bBnu3r2LrKwsGBgYyNyPi4sL1q5di5CQEHh4eMDBwYHHlI3FxcUhMzMT6enpGDBggMz9vPnmm9i7dy+cnZ2xdetWLFiwgMeULfP398e1a9eQkZGBjh07tth+586dCA4Oxrlz52Bubq6AhOJVVlbCwcEBly9fhqWlJWbOnIkuXbqgvLwceXl5WLduHSwsLGBhYaG0jK+ysLBo8lkyAoEAdnZ2+OKLL7B69WqEhoYiMjKyQZvt27cjIyMDbm5uvD2TpiUvZ66urkZZWRny8vIQFhaGb775BkuXLsXXX3/d6HT24MGDMWnSJLF9mpmZyTs2UQQmg5UrVzIArKioSJa3S+3jjz9menp67OnTpwrZnjIVFBQwAKygoEDq99bU1LA1a9Y0WDZjxgymo6PD/vjjj0bt165dywCww4cP85JN1uzKzt2S33//nQFgmzdvbrFtYmIiA8ASExObbFNbW8vs7e3ZkCFDZMojqaqqKmZgYMDmzJnTYltJcjPGWGBgIOvYsSN7+PAhTyklk5uby/T09JiDgwOrrKwULRf3u42Pj2ccxzE/Pz/2/PlzueZq6bu1Zs0aBoDNnTuX1dXVNVp//fp1JhQKRf/v6OjIALC///5b5m3K+r6ioiIGgLm4uLTY17Nnz5itrS3jOI5lZ2eLll+/fp117NiRde3alZWVlbUqDx+Zc3JymJmZGQPAli9fLlp+8uRJBoD5+/s3m7E12Ylq4P10VVVVFcLCwtC3b18IBAL06dMHERERuHDhAjiOQ0hIiNR9uru7o7KyEllZWXzHVSunTp3CqFGjGizbuHEjdHV1ERAQ0GB5UVER1qxZAw8Pjyb/JaMoqp47OjoaRkZG8Pf356U/TU1NLF++HPn5+Th37hwvfYrz448/4t69e1i+fDlvfX7++ed48uSJ3E9DvOqdd95BZmYmLl26hPHjx+PRo0di2+3cuRPe3t7w9fVFdHQ0NDSUe0b+119/BQAEBQWJvSje3Nwc/fv3V3SsVtPW1sbu3buhra2NTz75BI8ePUJdXR28vLzw6NEjxMTEoGvXrsqOCQcHBxw9ehQ6OjoIDw/HzZs3lR2JKBivR4DKyko4OjqKbj1duHAhbG1tERISgtDQUACAra2t1P2OGzcOAoEAycnJfMZVOz///HOj0x9GRkZYv349Tp48iV27domWz5s3D9ra2ti0aZOiYzaiyrnr6uqQkJAAb29vtGvXjrd+x40bB1NT0wafjW+7d+/GmDFjYGlpyVufJiYmmDRpklxzN6WlQkfVChwA6NKlCwDg6tWrSk7CP2tra6xevRpFRUVYsmQJIiMjcfr0acyaNQtubm7KjifSr18/fPjhh3j27BlSUlKUHYcoGK/X5Hh7e+P8+fNISEhocC52w4YNohGcQYMGSd1vhw4dMHbsWKSmpiImJkYlDl6qqLa2Fpqamo2Wz507F7t27UJwcDAmTZqEY8eO4ejRo9i8eTOMjY2VkLQhVc597do1VFRUwNnZmdd+NTU14eTkhLy8PF77rVdXV4dz587h888/571vZ2dnhISE4NmzZ7wWfpKoL3RcXFwwfvx4rF27FgCQmpqKNWvWqFSBAwBTp05FYmIi5s6di7y8PIwdOxaDBw8WFT+q6M8//8SqVasaLR83bhzs7e0bLAsJCUFKSgq2b9+Odu3awcTEBJs3b1ZQUsk5OTkhISGh0chpfn6+2M8KiP+8pO3hrcjJysrCgQMHEBAQ0Ohiszlz5iAkJATt27dHv379ZOrf3d0dqampyM3NlfvFmqru9u3b+OabbxAVFSVadvHixSYLSI7jEBMTA1tbWwQGBiInJwdDhgxBUFCQghK/0BZzX7x4EcCLCxT5NnjwYOzfvx/Pnz8XW+S1xvXr11FZWSm33M+ePRM9M0jRXi506i+AVsUCBwCmTJmCiIgIrFy5EhEREYiIiADw4kLZcePGYeHChXjzzTeVnLKhv/76C6tXr260vFOnTo3+6GtqauLrr7/G+++/j2fPniEyMlIlpwTp2bMnADR6gndBQQEKCgrEvkfc5yVtD29FztatWwFA7K2x9Xej2NjYiA7ma9euxcGDB/HHH39AV1cXjo6OCA8Pb/KK9smTJ0NLSwvJyclNFjnnz5/n4ZMol1AobLHNpUuXRA+Zqz9AZmZmNvvHf8CAAQgODsbatWuhqamJ9PR0mf8YNJWxpeyqmrs5Fy5cgKamJoqLiyV6LlRRUZHovy19H6uqqlBdXY3c3FyJnrcjjStXrgB48RBASfYLaXLX/6E4c+aM0p6ErKOjg82bN8PPzw/Ai2svfH19RUWpokjynVq8eDF8fX1x9OhR5ObmIj8/H2fPnsXWrVsRGxuL/fv3Y8qUKXLZtiztXVxccPToUYnaMsbw1Vdfif4/KSkJHh4evOWSZZ+Vhr+/P77//nuZ3y/vfKRpEs9lJsvVyuLurtLT02OWlpZi29+8ebPRlewuLi5s586d7LfffmPnz59n7733Huvfvz+rqalpcrsDBgxg9vb2Ta4HoDavlq7aX7lyJQsPDxf9/8t3DjQlIiKCAWC9evVi1dXVLbZ/Vf0dBa3Jrsq56UUvWV/S3mVTUVHB5s2bxwAwQ0ND0fdamrur+M4qzd1V9SIjIxkANmvWLFH25ORkid4rzedobebY2FgGgM2ePZsxxt/dVfRS3ktSvIzkVFRUoLKyEkOGDBG7/vjx4wAaXo/z6r8U/v3vf6NPnz74/fff8fbbbzfqo7S0FEKhsNm7s5oadmxLhEKhRM+WcHV1RVBQEEJCQnDz5k2Ympo22/7mzZtYuXIlrK2tceXKFYSHh8t8101iYiKsrKxkyq6KuZuTnZ2NJUuWICMjA0ZGRi22v3jxInx8fBAbG9vi9Wfx8fGIi4vDqVOneD/FUlpaigkTJmDjxo1wdHRssb00uc+cOYOgoCAcPHhQac8Sqb8GZ/LkyRg4cCAiIiLQt29fbNmyRTRFhSJIur++Sl9fH1FRUUhPT8eNGzdQWFgo9alFab/PsmZtytWrVxEaGgoTExNs2bIF//zzD95++20EBARg5MiREl931Nzn4CtzdnY2AGDo0KGt7utlshxTiGLxUuRoa2sDeDE0/qpnz54hPDwcQPN3Vj148AAAmnzQ2qFDh1BXV9fsVfsSD1+pgUGDBuHOnTsoLS1FWloaXF1dm20/f/58AC+eLLx48WJ8/fXX+Pjjj9GnTx+pt21lZSXzz7qt5TYyMsKSJUtQXV0t1XsHDRrUYvu1a9di6NChTf7joDUYYzAyMsL9+/d5z/2f//wHenp6cHV1Vcr1Lzt37mx0Dc748ePh4uKC0NBQiR8YqGwcx7XqNGVr9sPWev78OebMmYMnT55gx44d0NfXh76+PtavX4/58+dj/vz52Lt3r0R9yftzXL16FT/++CN0dHR4v+tLmb8DIhlejlAdOnRA7969UVhYiMLCQtHy6upqeHl5QSgUQkNDAzY2NmLf//z5cwQHB2PChAkwMTER2yYpKQk9e/bEsGHD+IisFiZPnozDhw/j9u3b6NGjR5PtkpOTkZqairCwMJiYmCAyMhLt2rVT+IXH9dpSbmNjY5iamiItLY3Xfp88eYKsrCyMGDGC137rcRyHESNGIC0tjff5vNLT0/HOO+8orcARd5u4pM/RUbSYmJgmn4WUkpICoVCITp06wdraWsHJWic8PBxnzpyBn58fXFxcRMvnzZsHZ2dn7Nu3D0lJSUpM+MIvv/wCFxcXVFdX47PPPlOJu0mJYvF24XFwcDAWLFiAUaNGYdq0aRAIBEhNTUWfPn0gEAhgbm4udhiZMYaAgACUlJTgl19+Edv3gwcPcOLECfj6+ipldmxV9cEHH2DFihXNjoZUVlbi008/ha2trehOlJ49eyIsLAwLFy7ETz/9hKlTpyoo8QttKTfHcZg7dy7WrVuHDRs2QF9fn5d+9+/fj4qKCnh7e/PSnzhz587FxIkTkZeXh+HDh/PS5+XLl/Hzzz/jp59+4qU/abT0HJxXby9XhRGdjIwMBAQEwNLSEiNGjEDPnj3x+PFjXLhwATk5OdDQ0MC2bdugo6Oj1JzSKCwsxKpVq2Bubi66W6wex3GIjY2FjY0NAgMDMWrUKBgaGso908u3vT979kw0rUNhYaHo4ZsrV65s9L7mbiEXCAT47LPP5JiaKIQsF12Ju/C4rq6OhYWFMWNjY9auXTvWv39/tn79evbf//6XAWDTp09v1E9dXR0LCAhgZmZmrKSkpMnt/fDDDwwAO3bsmCxx2xRpHhdeW1vLDAwM2G+//dZkm08//ZRpaGiwvLy8Ru+1s7NjPXv2lPgR/XxN66BquVty+/ZtpqOjwxYvXszLtiorK5m5uTmbNGmSTHkkVVtbyywtLZmTk1OL0xtIkruuro6NHz+emZiYsGfPnvEdt1nSTNXQ1BQQ8tDSz+2///0vCw8PZ2PGjGHm5uZMIBAwgUDALCws2Jw5c1h+fn6D9qo+rcOzZ8/YoEGDGMdx7OTJk022i4mJYQDY1KlTZc4jTeaXX+3bt2c9evRgo0ePZl9++SX7888/G72v/sLj5l76+vqtyk5Ug9znrjp48CAD0OCOGsZeHDADAwNZr1692PXr15vtw9PTk3Xu3LnZO6/UhbQ7z44dO5pcl5+fzzQ1Ndn8+fPFrs/Ly2MaGhrs008/5SWbNNlVKbckvv32W8ZxHDt9+nSrtxUYGMh0dXXFHnz5lpWVxYCW592SJPeOHTsYAJaWlsZ3zBZ99dVXUs1FlZuby+zt7Vlpaalccynjj528ihxF46PIURZVzUUak/ss5JcuXQLQ+EnHQUFB2Lt3Lw4fPoz27dvjzp07AF5cePzyU1SfPn2KjIwMuLu7Q0tL5SdNVzgfH58m1w0ePBi1tbVNrh86dKjSnnPS1nIvWrQIhw4dgru7O06ePCnzNRQRERGIjo7Gtm3bFDLztLOzM+bPn4/FixfD1NQUH3zwgUz9ZGZmYt68efDx8cHEiRN5TtmyL774AowxiU9Xv/POO8jNzaXT24S85uR+5WD9w7levbMqOjoaFRUVGDlyJHr06CF65ebmNmiXk5MDgUAAT09PeUclpEmampo4dOgQjI2N4ejoKPUcOFVVVfjXv/6F4OBghIaGIjAwUD5Bxfjuu+/g6uoKT09PbNy4UaoCsa6uDlFRUZgyZQrGjh2Lbdu2yTFp86QtWKjAIYTIvci5dOkSjI2NG118xl6cKmv0cnJyatBuzJgxKC8vl+mJoITwycDAANnZ2XBwcICbmxs++ugj0UhlU2pqavDTTz9h0KBBiImJwaZNm/D1118rKPELWlpa2Lt3LxYuXIjg4GCMHDkSx48fb/auK8YYsrOz4ezsjAULFsDX1xcHDx5U+FxVhBDSGjKd/6kvRCSZo0SSR+ET0lZ06tQJKSkp2LNnD5YuXYpBgwZh+PDhcHR0hJ2dHe7fvw8AOHDgAKKjo5Geno6///4bo0ePxuHDh2Weu621tLS0sGHDBri6umLevHkYM2YM+vbtK5ow8smTJwCAtLQ07Nq1C8eOHYNQKET//v2RlZXF+wSlhBCiCDIXOa+OuBDyuuA4DjNmzMCHH36I1NRU/PDDD9izZ4/ooZcAsH79etjY2MDDwwO+vr5in+KtDA4ODrh06RJycnIQFxeH//znPw0mTF25ciUsLS1hb2+PqKgojB49mk77EELaLLqSlxAZaWtrw8PDQzQh4T///IM7d+6guLgY9vb2Ej/WXtE4jsOoUaMwatQoAC+eSXTr1i1cu3YNQ4cObfYBjYQQ0pZQkUMIT7p06YIuXbpgwIAByo4iFT09PVhZWdEcPIQQtUNFDiGEtJJQKGwz21Jk1uZIk0NVMtdTtTykaVTkqChV3IkkzaRq2VUtD1EfhoaG0NXV5XV2b0no6upKPV2CsrI2p6XPoYqZ68nyOyCKx7Hm7iMlCldSUgIrKytUVVUpO4pYurq6EAqFMDU1bbROlbM3l5uQ1igpKUF5eblCt2loaCjTd1kZWZsjyedQtcz1ZP0dEMWiIkcFqepODbS8Y6tqdjogEULI64eKHEIIIYSoJbk/8ZgQQgghRBmoyCGEEEKIWqIihxBCCCFqiYocQgghhKglKnIIIYQQopaoyCGEEEKIWqIihxBCCCFqiYocQgghhKglKnIIIYQQopaoyCGEEEKIWqIihxBCCCFqiYocQgghhKglKnIIIYQQopaoyCGEEEKIWvp/uB6Hj9G0XlUAAAAASUVORK5CYII=", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "plot(c)" ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": null, "id": "5f5896a5-e639-401c-992a-19b960720ec4", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─H─U1─U1─U1─U1───────────────────────────x───M─\n", - "q1: ───o──|──|──|──H─U1─U1─U1────────────────|─x─M─\n", - "q2: ──────o──|──|────o──|──|──H─U1─U1────────|─|───\n", - "q3: ─────────o──|───────o──|────o──|──H─U1───|─x───\n", - "q4: ────────────o──────────o───────o────o──H─x─────\n" - ] - } - ], + "outputs": [], "source": [ "from qibo.models import QFT\n", "c = QFT(5)\n", @@ -256,105 +173,50 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": null, "id": "afa80613-6330-4a85-928f-4cb884d81990", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\")" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": null, "id": "916f7b83-1ad7-4984-8573-eb55dfeb125d", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\")" ] }, { "cell_type": "code", - "execution_count": 10, + "execution_count": null, "id": "b9e1176c-d8dc-47e4-9607-ad24f6f536b9", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\")" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": null, "id": "eaefdf76-af68-4187-996d-bdc9c33a4242", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"color-blind\")" ] }, { "cell_type": "code", - "execution_count": 12, + "execution_count": null, "id": "56f4f3cc-6864-4ef2-aa19-9c209fc217e5", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "custom_style = {\n", " \"facecolor\" : \"#6497bf\",\n", @@ -371,22 +233,10 @@ }, { "cell_type": "code", - "execution_count": 13, - "id": "0a2c8489", + "execution_count": null, + "id": "f5077d51", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "q0: ─[─H─U1───]─U1─U1─U1─────────────────────────────────────x───M─\n", - "q1: ─[───o──H─]─|──|──|──[─U1───]─U1─U1──────────────────────|─x─M─\n", - "q2: ────────────o──|──|──[─o──H─]─|──|──[─U1───]─U1──────────|─|───\n", - "q3: ───────────────o──|───────────o──|──[─o──H─]─|──[─U1───]─|─x───\n", - "q4: ──────────────────o──────────────o───────────o──[─o──H─]─x─────\n" - ] - } - ], + "outputs": [], "source": [ "from qibo.models import QFT\n", "c = QFT(5)\n", @@ -396,21 +246,10 @@ }, { "cell_type": "code", - "execution_count": 14, - "id": "63faa1ea", + "execution_count": null, + "id": "259e5c4f", "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], + "outputs": [], "source": [ "ax, fig = plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\")" ] @@ -418,7 +257,7 @@ { "cell_type": "code", "execution_count": null, - "id": "ce2296cf", + "id": "a9f50b42", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 8289c012ec..f173a660cc 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -551,7 +551,7 @@ def _build_path(filename): def _check_list_str(substrings, string): - return any(item in str for item in list) + return any(item in string for item in substrings) def _process_gates(array_gates): @@ -562,17 +562,14 @@ def _process_gates(array_gates): if init_label == "CCX": init_label = "TOFFOLI" - - if init_label == "CX": + elif init_label == "CX": init_label = "CNOT" - - if _check_list_str(["SX", "CSX"], init_label): + elif _check_list_str(["SX", "CSX"], init_label): is_dagger = init_label[-2:] == "DG" init_label = ( r"$\rm{\sqrt{X}}^{\dagger}$" if is_dagger else r"$\rm{\sqrt{X}}$" ) - - if ( + elif ( len(gate._control_qubits) > 0 and "C" in init_label[0] and "CNOT" != init_label From 3039e588cab09c943c0d89ac2871afbdcafd0aa3 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 13:33:34 +0200 Subject: [PATCH 077/116] review load json style files --- src/qibo/ui/mpldrawer.py | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index f173a660cc..0a942e972c 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -11,9 +11,11 @@ from qibo import gates from .FusedGateBarrier import FusedEndGateBarrier, FusedStartGateBarrier +from pathlib import Path -STYLE = {} -SYMBOLS = {} +UI = Path(__file__).parent +STYLE = json.loads((UI / "styles.json").read_text()) +SYMBOLS = json.loads((UI / "symbols.json").read_text()) plot_params = { "scale": 1.0, @@ -625,16 +627,6 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ax.figure A Figure object (type: matplotlib.figure.Figure) """ - json_file = _build_path("symbols.json") - - with open(json_file) as file: - SYMBOLS.update(json.load(file)) - - json_file = _build_path("styles.json") - - with open(json_file) as file: - STYLE.update(json.load(file)) - if style is not None: if type(style) is dict: plot_params.update(style) From aa0db70fb9ffd57839bd3fc491c319e2945477b0 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 1 Aug 2024 11:36:48 +0000 Subject: [PATCH 078/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 0a942e972c..d42a78c7d9 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -4,6 +4,7 @@ # import json from os import path +from pathlib import Path import matplotlib import numpy as np @@ -11,7 +12,6 @@ from qibo import gates from .FusedGateBarrier import FusedEndGateBarrier, FusedStartGateBarrier -from pathlib import Path UI = Path(__file__).parent STYLE = json.loads((UI / "styles.json").read_text()) From 5f46dc238b7ddfbdbe0a49dff8083082c347eab6 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 16:51:30 +0200 Subject: [PATCH 079/116] added more information to example notebook --- .../qibo-draw-circuit-matplotlib.ipynb | 273 +++++++++++++++--- 1 file changed, 233 insertions(+), 40 deletions(-) diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index fec8dc3687..e66a93a73d 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -47,20 +47,7 @@ "execution_count": 1, "id": "66e4921b-c1ea-479d-9926-d93a7c784be9", "metadata": {}, - "outputs": [ - { - "ename": "SyntaxError", - "evalue": "expected ':' (mpldrawer.py, line 572)", - "output_type": "error", - "traceback": [ - "Traceback \u001b[1;36m(most recent call last)\u001b[0m:\n", - "\u001b[0m File \u001b[0;32m~\\.conda\\envs\\qibo-env\\Lib\\site-packages\\IPython\\core\\interactiveshell.py:3508\u001b[0m in \u001b[0;35mrun_code\u001b[0m\n exec(code_obj, self.user_global_ns, self.user_ns)\u001b[0m\n", - "\u001b[0m Cell \u001b[0;32mIn[1], line 9\u001b[0m\n from qibo.ui import plot\u001b[0m\n", - "\u001b[1;36m File \u001b[1;32m~\\Desktop\\Optimizadores\\rotosolve\\qibo\\src\\qibo\\ui\\__init__.py:1\u001b[1;36m\n\u001b[1;33m from qibo.ui.mpldrawer import plot\u001b[1;36m\n", - "\u001b[1;36m File \u001b[1;32m~\\Desktop\\Optimizadores\\rotosolve\\qibo\\src\\qibo\\ui\\mpldrawer.py:572\u001b[1;36m\u001b[0m\n\u001b[1;33m else (\u001b[0m\n\u001b[1;37m ^\u001b[0m\n\u001b[1;31mSyntaxError\u001b[0m\u001b[1;31m:\u001b[0m expected ':'\n" - ] - } - ], + "outputs": [], "source": [ "# General libraries\n", "import matplotlib.pyplot as plt\n", @@ -77,10 +64,21 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "id": "eda54008", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─RY─o─o───o─────RY─o─o───o─────RY─o─o───o─────RY─M─\n", + "q1: ─RY─X─|─o─|─o───RY─X─|─o─|─o───RY─X─|─o─|─o───RY─M─\n", + "q2: ─RY───X─X─|─|─o─RY───X─X─|─|─o─RY───X─X─|─|─o─RY───\n", + "q3: ─RY───────X─X─X─RY───────X─X─X─RY───────X─X─X─RY───\n" + ] + } + ], "source": [ "nqubits = 4\n", "nlayers = 3\n", @@ -104,32 +102,92 @@ "print(ansatz.draw())" ] }, + { + "cell_type": "markdown", + "id": "7fdbf16f", + "metadata": {}, + "source": [ + "#### Plot circuit with default black and white style" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "id": "ea99c3d4-e36f-46ca-81c4-c8f10d6bcbe5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(,
)" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot(ansatz, scale = 0.6, cluster_gates = False)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "id": "81b65ea2-06a0-437d-b8f3-2ac176ea9b25", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(,
)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot(ansatz, scale = 0.7, cluster_gates = True)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "id": "62d00656-b40d-44f1-b56a-6733eeed6759", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ──────o───o───────────o──X─M─\n", + "q1: ─H──X─|───o─o─x─si─fx─o──X─M─\n", + "q2: ─SX───CSX─X─X─x─si─fx─DE─────\n" + ] + } + ], "source": [ "c = models.Circuit(3)\n", "c.add(gates.H(1))\n", @@ -150,20 +208,53 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "(,
)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "plot(c)" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "id": "5f5896a5-e639-401c-992a-19b960720ec4", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─H─U1─U1─U1─U1───────────────────────────x───M─\n", + "q1: ───o──|──|──|──H─U1─U1─U1────────────────|─x─M─\n", + "q2: ──────o──|──|────o──|──|──H─U1─U1────────|─|───\n", + "q3: ─────────o──|───────o──|────o──|──H─U1───|─x───\n", + "q4: ────────────o──────────o───────o────o──H─x─────\n" + ] + } + ], "source": [ "from qibo.models import QFT\n", "c = QFT(5)\n", @@ -171,52 +262,123 @@ "print(c.draw())" ] }, + { + "cell_type": "markdown", + "id": "8ce6b04d", + "metadata": {}, + "source": [ + "#### Plot circuit with built-in styles" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 8, "id": "afa80613-6330-4a85-928f-4cb884d81990", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 9, "id": "916f7b83-1ad7-4984-8573-eb55dfeb125d", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 10, "id": "b9e1176c-d8dc-47e4-9607-ad24f6f536b9", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\")" ] }, { "cell_type": "code", - "execution_count": null, + "execution_count": 11, "id": "eaefdf76-af68-4187-996d-bdc9c33a4242", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAABJkAAAFICAYAAADzkC8GAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8fJSN1AAAACXBIWXMAAA9hAAAPYQGoP6dpAAA5eUlEQVR4nO3daZAc953m9yez7qPvrkZ34yBAkAAaAEUcJAYjYbUUGRppNBOUPOQY0sauDkuUwxGaF5LtibDebDg2pIi1HCOHLe2sV9Isxx57SM7qtCyNTEv0ilwSpEiCINEECBIESaEB9H3WmZWZftHoJhpdje6urDu/nwgFZzKzMn+/7KpC1VP//Kcx/Fm5AgAAAAAAADww610AAAAAAAAAmh8hEwAAAAAAADwjZAIAAAAAAIBnhEwAAAAAAADwjJAJAAAAAAAAnhEyAQAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPCMkAkAAAAAAACeETIBAAAAAADAM0ImAAAAAAAAeEbIBAAAAAAAAM8ImQAAAAAAAOAZIRMAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8IyQCQAAAAAAAJ4RMgEAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAz4L1LqAZBToiMhOhqh/HSVuyZ/NVP86NatXbZlX7XPixbz/2LPm3bwAAAACNo9bfS2r1fYOQaZMCHRH1ffW4zHCg6sdyCrbGvn2qZl88a9nbZlXzXPixbz/2LPm3bwAAAACNox7fS2r1fYOQaZPMREhmOKCpx4dVHE9X7TjBVELdJw/ITIRq9qWzVr1tVrXPhR/79mPPkn/7BgAAANA4av29pJbfNwiZylQcT8u6slDvMqqilXu7FT/27ceeJf/2DQAAAKBxtOL3Eib+BgAAAAAAgGeETAAAAAAAAPCsrJCp7YFd2vrN+xXojFa6HgAAAAAAADShhp+TKXJnt3q/cEhTj51V9tWxepezrkBnVP1/+UHlLkxq8tEzJbcJ7+pU6pEjSj8/opmfvlHjCr1Zrv2lq5r54bkNbxMaSCp2V59Cg20KbW1TIBFW/u1pTXz/dC3LL4sfe5b82bcfewYAAADQWJZyBUmy5/O69q+flRx31XbBVFxbvnpcklSczmr0W8/VtM5SGv5yufzFaTlZS9H9qXqXAg+i+1Nqu2+nIrd3yZkv1LucmvBjz5I/+/ZjzwAAAKitzV5JFOiISEaVikFNuLajQFtE0T09JdfH7xmU67hySwRQ9dLwI5nkuMq9Manovl4pYEh245w8bFz2tTHlzo3LupaWGQ9p4Osn6l1S1fmxZ8mfffuxZwAAANROZHeXej53t6YeH1ZueHzd7YOpuHq/dFjp50c0/5t3ql8gqqLw3qxC/UnF7xlQ7vzEypWmofihLcq/NaXIrs661FdKxUMmI2QqeWKH4of7FeiIyJ4vKH3qsvIXp9X3F8c0/9t3NfePFze1z+zwuOKH+hXZ3a38hclKl4waKI6l611CzfmxZ8mfffuxZwAAANRO/tKMssNj6v70AU09duugaSlgctKW0s+P1LBKVJprOcq+Oqb4PQMyEyE5aWt5XXRvjwJtEc3+/M2GCpkqermcEQ6o95Ejav/o7SrO5rTw7GVZV+bV/vE71P6x3ZIk6+rCpvebvzAp17IVO8AlcwAAAAAAn3FcTf/DOWXPLgZN0TW+G98YME384PSKUALNKf3SFRkBU/HD/SuWx+8ZkJOxlH19/ZFttVTRkUxdDw0pNNimqSeGlX1ldHl58sR2dXziTkmSdXV+0/t1LUe5N6cUHeqVfiKpCa6YC/bE1PbArpLruCsfAAAAAGBTrgdNkkqOaCJgak3W5XlZ1xYUPzqghWd+L0kyk2FF9/QsjlRrsCmFKhYyRXZ3KXZXnxaev7wiYJKkzOlr6vjEnXIKtorjmbL2nxseV2x/SuEdHSq8O1uJkqsq2BNX+xohEwAAAAAAm7ZG0ETA1NrSL11V55/cqdC2dlmX5xQ/0i8jYCrz0tV6l7ZKxUKmxPGtkqSF3763ap2TWXyCF0cXVoxCSnxwm5If2qFAMqTCyLxmfnZBxWulL6fLnp9Qp+0ouj/VFCFT7sKkJh89U3Ld0i3QAQAAAADYlJuCptlfvKW2+24jYGph2VeuqeNju5W4Z0Azl+cUPzqgwsh8WdMRVVsFRzJ1qziRkT2dW7XObItIkqwr75+A2N1b1PGx3Zr+yRuyRuaV/Cc71PuFuzX6V6fk5u1V+3CzRRUnMorc1lF2jaHBZNmPXRJMxT3vo1GPt6FjXQ8JjVvdCnNppVvZYXvVOhfr7reOPUvV6Zu/9Rpa8G8NAACA1rTwzHsKdETU8ad3yslYmvnlmwp0RBToiNS7NKxjs5/7nbSl3PkJxT6wRdnXxhRKJTTzszeqftyb3ZjprHkMT0e4zogGZUaDskZKz7cUvaNLklS4YT6m5Ie2K/3CFWVPX5Mkzfz4vPr/uw8pdvcWZV64smofZjKkYCqhhadXj5TaqL6vHCv7sfXSffJgvUtYwckVJUlmPLTmNoHE4jr3+raVUq9zUc+eJX/27ceepcZ7vQMAAKA5BBJhpb5wuN5loIrSL15V7GCfuh4ekmvZytw0TdFGeP2+MfL136y7TWVGMtmOJMmIldhdwFDyw7dJuiH1ChgKDSQ1/+tL72/nuCpcmlFkR0fJkCk6lJJhGsre4laN6xn7zgtlP3ZJMBWv6RfBqcfPlj2P1WZtpLfiREZu0VFoW7tkGpKzejRHeHu7JMm6VtnbulfrXKzXdz17lqrTN3/r0lrxbw0AAIDWE+iKqvNT++Tmipp/+l11fWpIru1o7v+5qPzF6XqXh3WUkyvk35yUPZtToCOqzJnRsn70rsX3jYqETK7lqDidVag/qeCWhIqj1798BQx1PTykUF9CruMuzsmkxVECRsCUvVBYsR97oaBgd6zkMWIHUrJn87Iuz5Vd50aGdjWa4nimseouOsq+Nqb44X61fWTnyqBQUnBLQvF7B+XkihW/lWLdzkUde5b82bcfe5Ya8PUOAACAhhNMxdX54F458wVN/OD08uVxuYtTav+j3avuOocW4UqTf/eaAu2RsudiqsX3jYrNybTw9HvqfHCvUl8+osyro5LlKDqUUnEqK9eyVZzOybWcsvZtRAKK3N6l9IurRzih9mZ/8abC29vV/sAuRff2KH9pRio6CvbGFR3qlSRNPTG8IlkNpuLLI9qMkLm8rPOhoeVtZn54rnZNbJIfe5b82bcfewYAAEBzKHUXuaWQaf7JS3KzxRV3nUNrsUbm15ymqFFULGRKnxqRGQspcWxQiaODKk5llX5hRLlzE9ryteOybpiPyclYcm1HgWRYN857H0iG5dw0ukmSovt6ZQRNXiQNwklbGvvu75Q8sUPRoV4ljg0uj0zLnh3TwtPvrUpWzWRYiaMDK5YF2iIrljXyl3A/9iz5s28/9gwAAIDGVypgWsFdedc5gibUQ8VCJkmaf+odzT/1zopl0QMpSTddqma7sq4uKLK7S7k3JheXmYbCuzo19+Tbq/Yb25+Sk7EWRxQ0OHsmt+5kWIVLMxuaMKuRuXlb87++tOpyorXQc/PyY99+7BkAAACNa92AaYlD0NQKNpIr3OjKv/yPVaxmcyoaMpUS6k9K0oqRTJK08J9+r64/26fClXlZV+aVPLFDclxlz9w0Q3rQVGRP9+ILo8QkvAAAAAAAtDK3YKvw+znN/Pj82gHTkutBk2s5VbkjMnAr1Q+ZBq6HTDdNLpU9MyozEVL7H+1WIBlWYWROE//+jNy8vWK7yM4OuUVH2bOkrwAAAAAA/7Fn85r6u9c2/gDH1cyPzlevIGANNQmZ7NmcnMzqtDX97GWln718y8fn35rWtW88U63yAAAAAAAAUAFlhUz5t6c1J8nZwNC70W89V84hAAAAAAAA0ETKCpkKl2ZUaIJJuAEAAAAAAFAbZr0LAAAAAAAAQPMjZAIAAAAAAIBnhEwAAAAAAADwrOp3l2tVwVSiqfffqMcupVb1+LFvP/Zcy+NsVKPVAwAAAKD6WvH7DyHTJjlpS07BVvfJA9U/VsGWk7aqfpzl49Wwt82q5rnwY99+7Fnyb98AAAAAGkc9vpfU6vuGMfxZuVU/SosJdERkJkJVP46TtmTP5qt+nBtVqrdgKq7ukwc19fhZFccznvdX7XPhx7792LPk374BAADQmkKDSfV95ZjGvvOCrCsL9S4HG1SrXGFJrb5vMJKpDPZsvmW/DFa6t+J4pine6PzYtx97lvzbNwAAAIDG0aq5AhN/AwAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPCMkAkAAAAAAACeETIBAAAAAADAM0ImAAAAAAAAeEbIBAAAAAAAAM8ImQAAAAAAAOAZIRMAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8IyQCQAAAAAAAJ4RMgEAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAzwiZAAAAAAAA4BkhEwAAAAAAADwjZAIAAAAAAIBnhEwAAAAAAADwjJAJAAAAAAAAnhEyAQAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPgvUuAABQP4GOiMxEqOrHcdKW7Nl81Y9zo1r1tlnVPhd+7NuPPQMAgOZW688vtfpcQsgEAD4V6Iio76vHZYYDVT+WU7A19u1TNfvCXcveNqua58KPffuxZwAA0Nzq8fmlVp9LCJkAwKfMREhmOKCpx4dVHE9X7TjBVELdJw/ITIRq9mW7Vr1tVrXPhR/79mPPAACgudX680stP5cQMgGAzxXH07KuLNS7jKpo5d5uxY99+7FnAADQ3Frx8wsTfwMAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAz8oKmdoe2KWt37xfgc5opesBAAAAAABAE2r4ib8jd3ar9wuHNPXYWWVfHat3OQDgG4HOqPr/8oPKXZjU5KNnSm4T3tWp1CNHlH5+RDM/faPGFXqzXPtLVzXzw3Mb3iY0kFTsrj6FBtsU2tqmQCKs/NvTmvj+6VqWXxY/9iz5t28AANCclj6HS5I9n9e1f/2s5Lirtgum4try1eOSpOJ0VqPfeq6mdZbS8JfL5S9Oy8laiu5P1bsUAAAU3Z9S2307Fbm9S858od7l1IQfe5b82zcAAI0ifFuHogc2ngUY0aCS990mGVUsqoZc21GgLaLonp6S6+P3DMp1XLklAqh6afiRTHJc5d6YVHRfrxQwJLtxTh4AwH+yr40pd25c1rW0zHhIA18/Ue+Sqs6PPUv+7RsAgEYRPzKg+JF+TT02rNzw+C23NaJB9X7xkAKdUWVfGZU9k6tRldVTeG9Wof6k4vcMKHd+YuVK01D80Bbl35pSZFdnXeorpeIhkxEylTyxQ/HD/Qp0RGTPF5Q+dVn5i9Pq+4tjmv/tu5r7x4ub2md2eFzxQ/2K7O5W/sJkpUsGAGDDimPpepdQc37sWfJv3wAANIqZn74hIxxQ96cP3DJoujFgmvjBKy0RMEmSaznKvjqm+D0DMhMhOWlreV10b48CbRHN/vzNhgqZKnq5nBEOqPeRI2r/6O0qzua08OxlWVfm1f7xO9T+sd2SJOvqwqb3m78wKdeyFdvEMDnUUcBQ+LZOSZLZFqlvLQAAAACA5uS4mv6H15U9O67uTx8oeenczQFT8drmM4dGln7pioyAqfjh/hXL4/cMyMlYyr5+6xFetVbRkUxdDw0pNNimqSeGlX1ldHl58sR2dXziTkmSdXV+0/t1LUe5N6cUHeqVfiKJK+YaVnhXp7r/2UEFEmFJUs9nP6D0CyOa/dkF/m5Akwr2xNT2wK6S67jLKAAAAKrqetAk7V81oqnVAyZJsi7Py7q2oPjRAS0883tJkpkMK7qnR+nnRxpuSqGKhUyR3V2K3dWnhecvrwiYJClz+po6PnGnnIKt4nimrP3nhscV259SeEeHCu/OVqJkVJgZC6rnc3fLCL4/QM4wDCWObZU9ldPC0+/VsToA5Qr2xNW+RsgEAAAAVF2JoCl/cbrlA6Yl6ZeuqvNP7lRoW7usy3OKH+mXETCVeelqvUtbpWIhU+L4VknSwm9XBwlOZvG6weLowvJoluiBlBLHtiq8tU1mPKRr/8Ozt7xuMnt+Qp22o+j+VNkhU2gwWdbjsDGxD2yRETJlGKun8k+c2K78xak6VFVbwVR8xX/9wI89S63R90Zrz12Y1OSjZ0quW7rteyWPVwmN/nepVn1+7NuPPQMAcKNW+Fy6UQvPvCszFlT3Zw7KThdkBk3N/OS8DLO5vu9v9m+VfeWaOj62W4l7BjRzeU7xowMqjMxvejoir88R68r6x6vgSKZuFScysqdXB0VL8/LcWJARCqjwzoxy58bV+eDedffvZosqTmQUua2j7Br7vnKs7MeifIZhKNgW8dX57z55sN4l1Jwfe5b823c5Gu5cXf/Ro0Qu/r6llW5lhyHX7VzUsWfJn3033PMeANCy/PZvTvB6ztD9mbvqXEn1OWlLufMTin1gi7KvjSmUSmjmZ29sej9enyMjX//NuttUJGQyokGZ0aCskdLzLUXv6JIkFW6Yjyn7yrXFArYkNnQMMxlSMJXwdMnV2HdeKPuxWF9kb686Pnr7quWu46o4ldX0Y2frUFVtBVNxdZ88qKnHz5Z9aWiz8WPPUmv0vdRDrdTyXG2kNydXlCSZ8dCa2wQSi+vc69tWSrXOxXp917NnqTp9+/VvDQDAklb4XLpRRiSgzk/uU6A9LDMakuu4mvvVW8pfnK53aZtSzufw9ItXFTvYp66Hh+RatjI3TVO0EbV4jlRmJJPtSJKMWIndBQwlP3ybpI0NrVpLdCglwzSUXeOWhRvh5fhYnzWWUeKeAQXaIzICN8zLZBqaf/JtX53/4njGV/1K/uxZ8m/f5Wi0c1WcyMgtOgpta5dMQ3JWj2AJb2+XJFnXKnsr+3qdi3r2LPmz70Z73gMAWler/5uzNMm3mQhp+sdvqOczB5V7a0rtf7R7xWTgrSr/5qTs2ZwCHVFlzoyW9cNYLZ4j5vqbrM+1HBWnswr1J1eOTAoY6np4SKG+xOJoltHym4kdSMmezcu6PFeBilEVRUcT3zutwjszy4vshYKmf3RO2dfG6lcXAJRSdJR9bUyBZFhtH9m5anVwS0Lxewfl5IoNd2vYsvmxZ8m/fQMA0CJuvoucPbk4Gmf+ybeVPTuu7k8fUPRAqs5VVpkrTf7da5r831/V3K8u1ruaNVVsTqaFp99T54N7lfryEWVeHZUsR9GhlIpTWbmWreJ0Tq7llLVvIxJQ5PYupV+8UqlyUSX2TE4TP3hFZltYZjSo4mS25C/GANAIZn/xpsLb29X+wC5F9/Yof2lGKjoK9sYVHeqVJE09Mbzil6JgKr48QtcImcvLOh8aWt5m5ofnatfEJvmxZ8m/fQMA0OxuDpiK1xben+TbXX3XuVYe0WSNzK85TVGjqFjIlD41IjMWUuLYoBJHB1Wcyir9wohy5ya05WvHZV0t/0RE9/XKCJot/WRpNc58Qc58od5lAMAtOWlLY9/9nZIndig61KvEsUEZAVP2QkHZs2NaePq9VXftMJNhJY4OrFgWaIusWNbIwYMfe5b82zcAAM2sVMC0iuOvoKnRVSxkkqT5p97R/FPvrFi2NGTNy3V/sf0pORlr8VdHAEBN2DO5de8gUbg0s6G7TDQyN29r/teXNP/rSxvanp6bl1/7BgCgWXX92b5bB0xLbgqaRv/qVMk73zeLjXwOv9GVf/kfq1jN5lQ0ZCol1L84jO3mkUxGLKhgZ1SB7thiIX0JmbGgijM5udkbJrAKmors6V5MIrnsCgAAAAAAX5j9v9+UEQuquJEbc1wPmjKnu5o6YGp21Q+ZBq6HTDeNZIoN9arr4f3L/3/v5++WJE3/h9eVefna8vLIzg65RUfZswx3AwAAAADAL+zZvDSb3/gDHFf5C1PVKwjrqknIZM/m5GSsFcszL19bESatJf/WtK5945lqlQcAAAAAAIAKKCtkyr89rTlJzg13YFnL6LeeK+cQAAAAAAAAaCJlhUyFSzMqMAk3AAAAAAAArjPrXQAAAAAAAACaHyETAAAAAAAAPCNkAgAAAAAAgGdVv7scAKCxBVOJpt5/ox67lFrV48e+/dgzAABobq342ZCQCQB8yklbcgq2uk8eqP6xCractFX14ywfr4a9bVY1z4Uf+/ZjzwAAoLnV4/NLrT6XEDIBgE/Zs3mNffuUzESo6sdy0pbs2XzVj7Okkr0FU3F1nzyoqcfPqjie8by/ap4LP/btx54BAEBzq+Xn8CW1+lxCyAQAPmbP5lv2S3CleyuOZ2RdWajY/qrFj337sWcAANDcWvVzOBN/AwAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPCMkAkAAAAAAACeETIBAAAAAADAM0ImAAAAAAAAeEbIBAAAAAAAAM8ImQAAAAAAAOAZIRMAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8IyQCQAAAAAAAJ4RMgEAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAzwiZAAAAAAAA4BkhEwAAAAAAADwjZAIAAAAAAIBnhEwAAAAAAADwjJAJAAAAAAAAnhEyAQAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPgvUuAAAAAJUT6IjITISqfhwnbcmezVf9ODerVX+bVc3z4ceeAQDNiZAJAACgRQQ6Iur76nGZ4UDVj+UUbI19+1RNQ4Za9rdZ1ToffuwZANC8CJkAAABahJkIyQwHNPX4sIrj6aodJ5hKqPvkAZmJUE0Dhlr1t1nVPB9+7BkA0LwImQAAAFpMcTwt68pCvcuomlbvrxQ/9gwAaD5M/A0AAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCsrZGp7YJe2fvN+BTqjla4HAAAAAAAATajhJ/6O3Nmt3i8c0tRjZ5V9daze5QAAADS1QGdU/X/5QeUuTGry0TMltwnv6lTqkSNKPz+imZ++UeMKy7dc90tXNfPDcxveJjSQVOyuPoUG2xTa2qZAIqz829Oa+P7pWpZfNr/2DQBoPA1/uVz+4rScrKXo/lS9SwEAAEALiu5Pqe2+nYrc3iVnvlDvcmrGr30DAKqn4UcyyXGVe2NS0X29UsCQbLfeFQEAAKCFZF8bU+7cuKxraZnxkAa+fqLeJdWEX/sGAFRPxUMmI2QqeWKH4of7FeiIyJ4vKH3qsvIXp9X3F8c0/9t3NfePFze1z+zwuOKH+hXZ3a38hclKlwwAAAAfK46l611CXfi1bwBA9VQ0ZDLCAfV+6bDC29qVuzil7PC4gj0xtX/8DuXfmpIkWVcXNr3f/IVJuZat2IEUIRMakpkIKXF8m6JDvZKkyJ09i891Bt4BTS16MKXEH26TJMX/YJvmn3xbzgKXlAAAAAClVDRk6npoSKHBNk09MazsK6PLy5MntqvjE3dKkqyr85ver2s5yr05tfgF/ifiizsaitkeUd9/dY/MtrAM05AkdXxst4KpuGb+Q+nJNwE0vo4H9yh5fJtcZ/EfncTRAcWGejX+1y/Kns7VuTrAu2BPTG0P7Cq5jjsIAwCAclQsZIrs7lLsrj4tPH95RcAkSZnT19TxiTvlFGwVxzNl7T83PK7Y/pTCOzpUeHe2EiUDFdF+/06ZydBywLQkcWRAmRevqvDOTH0KA1C20NY2JY8vjmBaem0bpiEzFlT7R2/X9BOv17M8oCKCPXG1rxEyAQAAlKNiIVPi+FZJ0sJv31u1zslYkqTi6PuXDyX/6W2KHUgpmIrLtRzlL01r7pcXZc+U/nU4e35Cnbaj6P5U2SFTaDBZ1uOAW4nd1ScjsPpGja7tKHHvgNxCsQ5V1U4wFV/xX7/wa99+ET+2Va7trHptGwFTsQMpLfjg3xM/PsdboefN1J67MKnJR8+UXLd0u/tKHq8SGv1vU436/NgzgM1phX+/NsuPPTcC68r60x9VcCRTt4oTmZKXEJhtkVUFRXZ1Kv3cZRVG5mQETLX/8R3q+fzdGvufX5Cc1dfDudmiihMZRW7rKLvGvq8cK/uxwGYZAVPxwwOKHx6odyk10X3yYL1LqAu/9u1nRijgq39P/Pgc92PP5Wq4c3X9I6Rh3GKbpZVu5edfqNv5qGPfDfccAHzMj69HP/ZcTyNf/82621QkZDKiQZnRoKyR0vMtRe/okiQVbpiP6eZfzmZ+fF79/+0HFeyLq3ht9Z0uzGRIwVRCC0+vHim1UWPfeaHsxwJrabtvp6JDvSVHM03/8FxZ85A1k2Aqru6TBzX1+NmyL4dtRn7t2y+CqYS6Tx5Ytdy1HeXemtL8k2/Xoara8uNzvBV6XuqhVmp9rtbrz8ktjh4246E1twkkFte5ucqPNK7G+djI37SefTfz6wVoFa3w79dm+bHnZlGZkUy2I0kyYiV2FzCU/PBtkm49tMqMLj7WyZT+hy86lJJhGsoOj5dd5kaGdgGbNfPzN9W3vWN54m/XcWWYhtIvX1Xmpav1Lq9miuMZX77G/Np3q7OuLGjhto7lib+XXttOtqjZn13w1cTffnyO+7HncjXauSpOZOQWHYW2tUumUXJ0fHh7uyTJKvGjpufj1+l81LPvRnsOAH7mx9ejH3tudBUJmVzLUXE6q1B/UsEtCRVHr//jFTDU9fCQQn0JuY67OCdTKYbU/sd3KHd+Qs5cvuQmsQMp2bN5WZfnKlEyUDHOXF5j33lBiT/Yqsgd3XLzRWVOjyr72uj6DwbQsGZ/dkH5t6cVPzwgMx5U/uK00qdG5CwU6l0agLUUHWVfG1P8cL/aPrJT87++tGJ1cEtC8XsH5eSKyr5e/g+XDcevfQMAGk7F5mRaePo9dT64V6kvH1Hm1VHJchQdSqk4lZVr2SpO5+RaTsnHdn5qn4KdUY3/ry+VXG9EAorc3qX0i1cqVS5QUU7a0vxv3tH8b96pdykAKih3dly5s3whA5rJ7C/eVHh7u9of2KXo3h7lL81IRUfB3riiQ72SpKknhldcNhZMxZdH3hshc3lZ50NDy9vM/PBc7Zoog1/7BgA0loqFTOlTIzJjISWODSpxdFDFqazSL4wod25CW752fM15aTo+uUeR3V2a+N7LctJWyW2i+3plBE3lPFwqBwAAgNbnpC2Nffd3Sp7YoehQrxLHBmUETNkLBWXPjmnh6fdkXV05ut5MhpU4uvJGHYG2yIpljR62+LVvAEBjqVjIJEnzT72j+afeWbEseiAlqfR8SB0P7lF0b68mvvey7NnSl8lJUmx/Sk7GWvxFBgAAAGWzZ3Lr3h2mcGlmQ3eQaVRu3tb8ry+tumxsLc3e7xK/9g0AaByrb4dVYaH+pCStGsnU8eAexe/eounHh+VajsxkWGYyLAVuuvdq0FRkT7dy5ydKTmIIAAAAAACA+qvoSKZSQgPXQ6abRjIlj2+TJKX+y6Mrlo9/72UVbhixFNnZIbfoKMucGAAAAAAAAA2rJiGTPZuTk1k539JGh+bm35rWtW88U43SAAAAAAAAUCFlhUz5t6c1J8m54e4Uaxn91nPlHAIAAAAAAABNpKyQqXBpZsUlbQAAAAAAAPC3qk/8DQAAAAAAgNZHyAQAAAAAAADPqj7xNwAAAGormEo09f4b/fg3q0U9fuwZANB8CJkAAABahJO25BRsdZ88UP1jFWw5aWv9DSt5zBr2t1nVOh9+7BkA0LwImQAAAFqEPZvX2LdPyUyEqn4sJ23Jns1X/Tg3qmR/wVRc3ScPaurxsyqOZzzvr1rnw489AwCaFyETAABAC7Fn8y39xb/S/RXHM7KuLFRsf9Xgx54BAM2Jib8BAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPCMkAkAAAAAAACeETIBAAAAAADAM0ImAAAAAAAAeEbIBAAAAAAAAM8ImQAAAAAAAOAZIRMAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8IyQCQAAAAAAAJ4RMgEAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAzwiZAAAAAAAA4BkhEwAAAAAAADwjZAIAAAAAAIBnhEwAAAAAAADwjJAJAAAAAAAAnhEyAQAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGfBehcAAAAAABsV6IjITISqfhwnbcmezVf9ODeqVW+bVY9zAaA5ETIBAAAAaAqBjoj6vnpcZjhQ9WM5BVtj3z5Vs3Cllr1tVq3PBYDmRcgEAAAAoCmYiZDMcEBTjw+rOJ6u2nGCqYS6Tx6QmQjVLFipVW+bVY9zAaB5ETIBAAAAaCrF8bSsKwv1LqMqWrk3AK2Pib8BAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGdlhUxtD+zS1m/er0BntNL1AAAAAAAAoAk1/MTfkTu71fuFQ5p67Kyyr47VuxwAAAAADSrQGVX/X35QuQuTmnz0TMltwrs6lXrkiNLPj2jmp2/UuEJvlmt/6apmfnhuw9uEBpKK3dWn0GCbQlvbFEiElX97WhPfP13L8gH4QMNfLpe/OC0naym6P1XvUgAAAACg6UT3p9R2305Fbu+SM1+odznAhgU6Igr2Jzb+ANNQZE939QrCuhp+JJMcV7k3JhXd1ysFDMl2610RAAAAADSN7Gtjyp0bl3UtLTMe0sDXT9S7JGBDOv7kToV3dWriB6+oeG3h1hubhrr+fL9iB1Ma/atTsqdztSkSK1Q8ZDJCppIndih+uF+Bjojs+YLSpy4rf3FafX9xTPO/fVdz/3hxU/vMDo8rfqhfkd3dyl+YrHTJAAAAANCyimPpepcAlGX6R+fV+8VD6v3ioVsHTTcETFOPDRMw1VFFL5czwgH1PnJE7R+9XcXZnBaevSzryrzaP36H2j+2W5JkXV0nfSwhf2FSrmUrdoBL5oBGY0QWs2ojFKhzJQAqxjS4uQdamhEyFejiOQ4Ajc7NFTXxg1dkz+TU+8VDCvYnV290U8CUGx6vfaFYVtGRTF0PDSk02KapJ4aVfWV0eXnyxHZ1fOJOSZJ1dX7T+3UtR7k3pxQd6pV+Iokr5oC6M8IBdTy4R/G7t0iSev6LQ0o/e1lzT74tObxIgWYVO9Svjj/erUBbRJLU+WdDmvr7s7Ins3WuDKgAQ2q7f5eSJ7bLvP4jSdsf7db0Y8Nyc8U6F4dKCvbE1PbArpLrCNGB5rIUNN04ommZIQKmBlOxkUyR3V2K3dWn9O9GVgRMkpQ5fU2S5BRsFcczZe0/NzyuQDKs8I4Oz7UC8K7rMwcUP9QvI7D4NmKGAkp+eIfaP3p7nSsDUK7ovh51/+f7ZSbDy8tCWxJKPXJERpjRimh+bR/Zqbb7dy4HTJIUvaNbPf/8rjpWhWoI9sTV/sCukv9LHB2od3kANmnViKaemCSp/aO7CZgaTMVGMiWOb5UkLfz2vVXrnIwlSSqOLiyPQkp8aLsS9wws/pLguLKuLGj2VxdlXZ4ruf/s+Ql12o6i+1MqvDtbqbIBlCHYl1Bsb++q5YZhKPnBbZp/6h25BbsOlQHwInnfTrmOK8M0lpcZAVNmW1ixQ1uUeeFKHasDPAouzhtqGMaKxYZpKHJ7l0Jb22SNbH7EPRpT7sKkJh89U3JdeFenUo8cqXFFALy6cURT56f2SZIid3Rr6u/PEjA1kIqFTJHd3SpOZEpOsGVeH3JvXXl/PiZ7JqfZX7yl4mRWRtBQ8oPb1fuFuzX6Pz4nJ7t6uLKbLao4kVHktvJHMoUGS1y/CWDTInesfVtQIxRQZG93y19aE0zFV/wXaAWhgeSKgGmZ4ypye9eaPwS1Cl7Xrc1sj8qMrv3RN7qvV3Jb+3LvVniO17r2Wh5vQ8e6/hQ1SrxVL1taWeHnczM/b1pdK7y2N2P2l2+q51/cLUnKnLkmezrLd/0auTHTWUtFQiYjGpQZDa7560/0ji5JUuGG+ZhuThpnf/mWEse2KtifVOHSzKp9mMmQgqmEFp5ePVJqo/q+cqzsxwLYuJ7P+Oeyg+6TB+tdAlB1RsBU/ANbFP/AlnqXUhO8rv1p6VIqP+A5vnGNdq6c63OHmfHQmtsEEovrKj3PWKOdC6zmx79R4vCAEoe5BLZWRr7+m3W3qcxIJtuRJBmxErsLGEp++DZJt0i9AoYS9w7KyViy1rglYXQoJcM0lPUwDG7sOy+U/VgAK3V95qCCndHlOZkkyXVc5S5Oaf5XF+tYWW0EU3F1nzyoqcfPlj3XHNBoYgf71HbfzhXLXMeVHFcT/9sZudcvf29VvK5bX9v9uxTd17tixJ5rO7Ln85r6P15r+ZvLtMJzfKmHWqnludpIb8WJjNyio9C2dsk0St5sJby9XZJkXUtXtL5mft60ulZ4bW+IsTgHU+SObs09eVFOuqDkP7lNgWRYMz85r2KLX0nRLCoSMrmWo+J0VqH+pIJbEiqOXn9DCxjqenhIob6EXMddnJPpBuGdHer53N0yQgE58wVN/M0rcktcKidJsQMp2bN5T0P1NzK0C8DGTP7NK+r53N0K9SWWl+UvTWv67/11h57ieIb3FrQM6+qCjKCpxAe3L38Jd3NFTT12VoW3putcXe3wum5d00+8rq7PHFgxr6A9ndPk357x1ZcTnuMb13Dnqugo+9qY4of71faRnZr/9aUVq4NbEorfOygnV1T29crOUdNw5wKrtPTfyDTU9ef7FdndtWIOpuzZCfV+8ZA6HtyriR+8ouIag1ZQOxWbk2nh6ffU+eBepb58RJlXRyXLUXQopeJUVq5lqzidk2s5Kx5TuDyvsf/ldzLjISXuHVT3Zw5q/K9fXJ4ofIkRCShye5fSLzLhKNAo7Omcxv6n5xXe2alAZ0TF0bSsq7ypA03NlWZ/8ZYW/tPvFd7ZKTdfVO6taanorP9YoAm4BVtTf/uqgv0JhfqTsufyi9M0tPgIJrSW2V+8qfD2drU/sEvRvT3KX5qRio6CvXFFhxYD1KknVv7oF0zFl68uMULm8rLOh4aWt5n54bnaNQFsxvWAqdRd5G6cDLz3i4cImhpAxUKm9KkRmbGQEscGlTg6qOJUVukXRpQ7N6EtXzsu62qJ+ZqKjuyprOyprGYuz2nL144rfnRg1bxL0X29MoImM8YDDajwzky9SwBQYfZsXtkzo/UuA6ia4rW0ihW+lAioFSdtaey7v1PyxA5Fh3qVODYoI2DKXigoe3ZMC0+/t+qHPzMZVuLoynlrAm2RFcsImdCQbhEwLSFoaiwVC5kkaf6pdzT/1DsrlkUPpCRt8FI1QzKC5qrFsf0pORlrMaUHAAAAgBLsmdy6E9MWLs1saPLaRubmbc3/+tKqy+XW0go9w586P7n3lgHTkpuDpvHvvih7ZvWd71F9FQ2ZSgn1L95K8OaRTO0f263cuQnZc3mZsaASx7cp0B5R9uzYTRWaiuzpXnxClZjYDgAAAAAAtJ7My1eVuzC5oaualoKmxPGtsmcJmOql+iHTwPWQ6aaRTIH2iLo+fUCBZFhOxlJhZE7j/+7lVbPhR3Z2yC06yp7lUjkAAAAAAPyi8O7sprZ3c0Ut/H/vVqkabERNQiZ7NrdqMu/pf3h9Q4/PvzWta994phqlAQAAAAAAoELKCpnyb09rTpKzgduUj37ruXIOAQAAAAAAgCZSVshUuDSzeLtXAAAAAAAAQNLqW7kBAAAAAAAAm0TIBAAAAAAAAM8ImQAAAAAAAOBZ1e8uBwAAAACVFEwlmnr/jXrsUhqtHgCNjZAJAAAAQFNw0pacgq3ukweqf6yCLSdtVf04y8erYW+bVetzAaB5ETIBAAAAaAr2bF5j3z4lMxGq+rGctCV7Nl/14yypZG/BVFzdJw9q6vGzKo5nPO+v1ucCQPMiZAIAAADQNOzZfMsGHpXurTiekXVloWL7A4D1MPE3AAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPCMkAkAAAAAAACeETIBAAAAAADAM0ImAAAAAAAAeEbIBAAAAAAAAM8ImQAAAAAAAOAZIRMAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8IyQCQAAAAAAAJ4RMgEAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAzwiZAAAAAAAA4BkhEwAAAAAAADwjZAIAAAAAAIBnhEwAAAAAAADwjJAJAAAAAAAAnhEyAQAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPAsWO8CAAAAAAC4WaAjIjMRqvpxnLQlezZf9eMAfkDIBAAAAABoKIGOiPq+elxmOFD1YzkFW2PfPkXQBFQAIRMAAAAAoKGYiZDMcEBTjw+rOJ6u2nGCqYS6Tx6QmQgRMgEVQMgEAAAAAGhIxfG0rCsL9S4DwAYx8TcAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8KyskKntgV3a+s37FeiMVroeAAAAAAAANKGGH8kUubNbW795v2If6Kt3KQAAAACABhHojGrrN+9Xz+fvXnOb8K5Obf3m/er85N4aVgb4V8OHTPmL03KylqL7U/UuBQAAAACAmgt0RNT9z++SmQht7AGmoc4/26fI7q7qFgbcpOFDJjmucm9MKrqnRwoY9a4GAAAAAICaMsIBhbe3q/eLh9cPmkxDXX8+pPjhfhnRYG0KBK6reMhkhEy1fWSntnztuAb/+3+qLf/NHyp5YrtCA0lt/eb9av/47k3vMzs8LjMaVGR3d6XLBQAAAACgoRXHM5r4/mmZidCtg6brAVPsYJ+mHhtWbni8toXC9yoaMhnhgHofOaL2j96u4mxOC89elnVlXu0fv0PtH1sMl6yrC5veb/7CpFzLVuwAl8wBqL/QtnYl/nD74v/dn6xzNQAqwYyHFLu7X5IU3Z+SEQ7UuSKgsgLdMcXvHZQkhXd1SSZXCLQq3s9a17pBkyECJtRdRcfOdT00pNBgm6aeGFb2ldHl5ckT29XxiTslSdbV+U3v17Uc5d6cUnSoV/qJJLdCBQPAJnU8uEfJ49vk2o4kqevh/Qrv6tLMj87x3gQ0qfDOTvV8/m4ZwcXf3to+slOJewY1/r2XZU9m61wd4F383kF1fmrv8r9TnX9yp+If2KKJvzktN2/XtzhUlF/fz4I9MbU9sKvkula7I/pS0NT7pcPq/eJhTfzg9PK69o/uVmR3FwET6qpiI5kiu7sUu6tP6d+NrAiYJClz+pokySnYKo5nytp/bnhcgWRY4R0dnmsFgHJE9/cqeXybJMkIvP/2mTg6oNjdW+pVFgAvAoa6/9lBGUFTxvWRHYZhyEyE1PXwUJ2LA7wLdEXV+cm9Mgxj+TkuSaGtbWpf40s5mpSP38+CPXG1P7Cr5P8SRwfqXV7F3TyiyYgtjh0hYEIjqNhIpsTxrZKkhd++t2qdk7EkScXRhZK/9Hd8co+Sf7BNMz97Q+lTIyX3nz0/oU7bUXR/SoV3Z8uqMTTIZS0Aypf4w21yHUeGuTKfdx1XiePbVBxL16kyAOUK7ehQIBletdwImIrc1qnI3h458/k6VAZURmyNL9iGaSh+z4Ayr1yrcUWollZ7Pwum4hveNndhUpOPnim5LryrU6lHjlT0eI1i5mdvqPM/26eef3G3JGnh1GXZ01m+96JqrCvrT39UsZApsrtbxYmM7OncqnVmW2TNgqJ7exTe3iF79tZveG62qOJERpHbyh/J1PeVY2U/FgDWYpiGIjs6eI8BWlDv5+6udwlA1ZjREP92+QjvZ7fWffJgvUvwrO1DO9T2oR31LgMtbOTrv1l3m4qETEY0KDMalDVSer6l6B1dkqTCTfMxmcmQOj65V5N/e0Y9n/3ALY9hJkMKphJaeHr1SKmNGvvOC2U/FgDi9wwqcWzrissNpMWRTJmXryp96nKdKgNQLiMRUu/nDq16XUuSnbU0+e9fkRwmXEPzCu3oUNeDe1ctdx1XhZE5zf70jTpUhWpotfezYCpe0+Bn6vGzZU/tUhfG+3MwLTz3eyWODsrJWJr+8Xm5uWK9q4OPVWYk0/UJcJeuBV0hYCj54dskrR7J1PXQkNLPXVZxdP1LTKJDKRmmoayH60s3MrQLANYy//9eUmyoV2YyvDwnk2s7crJFzT35tpz5Qp0rBFCO9LO/V+JDi3eMNAxDruPKMA3N/fKirMubv2EJ0EisqwuK37VF4ds6lsMH13El19Xcz9/k83GL4f2sfMXxTPO8HkxDXX8+tGIOpszvrqr3S4fV+ad7NPGD03LSVr2rhE9VZOJv13JUnM4q1J9UcEvi/RUBQ10PDynUl5DruItzMl2XOL5VRjighWc2NjIpdiAlezYv6/JcJUoGgE1zMpbG/+1Lypy+JidXlJMvKntmVON//SIBE9DEZn/5lmZ//qbsqazcoiPr2oIm/8/XlHnxSr1LA7xzpclHX9HC0+/JXijItWzlL05p4t+9rMLv+Vzdang/84HrAVPsYN+KSb5vngzcTITqXCj8qmJzMi08/Z46H9yr1JePKPPqqGQ5ig6lVJzKyrVsFadzcq3FEU/BVFxt9+/S+L95cUO3/DYiAUVu71KaN0cAdWbP5jXzo/Oa+dH5epcCoFJcKf3cZaWf45JXtCbXcjT3q4ua+9XFepeCauP9rLWtETAtWQqaer90WL1fPMyIJtRFRUYySVL61IjmnnxbbsFW4uigInt6lH5hRLP/1wUZoYCsG+ZjCm9vlxkPact/fVyD/+o+Df6r+xTsiqnjT/co9ZV7V+07uq9XRtDkVowAAAAAAP9ZJ2Bawogm1FvFRjJJ0vxT72j+qXdWLIseSElaOR9S9vUJFUZWTsLd+/lDixPnvnR11X5j+1NyMpbyl2YqWS4AAAAAoEnZM7l173ZVuDSzoTtiNbrwzk7FDtw6YFpy44imxB9s1fxv3qlNkYAqHDKVEupPStKKkUxurqjiTTPeu44jez4veyp7U4WmInu6F19ITXQ3BAAAAAAAKqHw9rRG/+qU7JnchrYvjmc0/m9elD2Xr3JlwErVD5kGrodMZc7UH9nZIbfoKHuWS+UAAAAAAP600YBpeftZAibUXk1CJns2Jydz6wnHRr/1XMnl+bemde0bz1SjNAAAAAAAAFRIWSFT/u1pzUlybrrkrZS1wiMAAAAAAAC0jrJCpsKlGRWYhBsAAAAAAADXmfUuAAAAAAAAAM2PkAkAAAAAAACeVX3ibwAAAAAAyhFMJZp6/4DfEDIBAAAAABqKk7bkFGx1nzxQ/WMVbDnpW98NHcDGGMOflVvvIgAAAAAAuFGgIyIzEar6cZy0JXs2X/XjAH7ASCYAAAAAQMOxZ/OEP0CTYeJvAAAAAAAAeEbIBAAAAAAAAM8ImQAAAAAAAOAZIRMAAAAAAAA8I2QCAAAAAACAZ4RMAAAAAAAA8IyQCQAAAAAAAJ4RMgEAAAAAAMAzQiYAAAAAAAB4RsgEAAAAAAAAzwiZAAAAAAAA4BkhEwAAAAAAADwjZAIAAAAAAIBnhEwAAAAAAADwjJAJAAAAAAAAnhEyAQAAAAAAwDNCJgAAAAAAAHhGyAQAAAAAAADPCJkAAAAAAADgGSETAAAAAAAAPCNkAgAAAAAAgGeETAAAAAAAAPCMkAkAAAAAAACe/f/+k2fQfCKcZwAAAABJRU5ErkJggg==", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"color-blind\")" ] }, + { + "cell_type": "markdown", + "id": "50f4eb75", + "metadata": {}, + "source": [ + "#### Plot circuit with custom style" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 12, "id": "56f4f3cc-6864-4ef2-aa19-9c209fc217e5", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "custom_style = {\n", " \"facecolor\" : \"#6497bf\",\n", @@ -233,10 +395,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 13, "id": "f5077d51", "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "q0: ─[─H─U1───]─U1─U1─U1─────────────────────────────────────x───M─\n", + "q1: ─[───o──H─]─|──|──|──[─U1───]─U1─U1──────────────────────|─x─M─\n", + "q2: ────────────o──|──|──[─o──H─]─|──|──[─U1───]─U1──────────|─|───\n", + "q3: ───────────────o──|───────────o──|──[─o──H─]─|──[─U1───]─|─x───\n", + "q4: ──────────────────o──────────────o───────────o──[─o──H─]─x─────\n" + ] + } + ], "source": [ "from qibo.models import QFT\n", "c = QFT(5)\n", @@ -244,12 +418,31 @@ "print(c.fuse().draw())" ] }, + { + "cell_type": "markdown", + "id": "c30e59fc", + "metadata": {}, + "source": [ + "#### Plot fused circuit with built-in style" + ] + }, { "cell_type": "code", - "execution_count": null, + "execution_count": 14, "id": "259e5c4f", "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "ax, fig = plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\")" ] From 33bc78d0abf45ff0ac7ffba5f8923171e8f155b3 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 21:09:27 +0200 Subject: [PATCH 080/116] deep style review on example notebook --- .../qibo-draw-circuit-matplotlib.ipynb | 57 +++++-------------- 1 file changed, 13 insertions(+), 44 deletions(-) diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index e66a93a73d..fceeb97ebe 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -56,7 +56,9 @@ "# Qibo libraries\n", "import qibo\n", "from qibo import gates, models\n", - "from qibo.models import Circuit\n", + "from qibo.models import Circuit, QFT\n", + "\n", + "# new plot function based on matplotlib\n", "from qibo.ui import plot\n", "\n", "%matplotlib inline" @@ -116,16 +118,6 @@ "id": "ea99c3d4-e36f-46ca-81c4-c8f10d6bcbe5", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 3, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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", @@ -138,7 +130,7 @@ } ], "source": [ - "plot(ansatz, scale = 0.6, cluster_gates = False)" + "plot(ansatz, scale = 0.6, cluster_gates = False);" ] }, { @@ -147,16 +139,6 @@ "id": "81b65ea2-06a0-437d-b8f3-2ac176ea9b25", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 4, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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", @@ -169,7 +151,7 @@ } ], "source": [ - "plot(ansatz, scale = 0.7, cluster_gates = True)" + "plot(ansatz, scale = 0.7, cluster_gates = True);" ] }, { @@ -212,16 +194,6 @@ "id": "f68eb0c1-9ae4-436b-948d-74d24d782a80", "metadata": {}, "outputs": [ - { - "data": { - "text/plain": [ - "(,
)" - ] - }, - "execution_count": 6, - "metadata": {}, - "output_type": "execute_result" - }, { "data": { "image/png": "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", @@ -234,7 +206,7 @@ } ], "source": [ - "plot(c)" + "plot(c);" ] }, { @@ -256,9 +228,9 @@ } ], "source": [ - "from qibo.models import QFT\n", "c = QFT(5)\n", "c.add(gates.M(qubit) for qubit in range(2))\n", + "\n", "print(c.draw())" ] }, @@ -288,7 +260,7 @@ } ], "source": [ - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\")" + "plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\");" ] }, { @@ -309,7 +281,7 @@ } ], "source": [ - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\")" + "plot(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\");" ] }, { @@ -330,7 +302,7 @@ } ], "source": [ - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\")" + "plot(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\");" ] }, { @@ -351,7 +323,7 @@ } ], "source": [ - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=\"color-blind\")" + "plot(c, scale = 0.8, cluster_gates = True, style=\"color-blind\");" ] }, { @@ -390,7 +362,7 @@ " \"controlcolor\" : \"#360000\"\n", "}\n", "\n", - "ax, fig = plot(c, scale = 0.8, cluster_gates = True, style=custom_style)" + "plot(c, scale = 0.8, cluster_gates = True, style=custom_style);" ] }, { @@ -412,9 +384,6 @@ } ], "source": [ - "from qibo.models import QFT\n", - "c = QFT(5)\n", - "c.add(gates.M(qubit) for qubit in range(2))\n", "print(c.fuse().draw())" ] }, @@ -444,7 +413,7 @@ } ], "source": [ - "ax, fig = plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\")" + "plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\");" ] }, { From 0283e1f38a93586ce566a313893ed3a134889c94 Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 21:37:06 +0200 Subject: [PATCH 081/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 6 ------ 1 file changed, 6 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index d42a78c7d9..c711adf1d2 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -546,12 +546,6 @@ def _make_cluster_gates(gates_items): return cluster_gates -def _build_path(filename): - file_path = path.abspath(__file__) # full path of current file - dir_path = path.dirname(file_path) # full path of the directory from file - return path.join(dir_path, filename) # absolute file path of given file - - def _check_list_str(substrings, string): return any(item in string for item in substrings) From 8f9706cf5eafd0d06b0da1ec882ec2414daa446b Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 21:37:20 +0200 Subject: [PATCH 082/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index c711adf1d2..bf0d89a955 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -17,7 +17,7 @@ STYLE = json.loads((UI / "styles.json").read_text()) SYMBOLS = json.loads((UI / "symbols.json").read_text()) -plot_params = { +PLOT_PARAMS = { "scale": 1.0, "fontsize": 14.0, "linewidth": 1.0, From f6d59aa5d4c2126f61cca10878ffc7c7f37398ea Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 1 Aug 2024 19:37:28 +0000 Subject: [PATCH 083/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 1 - 1 file changed, 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index bf0d89a955..ce324bee91 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -3,7 +3,6 @@ # https://github.com/rpmuller/PlotQCircuit # import json -from os import path from pathlib import Path import matplotlib From d4b742066fb4443d06aa5d73b233a59b7f12fcb4 Mon Sep 17 00:00:00 2001 From: Sergio Date: Thu, 1 Aug 2024 21:41:35 +0200 Subject: [PATCH 084/116] Update src/qibo/ui/mpldrawer.py Co-authored-by: Alessandro Candido --- src/qibo/ui/mpldrawer.py | 16 +++++++--------- 1 file changed, 7 insertions(+), 9 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index ce324bee91..a9e88fb11a 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -620,15 +620,13 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ax.figure A Figure object (type: matplotlib.figure.Figure) """ - if style is not None: - if type(style) is dict: - plot_params.update(style) - else: - plot_params.update( - STYLE[style] if style in list(STYLE.keys()) else STYLE["default"] - ) - else: - plot_params.update(STYLE["default"]) + params = PLOT_PARAMS.copy() + if not isinstance(style, dict): + try: + style = STYLE.get(style) + except AttributeError: + style = STYLE["default"] + params.update(style) inits = list(range(circuit.nqubits)) From 5cdd0955649ea238989e82d72a4d60b6e94b21c9 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Thu, 1 Aug 2024 22:31:32 +0200 Subject: [PATCH 085/116] review global params style dict to local variable --- src/qibo/ui/mpldrawer.py | 21 +++++++++++---------- 1 file changed, 11 insertions(+), 10 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index a9e88fb11a..84dc252f66 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -34,7 +34,7 @@ } -def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwargs): +def _plot_quantum_schedule(schedule, inits, plot_params, labels=[], plot_labels=True, **kwargs): """Use Matplotlib to plot a quantum circuit. schedule List of time steps, each containing a sequence of gates during that step. Each gate is a tuple containing (name,target,control1,control2...). @@ -44,6 +44,7 @@ def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwarg kwargs Can override plot_parameters """ + plot_params.update(kwargs) scale = plot_params["scale"] @@ -75,7 +76,7 @@ def _plot_quantum_schedule(schedule, inits, labels=[], plot_labels=True, **kwarg return ax -def _plot_quantum_circuit(gates, inits, labels=[], plot_labels=True, **kwargs): +def _plot_quantum_circuit(gates, inits, plot_params, labels=[], plot_labels=True, **kwargs): """Use Matplotlib to plot a quantum circuit. gates List of tuples for each gate in the quantum circuit. (name,target,control1,control2...). Targets and controls initially @@ -85,6 +86,7 @@ def _plot_quantum_circuit(gates, inits, labels=[], plot_labels=True, **kwargs): kwargs Can override plot_parameters """ + plot_params.update(kwargs) scale = plot_params["scale"] @@ -114,14 +116,13 @@ def _plot_quantum_circuit(gates, inits, labels=[], plot_labels=True, **kwargs): return ax -def _plot_lines_circuit(inits, labels, plot_labels=True, **kwargs): +def _plot_lines_circuit(inits, labels, plot_params, plot_labels=True, **kwargs): """Use Matplotlib to plot a quantum circuit. inits Initialization list of gates labels List of qubit labels kwargs Can override plot_parameters """ - plot_params.update(kwargs) scale = plot_params["scale"] @@ -620,14 +621,14 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): ax.figure A Figure object (type: matplotlib.figure.Figure) """ - params = PLOT_PARAMS.copy() + params = PLOT_PARAMS.copy() if not isinstance(style, dict): try: - style = STYLE.get(style) + style = STYLE.get(style) if (style is not None) else STYLE["default"] except AttributeError: style = STYLE["default"] - params.update(style) + params.update(style) inits = list(range(circuit.nqubits)) labels = [] @@ -668,11 +669,11 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): if cluster_gates: gates_cluster = _make_cluster_gates(gates_plot) - ax = _plot_quantum_schedule(gates_cluster, inits, labels, scale=scale) + ax = _plot_quantum_schedule(gates_cluster, inits, params, labels, scale=scale) return ax, ax.figure - ax = _plot_quantum_circuit(gates_plot, inits, labels, scale=scale) + ax = _plot_quantum_circuit(gates_plot, inits, params, labels, scale=scale) return ax, ax.figure else: - ax = _plot_lines_circuit(inits, labels, scale=scale) + ax = _plot_lines_circuit(inits, labels, params, scale=scale) return ax, ax.figure From 92c11de29eb550052d8bedb5267df790e9b3767d Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Thu, 1 Aug 2024 20:33:22 +0000 Subject: [PATCH 086/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 12 +++++++++--- 1 file changed, 9 insertions(+), 3 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 84dc252f66..37d028c874 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -34,7 +34,9 @@ } -def _plot_quantum_schedule(schedule, inits, plot_params, labels=[], plot_labels=True, **kwargs): +def _plot_quantum_schedule( + schedule, inits, plot_params, labels=[], plot_labels=True, **kwargs +): """Use Matplotlib to plot a quantum circuit. schedule List of time steps, each containing a sequence of gates during that step. Each gate is a tuple containing (name,target,control1,control2...). @@ -76,7 +78,9 @@ def _plot_quantum_schedule(schedule, inits, plot_params, labels=[], plot_labels= return ax -def _plot_quantum_circuit(gates, inits, plot_params, labels=[], plot_labels=True, **kwargs): +def _plot_quantum_circuit( + gates, inits, plot_params, labels=[], plot_labels=True, **kwargs +): """Use Matplotlib to plot a quantum circuit. gates List of tuples for each gate in the quantum circuit. (name,target,control1,control2...). Targets and controls initially @@ -669,7 +673,9 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): if cluster_gates: gates_cluster = _make_cluster_gates(gates_plot) - ax = _plot_quantum_schedule(gates_cluster, inits, params, labels, scale=scale) + ax = _plot_quantum_schedule( + gates_cluster, inits, params, labels, scale=scale + ) return ax, ax.figure ax = _plot_quantum_circuit(gates_plot, inits, params, labels, scale=scale) From 5347400e3deb281ff1c182fbfe1abc82166f8a0e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 2 Aug 2024 09:44:39 +0200 Subject: [PATCH 087/116] plot circuit function code reduction and unification --- .../qibo-draw-circuit-matplotlib.ipynb | 23 ++- src/qibo/ui/mpldrawer.py | 156 +++++++----------- 2 files changed, 84 insertions(+), 95 deletions(-) diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index fceeb97ebe..f028075f96 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -400,6 +400,27 @@ "execution_count": 14, "id": "259e5c4f", "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"quantumspain\");" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "a9f50b42", + "metadata": {}, "outputs": [ { "data": { @@ -419,7 +440,7 @@ { "cell_type": "code", "execution_count": null, - "id": "a9f50b42", + "id": "fa46e167", "metadata": {}, "outputs": [], "source": [] diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 37d028c874..9afd47cde0 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -47,39 +47,19 @@ def _plot_quantum_schedule( kwargs Can override plot_parameters """ - plot_params.update(kwargs) - scale = plot_params["scale"] - - # Create labels from gates. This will become slow if there are a lot - # of gates, in which case move to an ordered dictionary - if not labels: - labels = [] - for i, gate in _enumerate_gates(schedule, schedule=True): - for label in gate[1:]: - if label not in labels: - labels.append(label) - - nq = len(labels) - nt = len(schedule) - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, nt * scale, scale, dtype=float) - - ax, _ = _setup_figure(nq, nt, gate_grid, wire_grid, plot_params) - - measured = _measured_wires(schedule, labels, schedule=True) - _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) - - if plot_labels: - _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - - _draw_gates( - ax, schedule, labels, gate_grid, wire_grid, plot_params, measured, schedule=True + return _plot_quantum_circuit( + schedule, + inits, + plot_params, + labels=labels, + plot_labels=plot_labels, + schedule=True, + **kwargs ) - return ax def _plot_quantum_circuit( - gates, inits, plot_params, labels=[], plot_labels=True, **kwargs + gates, inits, plot_params, labels=[], plot_labels=True, schedule=False, **kwargs ): """Use Matplotlib to plot a quantum circuit. gates List of tuples for each gate in the quantum circuit. @@ -98,49 +78,42 @@ def _plot_quantum_circuit( # of gates, in which case move to an ordered dictionary if not labels: labels = [] - for i, gate in _enumerate_gates(gates): + for i, gate in _enumerate_gates(gates, schedule=schedule): for label in gate[1:]: if label not in labels: labels.append(label) nq = len(labels) ng = len(gates) + wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, ng * scale, scale, dtype=float) - ax, _ = _setup_figure(nq, ng, gate_grid, wire_grid, plot_params) + EMPTY_GATES = True if ng == 0 else False - measured = _measured_wires(gates, labels) + gate_grid = np.arange(0.0, (nq if EMPTY_GATES else ng) * scale, scale, dtype=float) + ax, _ = _setup_figure( + nq, (nq if EMPTY_GATES else ng), gate_grid, wire_grid, plot_params + ) + + measured = ( + None if EMPTY_GATES else _measured_wires(gates, labels, schedule=schedule) + ) _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) if plot_labels: _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) - _draw_gates(ax, gates, labels, gate_grid, wire_grid, plot_params, measured) - return ax - - -def _plot_lines_circuit(inits, labels, plot_params, plot_labels=True, **kwargs): - """Use Matplotlib to plot a quantum circuit. - inits Initialization list of gates - labels List of qubit labels - - kwargs Can override plot_parameters - """ - plot_params.update(kwargs) - scale = plot_params["scale"] - - nq = len(labels) - - wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - gate_grid = np.arange(0.0, nq * scale, scale, dtype=float) - - ax, _ = _setup_figure(nq, nq, gate_grid, wire_grid, plot_params) - - _draw_wires(ax, nq, gate_grid, wire_grid, plot_params) - - if plot_labels: - _draw_labels(ax, labels, inits, gate_grid, wire_grid, plot_params) + if ng > 0: + _draw_gates( + ax, + gates, + labels, + gate_grid, + wire_grid, + plot_params, + measured, + schedule=schedule, + ) return ax @@ -555,6 +528,10 @@ def _check_list_str(substrings, string): def _process_gates(array_gates): + + if len(array_gates) == 0: + return [] + gates_plot = [] for gate in array_gates: @@ -639,47 +616,38 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): for i in range(circuit.nqubits): labels.append("q_" + str(i)) - if len(circuit.queue) > 0: - - all_gates = [] - for gate in circuit.queue: - if isinstance(gate, gates.FusedGate): - min_q, max_q = _get_min_max_qbits(gate) + all_gates = [] + for gate in circuit.queue: + if isinstance(gate, gates.FusedGate): + min_q, max_q = _get_min_max_qbits(gate) - fgates = None + fgates = None - if cluster_gates: - fgates = _make_cluster_gates(_process_gates(gate.gates)) - else: - fgates = _process_gates(gate.gates) + if cluster_gates: + fgates = _make_cluster_gates(_process_gates(gate.gates)) + else: + fgates = _process_gates(gate.gates) - l_gates = len(gate.gates) - equal_qbits = False - if min_q != max_q: - l_gates = len(fgates) - else: - max_q += 1 - equal_qbits = True - - all_gates.append( - FusedStartGateBarrier(min_q, max_q, l_gates, equal_qbits) - ) - all_gates += gate.gates - all_gates.append(FusedEndGateBarrier(min_q, max_q)) + l_gates = len(gate.gates) + equal_qbits = False + if min_q != max_q: + l_gates = len(fgates) else: - all_gates.append(gate) + max_q += 1 + equal_qbits = True - gates_plot = _process_gates(all_gates) + all_gates.append(FusedStartGateBarrier(min_q, max_q, l_gates, equal_qbits)) + all_gates += gate.gates + all_gates.append(FusedEndGateBarrier(min_q, max_q)) + else: + all_gates.append(gate) - if cluster_gates: - gates_cluster = _make_cluster_gates(gates_plot) - ax = _plot_quantum_schedule( - gates_cluster, inits, params, labels, scale=scale - ) - return ax, ax.figure + gates_plot = _process_gates(all_gates) - ax = _plot_quantum_circuit(gates_plot, inits, params, labels, scale=scale) - return ax, ax.figure - else: - ax = _plot_lines_circuit(inits, labels, params, scale=scale) + if cluster_gates and len(gates_plot) > 0: + gates_cluster = _make_cluster_gates(gates_plot) + ax = _plot_quantum_schedule(gates_cluster, inits, params, labels, scale=scale) return ax, ax.figure + + ax = _plot_quantum_circuit(gates_plot, inits, params, labels, scale=scale) + return ax, ax.figure From fd5bb5ac063257d6217d61550d8b5cc7a95a7f0e Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 2 Aug 2024 09:52:27 +0200 Subject: [PATCH 088/116] postreview for plot circuit function code --- src/qibo/ui/mpldrawer.py | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 9afd47cde0..37359deb01 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -88,16 +88,12 @@ def _plot_quantum_circuit( wire_grid = np.arange(0.0, nq * scale, scale, dtype=float) - EMPTY_GATES = True if ng == 0 else False - - gate_grid = np.arange(0.0, (nq if EMPTY_GATES else ng) * scale, scale, dtype=float) + gate_grid = np.arange(0.0, (nq if ng == 0 else ng) * scale, scale, dtype=float) ax, _ = _setup_figure( - nq, (nq if EMPTY_GATES else ng), gate_grid, wire_grid, plot_params + nq, (nq if ng == 0 else ng), gate_grid, wire_grid, plot_params ) - measured = ( - None if EMPTY_GATES else _measured_wires(gates, labels, schedule=schedule) - ) + measured = None if ng == 0 else _measured_wires(gates, labels, schedule=schedule) _draw_wires(ax, nq, gate_grid, wire_grid, plot_params, measured) if plot_labels: From 7939c843444c72efe9c39a572b394c544f5c9446 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Fri, 2 Aug 2024 10:54:37 +0200 Subject: [PATCH 089/116] added _plot_params function --- src/qibo/ui/mpldrawer.py | 20 ++++++++++++-------- 1 file changed, 12 insertions(+), 8 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 37359deb01..4e1445d011 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -4,7 +4,7 @@ # import json from pathlib import Path - +from typing import Union import matplotlib import numpy as np @@ -587,6 +587,16 @@ def _process_gates(array_gates): return gates_plot +def _plot_params(style: Union[dict, str, None]) -> dict: + if not isinstance(style, dict): + try: + style = STYLE.get(style) if (style is not None) else STYLE["default"] + except AttributeError: + style = STYLE["default"] + + return style + + def plot(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) @@ -599,13 +609,7 @@ def plot(circuit, scale=0.6, cluster_gates=True, style=None): """ params = PLOT_PARAMS.copy() - if not isinstance(style, dict): - try: - style = STYLE.get(style) if (style is not None) else STYLE["default"] - except AttributeError: - style = STYLE["default"] - - params.update(style) + params.update(_plot_params(style)) inits = list(range(circuit.nqubits)) labels = [] From c775cdac37011c6d4dd80e35836fdaacb90c3f08 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Fri, 2 Aug 2024 08:55:31 +0000 Subject: [PATCH 090/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 1 + 1 file changed, 1 insertion(+) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 4e1445d011..75223ba3d1 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -5,6 +5,7 @@ import json from pathlib import Path from typing import Union + import matplotlib import numpy as np From d94b4434cb4fbb350b8147e1861f9594bb8533b5 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 14 Aug 2024 15:46:32 +0200 Subject: [PATCH 091/116] plotting function review along style methods and variables --- .../qibo-draw-circuit-matplotlib.ipynb | 22 +++++++++---------- src/qibo/ui/__init__.py | 2 +- .../{FusedGateBarrier.py => drawer_utils.py} | 4 ++++ src/qibo/ui/mpldrawer.py | 14 +++++++----- 4 files changed, 24 insertions(+), 18 deletions(-) rename src/qibo/ui/{FusedGateBarrier.py => drawer_utils.py} (84%) diff --git a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb index f028075f96..754592147e 100644 --- a/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb +++ b/examples/circuit-draw-mpl/qibo-draw-circuit-matplotlib.ipynb @@ -59,7 +59,7 @@ "from qibo.models import Circuit, QFT\n", "\n", "# new plot function based on matplotlib\n", - "from qibo.ui import plot\n", + "from qibo.ui import plot_circuit\n", "\n", "%matplotlib inline" ] @@ -130,7 +130,7 @@ } ], "source": [ - "plot(ansatz, scale = 0.6, cluster_gates = False);" + "plot_circuit(ansatz, scale = 0.6, cluster_gates = False);" ] }, { @@ -151,7 +151,7 @@ } ], "source": [ - "plot(ansatz, scale = 0.7, cluster_gates = True);" + "plot_circuit(ansatz, scale = 0.7, cluster_gates = True);" ] }, { @@ -206,7 +206,7 @@ } ], "source": [ - "plot(c);" + "plot_circuit(c);" ] }, { @@ -260,7 +260,7 @@ } ], "source": [ - "plot(c, scale = 0.8, cluster_gates = True, style=\"garnacha\");" + "plot_circuit(c, scale = 0.8, cluster_gates = True, style=\"garnacha\");" ] }, { @@ -281,7 +281,7 @@ } ], "source": [ - "plot(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\");" + "plot_circuit(c, scale = 0.8, cluster_gates = True, style=\"fardelejo\");" ] }, { @@ -302,7 +302,7 @@ } ], "source": [ - "plot(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\");" + "plot_circuit(c, scale = 0.8, cluster_gates = True, style=\"quantumspain\");" ] }, { @@ -323,7 +323,7 @@ } ], "source": [ - "plot(c, scale = 0.8, cluster_gates = True, style=\"color-blind\");" + "plot_circuit(c, scale = 0.8, cluster_gates = True, style=\"color-blind\");" ] }, { @@ -362,7 +362,7 @@ " \"controlcolor\" : \"#360000\"\n", "}\n", "\n", - "plot(c, scale = 0.8, cluster_gates = True, style=custom_style);" + "plot_circuit(c, scale = 0.8, cluster_gates = True, style=custom_style);" ] }, { @@ -413,7 +413,7 @@ } ], "source": [ - "plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"quantumspain\");" + "plot_circuit(c.fuse(), scale = 0.8, cluster_gates = True, style=\"quantumspain\");" ] }, { @@ -434,7 +434,7 @@ } ], "source": [ - "plot(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\");" + "plot_circuit(c.fuse(), scale = 0.8, cluster_gates = True, style=\"cachirulo\");" ] }, { diff --git a/src/qibo/ui/__init__.py b/src/qibo/ui/__init__.py index b092d102ed..34354b6b7c 100644 --- a/src/qibo/ui/__init__.py +++ b/src/qibo/ui/__init__.py @@ -1 +1 @@ -from qibo.ui.mpldrawer import plot +from qibo.ui.mpldrawer import plot_circuit diff --git a/src/qibo/ui/FusedGateBarrier.py b/src/qibo/ui/drawer_utils.py similarity index 84% rename from src/qibo/ui/FusedGateBarrier.py rename to src/qibo/ui/drawer_utils.py index f557476938..d6779c4821 100644 --- a/src/qibo/ui/FusedGateBarrier.py +++ b/src/qibo/ui/drawer_utils.py @@ -2,6 +2,8 @@ class FusedStartGateBarrier(Gate): + """Special gate barrier gate to pin the starting point of fused gates""" + def __init__(self, q_ctrl, q_trgt, nfused, equal_qbits=False): super().__init__() @@ -20,6 +22,8 @@ def __init__(self, q_ctrl, q_trgt, nfused, equal_qbits=False): class FusedEndGateBarrier(Gate): + """Special gate barrier gate to pin the ending point of fused gates""" + def __init__(self, q_ctrl, q_trgt): super().__init__() diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 75223ba3d1..937ce7f7be 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -11,7 +11,7 @@ from qibo import gates -from .FusedGateBarrier import FusedEndGateBarrier, FusedStartGateBarrier +from .drawer_utils import FusedEndGateBarrier, FusedStartGateBarrier UI = Path(__file__).parent STYLE = json.loads((UI / "styles.json").read_text()) @@ -41,8 +41,9 @@ def _plot_quantum_schedule( """Use Matplotlib to plot a quantum circuit. schedule List of time steps, each containing a sequence of gates during that step. Each gate is a tuple containing (name,target,control1,control2...). - Targets and controls initially defined in terms of labels. + Targets and controls initially defined in terms of labels inits Initialization list of gates + plot_params Style plot configuration labels List of qubit labels, optional kwargs Can override plot_parameters @@ -67,6 +68,7 @@ def _plot_quantum_circuit( (name,target,control1,control2...). Targets and controls initially defined in terms of labels. inits Initialization list of gates + plot_params Style plot configuration labels List of qubit labels. optional kwargs Can override plot_parameters @@ -115,14 +117,14 @@ def _plot_quantum_circuit( return ax -def _enumerate_gates(l, schedule=False): +def _enumerate_gates(gates_plot, schedule=False): "Enumerate the gates in a way that can take l as either a list of gates or a schedule" if schedule: - for i, gates in enumerate(l): + for i, gates in enumerate(gates_plot): for gate in gates: yield i, gate else: - for i, gate in enumerate(l): + for i, gate in enumerate(gates_plot): yield i, gate @@ -598,7 +600,7 @@ def _plot_params(style: Union[dict, str, None]) -> dict: return style -def plot(circuit, scale=0.6, cluster_gates=True, style=None): +def plot_circuit(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) scale Scale the ouput plot From 5d68cd1e6cf51897eb1c059d5e4e03f6768e28e0 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 14 Aug 2024 15:58:11 +0200 Subject: [PATCH 092/116] plotting function review along style methods and variables --- src/qibo/ui/mpldrawer.py | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 937ce7f7be..6997743d62 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -128,10 +128,10 @@ def _enumerate_gates(gates_plot, schedule=False): yield i, gate -def _measured_wires(l, labels, schedule=False): +def _measured_wires(gates_plot, labels, schedule=False): "measured[i] = j means wire i is measured at step j" measured = {} - for i, gate in _enumerate_gates(l, schedule=schedule): + for i, gate in _enumerate_gates(gates_plot, schedule=schedule): name, target = gate[:2] j = _get_flipped_index(target, labels) if name.startswith("M"): @@ -140,9 +140,9 @@ def _measured_wires(l, labels, schedule=False): def _draw_gates( - ax, l, labels, gate_grid, wire_grid, plot_params, measured={}, schedule=False + ax, gates_plot, labels, gate_grid, wire_grid, plot_params, measured={}, schedule=False ): - for i, gate in _enumerate_gates(l, schedule=schedule): + for i, gate in _enumerate_gates(gates_plot, schedule=schedule): _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) if len(gate) > 2: # Controlled _draw_controls( From 2b49b40eb72821529a1e2732505982041e075174 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Wed, 14 Aug 2024 14:00:29 +0000 Subject: [PATCH 093/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/ui/mpldrawer.py | 9 ++++++++- 1 file changed, 8 insertions(+), 1 deletion(-) diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 6997743d62..449a1f07c8 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -140,7 +140,14 @@ def _measured_wires(gates_plot, labels, schedule=False): def _draw_gates( - ax, gates_plot, labels, gate_grid, wire_grid, plot_params, measured={}, schedule=False + ax, + gates_plot, + labels, + gate_grid, + wire_grid, + plot_params, + measured={}, + schedule=False, ): for i, gate in _enumerate_gates(gates_plot, schedule=schedule): _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) From d96573e166be637f379be00a1e4ec7e736c8a70b Mon Sep 17 00:00:00 2001 From: changsookim <> Date: Mon, 19 Aug 2024 19:53:53 +0800 Subject: [PATCH 094/116] add cnot as native --- src/qibo/transpiler/decompositions.py | 6 ++++++ src/qibo/transpiler/unroller.py | 9 ++++++++- 2 files changed, 14 insertions(+), 1 deletion(-) diff --git a/src/qibo/transpiler/decompositions.py b/src/qibo/transpiler/decompositions.py index 780aa42c99..29d691402a 100644 --- a/src/qibo/transpiler/decompositions.py +++ b/src/qibo/transpiler/decompositions.py @@ -387,6 +387,12 @@ def _u3_to_gpi2(t, p, l): lambda gate: two_qubit_decomposition(0, 1, gate.matrix(backend), backend=backend), ) +# temporary CNOT decompositions for CNOT, CZ, SWAP +cnot_dec_temp = GateDecompositions() +cnot_dec_temp.add(gates.CNOT, [gates.CNOT(0, 1)]) +cnot_dec_temp.add(gates.CZ, [gates.H(1), gates.CNOT(0, 1), gates.H(1)]) +cnot_dec_temp.add(gates.SWAP, [gates.CNOT(0, 1), gates.CNOT(1, 0), gates.CNOT(0, 1)]) + # register other optimized gate decompositions opt_dec = GateDecompositions() opt_dec.add( diff --git a/src/qibo/transpiler/unroller.py b/src/qibo/transpiler/unroller.py index a14aca382d..25d691f4fe 100644 --- a/src/qibo/transpiler/unroller.py +++ b/src/qibo/transpiler/unroller.py @@ -4,7 +4,7 @@ from qibo.config import raise_error from qibo.models import Circuit from qibo.transpiler._exceptions import DecompositionError -from qibo.transpiler.decompositions import cz_dec, gpi2_dec, iswap_dec, opt_dec, u3_dec +from qibo.transpiler.decompositions import cz_dec, gpi2_dec, iswap_dec, opt_dec, u3_dec, cnot_dec_temp class NativeGates(Flag): @@ -32,6 +32,7 @@ class NativeGates(Flag): U3 = auto() CZ = auto() iSWAP = auto() + CNOT = auto() # For testing purposes @classmethod def default(cls): @@ -239,6 +240,12 @@ def _translate_two_qubit_gates(gate: gates.Gate, native_gates: NativeGates): for g_translated in translate_gate(g, native_gates=native_gates): iswap_decomposed.append(g_translated) return iswap_decomposed + + # For testing purposes + # No CZ, iSWAP gates in the native gate set + # Decompose CNOT, CZ, SWAP gates into CNOT gates + if native_gates & NativeGates.CNOT: + return cnot_dec_temp(gate) raise_error( DecompositionError, "Use only CZ and/or iSWAP as native gates" From 04598028ed8a9a2bcccd585d1eed5558cefcb064 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 19 Aug 2024 11:58:02 +0000 Subject: [PATCH 095/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/transpiler/unroller.py | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) diff --git a/src/qibo/transpiler/unroller.py b/src/qibo/transpiler/unroller.py index 25d691f4fe..adc2e02d78 100644 --- a/src/qibo/transpiler/unroller.py +++ b/src/qibo/transpiler/unroller.py @@ -4,7 +4,14 @@ from qibo.config import raise_error from qibo.models import Circuit from qibo.transpiler._exceptions import DecompositionError -from qibo.transpiler.decompositions import cz_dec, gpi2_dec, iswap_dec, opt_dec, u3_dec, cnot_dec_temp +from qibo.transpiler.decompositions import ( + cnot_dec_temp, + cz_dec, + gpi2_dec, + iswap_dec, + opt_dec, + u3_dec, +) class NativeGates(Flag): @@ -32,7 +39,7 @@ class NativeGates(Flag): U3 = auto() CZ = auto() iSWAP = auto() - CNOT = auto() # For testing purposes + CNOT = auto() # For testing purposes @classmethod def default(cls): @@ -240,11 +247,11 @@ def _translate_two_qubit_gates(gate: gates.Gate, native_gates: NativeGates): for g_translated in translate_gate(g, native_gates=native_gates): iswap_decomposed.append(g_translated) return iswap_decomposed - + # For testing purposes # No CZ, iSWAP gates in the native gate set # Decompose CNOT, CZ, SWAP gates into CNOT gates - if native_gates & NativeGates.CNOT: + if native_gates & NativeGates.CNOT: return cnot_dec_temp(gate) raise_error( From 07d721da030a970a58ce9d8d6a00c865ad1f2218 Mon Sep 17 00:00:00 2001 From: changsookim <> Date: Tue, 20 Aug 2024 14:35:15 +0800 Subject: [PATCH 096/116] update test func --- tests/test_transpiler_unroller.py | 32 +++++++++++++++++++++++++++++++ 1 file changed, 32 insertions(+) diff --git a/tests/test_transpiler_unroller.py b/tests/test_transpiler_unroller.py index 61e2c11fc1..d3bb88af44 100644 --- a/tests/test_transpiler_unroller.py +++ b/tests/test_transpiler_unroller.py @@ -121,3 +121,35 @@ def test_measurements_non_comp_basis(): assert isinstance(transpiled_circuit.queue[2], gates.M) # After transpiling the measurement gate should be in the computational basis assert transpiled_circuit.queue[2].basis == [] + +def test_temp_cnot_decomposition(): + from qibo.transpiler.pipeline import Passes + + circ = Circuit(2) + circ.add(gates.H(0)) + circ.add(gates.CNOT(0, 1)) + circ.add(gates.SWAP(0, 1)) + circ.add(gates.CZ(0, 1)) + circ.add(gates.M(0, 1)) + + glist = [gates.GPI2, gates.RZ, gates.Z, gates.M, gates.CNOT] + native_gates = NativeGates(0).from_gatelist(glist) + + custom_pipeline = Passes([Unroller(native_gates=native_gates)]) + transpiled_circuit, _ = custom_pipeline(circ) + + # H + assert transpiled_circuit.queue[0].name == 'z' + assert transpiled_circuit.queue[1].name == 'gpi2' + # CNOT + assert transpiled_circuit.queue[2].name == 'cx' + # SWAP + assert transpiled_circuit.queue[3].name == 'cx' + assert transpiled_circuit.queue[4].name == 'cx' + assert transpiled_circuit.queue[5].name == 'cx' + # CZ + assert transpiled_circuit.queue[6].name == 'z' + assert transpiled_circuit.queue[7].name == 'gpi2' + assert transpiled_circuit.queue[8].name == 'cx' + assert transpiled_circuit.queue[9].name == 'z' + assert transpiled_circuit.queue[10].name == 'gpi2' \ No newline at end of file From 96e5d0d5d78a0f4a4828325f92b1ff099bd859be Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Tue, 20 Aug 2024 06:35:48 +0000 Subject: [PATCH 097/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- tests/test_transpiler_unroller.py | 25 +++++++++++++------------ 1 file changed, 13 insertions(+), 12 deletions(-) diff --git a/tests/test_transpiler_unroller.py b/tests/test_transpiler_unroller.py index d3bb88af44..474d2c50a3 100644 --- a/tests/test_transpiler_unroller.py +++ b/tests/test_transpiler_unroller.py @@ -122,6 +122,7 @@ def test_measurements_non_comp_basis(): # After transpiling the measurement gate should be in the computational basis assert transpiled_circuit.queue[2].basis == [] + def test_temp_cnot_decomposition(): from qibo.transpiler.pipeline import Passes @@ -134,22 +135,22 @@ def test_temp_cnot_decomposition(): glist = [gates.GPI2, gates.RZ, gates.Z, gates.M, gates.CNOT] native_gates = NativeGates(0).from_gatelist(glist) - + custom_pipeline = Passes([Unroller(native_gates=native_gates)]) transpiled_circuit, _ = custom_pipeline(circ) # H - assert transpiled_circuit.queue[0].name == 'z' - assert transpiled_circuit.queue[1].name == 'gpi2' + assert transpiled_circuit.queue[0].name == "z" + assert transpiled_circuit.queue[1].name == "gpi2" # CNOT - assert transpiled_circuit.queue[2].name == 'cx' + assert transpiled_circuit.queue[2].name == "cx" # SWAP - assert transpiled_circuit.queue[3].name == 'cx' - assert transpiled_circuit.queue[4].name == 'cx' - assert transpiled_circuit.queue[5].name == 'cx' + assert transpiled_circuit.queue[3].name == "cx" + assert transpiled_circuit.queue[4].name == "cx" + assert transpiled_circuit.queue[5].name == "cx" # CZ - assert transpiled_circuit.queue[6].name == 'z' - assert transpiled_circuit.queue[7].name == 'gpi2' - assert transpiled_circuit.queue[8].name == 'cx' - assert transpiled_circuit.queue[9].name == 'z' - assert transpiled_circuit.queue[10].name == 'gpi2' \ No newline at end of file + assert transpiled_circuit.queue[6].name == "z" + assert transpiled_circuit.queue[7].name == "gpi2" + assert transpiled_circuit.queue[8].name == "cx" + assert transpiled_circuit.queue[9].name == "z" + assert transpiled_circuit.queue[10].name == "gpi2" From d6d600068dac1c20e32efedb39e83203016e7756 Mon Sep 17 00:00:00 2001 From: changsookim <> Date: Mon, 26 Aug 2024 15:27:47 +0800 Subject: [PATCH 098/116] add error msg / docstring --- src/qibo/transpiler/unroller.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qibo/transpiler/unroller.py b/src/qibo/transpiler/unroller.py index adc2e02d78..9c6630a11c 100644 --- a/src/qibo/transpiler/unroller.py +++ b/src/qibo/transpiler/unroller.py @@ -29,6 +29,7 @@ class NativeGates(Flag): - :class:`qibo.gates.gates.U3` - :class:`qibo.gates.gates.CZ` - :class:`qibo.gates.gates.iSWAP` + - :class:`qibo.gates.gates.CNOT` """ I = auto() @@ -255,5 +256,5 @@ def _translate_two_qubit_gates(gate: gates.Gate, native_gates: NativeGates): return cnot_dec_temp(gate) raise_error( - DecompositionError, "Use only CZ and/or iSWAP as native gates" + DecompositionError, "Use only CZ and/or iSWAP as native gates. CNOT is allowed in circuits where the two-qubit gates are limited to CZ, CNOT, and SWAP." ) # pragma: no cover From 3281871143a17015f9764ca0ddeae80d14579d23 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 26 Aug 2024 07:28:19 +0000 Subject: [PATCH 099/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- src/qibo/transpiler/unroller.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/qibo/transpiler/unroller.py b/src/qibo/transpiler/unroller.py index 9c6630a11c..9032e5e306 100644 --- a/src/qibo/transpiler/unroller.py +++ b/src/qibo/transpiler/unroller.py @@ -256,5 +256,6 @@ def _translate_two_qubit_gates(gate: gates.Gate, native_gates: NativeGates): return cnot_dec_temp(gate) raise_error( - DecompositionError, "Use only CZ and/or iSWAP as native gates. CNOT is allowed in circuits where the two-qubit gates are limited to CZ, CNOT, and SWAP." + DecompositionError, + "Use only CZ and/or iSWAP as native gates. CNOT is allowed in circuits where the two-qubit gates are limited to CZ, CNOT, and SWAP.", ) # pragma: no cover From 114714f3efae222d697c4cb88c9cff4310341b69 Mon Sep 17 00:00:00 2001 From: Renato Mello Date: Mon, 26 Aug 2024 15:04:05 +0400 Subject: [PATCH 100/116] improved docs --- doc/source/api-reference/qibo.rst | 6 +- src/qibo/derivative.py | 49 +++++++------ src/qibo/hamiltonians/abstract.py | 27 ++++--- src/qibo/hamiltonians/hamiltonians.py | 61 ++++++++------- src/qibo/hamiltonians/models.py | 102 +++++++++++++++----------- src/qibo/symbols.py | 4 +- 6 files changed, 140 insertions(+), 109 deletions(-) diff --git a/doc/source/api-reference/qibo.rst b/doc/source/api-reference/qibo.rst index 8955017e55..d086154dc4 100644 --- a/doc/source/api-reference/qibo.rst +++ b/doc/source/api-reference/qibo.rst @@ -1213,9 +1213,9 @@ Matrix Hamiltonian ^^^^^^^^^^^^^^^^^^ The first implementation of Hamiltonians uses the full matrix representation -of the Hamiltonian operator in the computational basis. This matrix has size -``(2 ** nqubits, 2 ** nqubits)`` and therefore its construction is feasible -only when number of qubits is small. +of the Hamiltonian operator in the computational basis. +For :math:`n` qubits, this matrix has size :math:`2^{n} \times 2^{n}`. +Therefore, its construction is feasible only when :math:`n` is small. Alternatively, the user can construct this Hamiltonian using a sparse matrices. Sparse matrices from the diff --git a/src/qibo/derivative.py b/src/qibo/derivative.py index 65d4ef87b0..8d2d934e41 100644 --- a/src/qibo/derivative.py +++ b/src/qibo/derivative.py @@ -13,41 +13,43 @@ def parameter_shift( nshots=None, ): """In this method the parameter shift rule (PSR) is implemented. - Given a circuit U and an observable H, the PSR allows to calculate the derivative - of the expected value of H on the final state with respect to a variational + Given a circuit :math:`U` and an observable :math:`H`, the PSR allows to calculate the derivative + of the expected value of :math:`H` on the final state with respect to a variational parameter of the circuit. There is also the possibility of setting a scale factor. It is useful when a circuit's parameter is obtained by combination of a variational parameter and an external object, such as a training variable in a Quantum Machine Learning problem. For example, performing a re-uploading strategy to embed some data into a circuit, we apply to the quantum state rotations - whose angles are in the form: theta' = theta * x, where theta is a variational - parameter and x an input variable. The PSR allows to calculate the derivative - with respect of theta' but, if we want to optimize a system with respect its - variational parameters we need to "free" this procedure from the x depencency. - If the `scale_factor` is not provided, it is set equal to one and doesn't + whose angles are in the form :math:`\\theta^{\\prime} = x \\, \\theta`, + where :math:`\\theta` is a variational parameter, and :math:`x` an input variable. + The PSR allows to calculate the derivative with respect to :math:`\\theta^{\\prime}`. + However, if we want to optimize a system with respect to its + variational parameters, we need to "free" this procedure from the :math:`x` depencency. + If the ``scale_factor`` is not provided, it is set equal to one and doesn't affect the calculation. If the PSR is needed to be executed on a real quantum device, it is important - to set `nshots` to some integer value. This enables the execution on the + to set ``nshots`` to some integer value. This enables the execution on the hardware by calling the proper methods. Args: circuit (:class:`qibo.models.circuit.Circuit`): custom quantum circuit. hamiltonian (:class:`qibo.hamiltonians.Hamiltonian`): target observable. if you want to execute on hardware, a symbolic hamiltonian must be - provided as follows (example with Pauli Z and ``nqubits=1``): + provided as follows (example with Pauli:math:`Z` and :math:`n = 1`): ``SymbolicHamiltonian(np.prod([ Z(i) for i in range(1) ]))``. parameter_index (int): the index which identifies the target parameter in the ``circuit.get_parameters()`` list. initial_state (ndarray, optional): initial state on which the circuit - acts. Default is ``None``. - scale_factor (float, optional): parameter scale factor. Default is ``1``. + acts. If ``None``, defaults to the zero state :math:`\\ket{\\mathbf{0}}`. + Defaults to ``None``. + scale_factor (float, optional): parameter scale factor. Defaults to :math:`1`. nshots (int, optional): number of shots if derivative is evaluated on hardware. If ``None``, the simulation mode is executed. - Default is ``None``. + Defaults to ``None``. Returns: - (float): Value of the derivative of the expectation value of the hamiltonian + float: Value of the derivative of the expectation value of the hamiltonian with respect to the target variational parameter. Example: @@ -167,27 +169,28 @@ def finite_differences( step_size=1e-7, ): """ - Calculate derivative of the expectation value of `hamiltonian` on the - final state obtained by executing `circuit` on `initial_state` with - respect to the variational parameter identified by `parameter_index` + Calculate derivative of the expectation value of ``hamiltonian`` on the + final state obtained by executing ``circuit`` on ``initial_state`` with + respect to the variational parameter identified by ``parameter_index`` in the circuit's parameters list. This method can be used only in exact simulation mode. Args: circuit (:class:`qibo.models.circuit.Circuit`): custom quantum circuit. hamiltonian (:class:`qibo.hamiltonians.Hamiltonian`): target observable. - if you want to execute on hardware, a symbolic hamiltonian must be - provided as follows (example with Pauli Z and ``nqubits=1``): + To execute on hardware, a symbolic hamiltonian must be + provided as follows (example with Pauli-:math:`Z` and :math:`n = 1`): ``SymbolicHamiltonian(np.prod([ Z(i) for i in range(1) ]))``. parameter_index (int): the index which identifies the target parameter - in the ``circuit.get_parameters()`` list. + in the :meth:`qibo.models.Circuit.get_parameters` list. initial_state (ndarray, optional): initial state on which the circuit - acts. Default is ``None``. - step_size (float): step size used to evaluate the finite difference - (default 1e-7). + acts. If ``None``, defaults to the zero state :math:`\\ket{\\mathbf{0}}`. + Defaults to ``None``. + step_size (float, optional): step size used to evaluate the finite difference. + Defaults to :math:`10^{-7}`. Returns: - (float): Value of the derivative of the expectation value of the hamiltonian + float: Value of the derivative of the expectation value of the hamiltonian with respect to the target variational parameter. """ diff --git a/src/qibo/hamiltonians/abstract.py b/src/qibo/hamiltonians/abstract.py index 749ad0b21e..4abf7d43af 100644 --- a/src/qibo/hamiltonians/abstract.py +++ b/src/qibo/hamiltonians/abstract.py @@ -57,11 +57,10 @@ def ground_state(self): @abstractmethod def exp(self, a): # pragma: no cover - """Computes a tensor corresponding to exp(-1j * a * H). + """Computes a tensor corresponding to :math:`\\exp(-i \\, a \\, H)`. Args: - a (complex): Complex number to multiply Hamiltonian before - exponentiation. + a (complex): Complex number to multiply Hamiltonian before exponentiation. """ raise_error(NotImplementedError) @@ -70,27 +69,31 @@ def expectation(self, state, normalize=False): # pragma: no cover """Computes the real expectation value for a given state. Args: - state (array): the expectation state. - normalize (bool): If ``True`` the expectation value is divided - with the state's norm squared. + state (ndarray): state in which to calculate the expectation value. + normalize (bool, optional): If ``True``, the expectation value + :math:`\\ell_{2}`-normalized. Defaults to ``False``. Returns: - Real number corresponding to the expectation value. + float: real number corresponding to the expectation value. """ raise_error(NotImplementedError) @abstractmethod def expectation_from_samples(self, freq, qubit_map=None): # pragma: no cover - """Computes the real expectation value of a diagonal observable given the frequencies when measuring in the computational basis. + """Computes the expectation value of a diagonal observable, + given computational-basis measurement frequencies. Args: freq (collections.Counter): the keys are the observed values in binary form - and the values the corresponding frequencies, that is the number - of times each measured value/bitstring appears. - qubit_map (tuple): Mapping between frequencies and qubits. If None, [1,...,len(key)] + and the values the corresponding frequencies, that is the number + of times each measured value/bitstring appears. + qubit_map (tuple): Mapping between frequencies and qubits. + If ``None``, then defaults to + :math:`[1, \\, 2, \\, \\cdots, \\, \\mathrm{len}(\\mathrm{key})]`. + Defaults to ``None``. Returns: - Real number corresponding to the expectation value. + float: real number corresponding to the expectation value. """ raise_error(NotImplementedError) diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py index bceb1b3b0a..d138d83e2e 100644 --- a/src/qibo/hamiltonians/hamiltonians.py +++ b/src/qibo/hamiltonians/hamiltonians.py @@ -17,14 +17,16 @@ class Hamiltonian(AbstractHamiltonian): Args: nqubits (int): number of quantum bits. - matrix (np.ndarray): Matrix representation of the Hamiltonian in the - computational basis as an array of shape ``(2 ** nqubits, 2 ** nqubits)``. - Sparse matrices based on ``scipy.sparse`` for numpy/qibojit backends - or on ``tf.sparse`` for the tensorflow backend are also - supported. + matrix (ndarray): Matrix representation of the Hamiltonian in the + computational basis as an array of shape :math:`2^{n} \\times 2^{n}`. + Sparse matrices based on ``scipy.sparse`` for ``numpy`` / ``qibojit`` backends + (or on ``tf.sparse`` for the ``tensorflow`` backend) are also supported. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. """ - def __init__(self, nqubits, matrix=None, backend=None): + def __init__(self, nqubits, matrix, backend=None): from qibo.backends import _check_backend self.backend = _check_backend(backend) @@ -50,7 +52,7 @@ def __init__(self, nqubits, matrix=None, backend=None): def matrix(self): """Returns the full matrix representation. - Can be a dense ``(2 ** nqubits, 2 ** nqubits)`` array or a sparse + For :math:`n` qubits, can be a dense :math:`2^{n} \\times 2^{n}` array or a sparse matrix, depending on how the Hamiltonian was created. """ return self._matrix @@ -68,22 +70,22 @@ def matrix(self, mat): @classmethod def from_symbolic(cls, symbolic_hamiltonian, symbol_map, backend=None): - """Creates a ``Hamiltonian`` from a symbolic Hamiltonian. + """Creates a :class:`qibo.hamiltonian.Hamiltonian` from a symbolic Hamiltonian. - We refer to the - :ref:`How to define custom Hamiltonians using symbols? ` - example for more details. + We refer to :ref:`How to define custom Hamiltonians using symbols? ` + for more details. Args: - symbolic_hamiltonian (sympy.Expr): The full Hamiltonian written - with symbols. + symbolic_hamiltonian (sympy.Expr): full Hamiltonian written with ``sympy`` symbols. symbol_map (dict): Dictionary that maps each symbol that appears in - the Hamiltonian to a pair of (target, matrix). + the Hamiltonian to a pair ``(target, matrix)``. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. Returns: - A :class:`qibo.hamiltonians.SymbolicHamiltonian` object - that implements the Hamiltonian represented by the given symbolic - expression. + :class:`qibo.hamiltonians.SymbolicHamiltonian`: object that implements the + Hamiltonian represented by the given symbolic expression. """ log.warning( "`Hamiltonian.from_symbolic` and the use of symbol maps is " @@ -175,15 +177,16 @@ def energy_fluctuation(self, state): Evaluate energy fluctuation: .. math:: - \\Xi_{k}(\\mu) = \\sqrt{\\langle\\mu|\\hat{H}^2|\\mu\\rangle - \\langle\\mu|\\hat{H}|\\mu\\rangle^2} \\, + \\Xi_{k}(\\mu) = \\sqrt{\\bra{\\mu} \\, H^{2} \\, \\ket{\\mu} + - \\bra{\\mu} \\, H \\, \\ket{\\mu}^2} \\, . - for a given state :math:`|\\mu\\rangle`. + for a given state :math:`\\ket{\\mu}`. Args: - state (np.ndarray): quantum state to be used to compute the energy fluctuation. + state (ndarray): quantum state to be used to compute the energy fluctuation. - Return: - Energy fluctuation value (float). + Returns: + float: Energy fluctuation value. """ state = self.backend.cast(state) energy = self.expectation(state) @@ -311,6 +314,9 @@ class SymbolicHamiltonian(AbstractHamiltonian): The symbol_map can also be used to pass non-quantum operator arguments to the symbolic Hamiltonian, such as the parameters in the :meth:`qibo.hamiltonians.models.MaxCut` Hamiltonian. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. """ def __init__(self, form=None, nqubits=None, symbol_map={}, backend=None): @@ -419,7 +425,7 @@ def terms(self, terms): def matrix(self): """Returns the full matrix representation. - Consisting of ``(2 ** nqubits, 2 ** nqubits)`` elements. + Consisting of :math:`2^{n} \\times 2^{n}`` elements. """ return self.dense.matrix @@ -449,8 +455,8 @@ def _get_symbol_matrix(self, term): term (sympy.Expr): Symbolic expression containing local operators. Returns: - Numerical matrix corresponding to the given expression as a numpy - array of size ``(2 ** self.nqubits, 2 ** self.nqubits). + ndarray: matrix corresponding to the given expression as an array + of shape ``(2 ** self.nqubits, 2 ** self.nqubits)``. """ if isinstance(term, sympy.Add): # symbolic op for addition @@ -697,7 +703,7 @@ def apply_gates(self, state, density_matrix=False): Gates are applied to the given state. - Helper method for ``__matmul__``. + Helper method for :meth:`qibo.hamiltonians.SymbolicHamiltonian.__matmul__`. """ total = 0 for term in self.terms: @@ -759,7 +765,8 @@ def circuit(self, dt, accelerators=None): Args: dt (float): Time step used for Trotterization. - accelerators (dict): Dictionary with accelerators for distributed circuits. + accelerators (dict, optional): Dictionary with accelerators for distributed circuits. + Defaults to ``None``. """ from qibo import Circuit # pylint: disable=import-outside-toplevel from qibo.hamiltonians.terms import ( # pylint: disable=import-outside-toplevel diff --git a/src/qibo/hamiltonians/models.py b/src/qibo/hamiltonians/models.py index 1fa030fac6..f6413b9848 100644 --- a/src/qibo/hamiltonians/models.py +++ b/src/qibo/hamiltonians/models.py @@ -1,48 +1,52 @@ +from functools import reduce + from qibo.backends import matrices from qibo.config import raise_error from qibo.hamiltonians.hamiltonians import Hamiltonian, SymbolicHamiltonian from qibo.hamiltonians.terms import HamiltonianTerm -def multikron(matrix_list): +def _multikron(matrix_list): """Calculates Kronecker product of a list of matrices. Args: - matrices (list): List of matrices as ``np.ndarray``s. + matrix_list (list): List of matrices as ``ndarray``. Returns: - ``np.ndarray`` of the Kronecker product of all ``matrices``. + ndarray: Kronecker product of all matrices in ``matrix_list``. """ import numpy as np - h = 1 - for m in matrix_list: - # TODO: check if we observe GPU deterioration - h = np.kron(h, m) - return h + return reduce(np.kron, matrix_list) def _build_spin_model(nqubits, matrix, condition): """Helper method for building nearest-neighbor spin model Hamiltonians.""" h = sum( - multikron(matrix if condition(i, j) else matrices.I for j in range(nqubits)) + _multikron(matrix if condition(i, j) else matrices.I for j in range(nqubits)) for i in range(nqubits) ) return h -def XXZ(nqubits, delta=0.5, dense=True, backend=None): - """Heisenberg XXZ model with periodic boundary conditions. +def XXZ(nqubits, delta=0.5, dense: bool = True, backend=None): + """Heisenberg :math:`\\mathrm{XXZ}` model with periodic boundary conditions. .. math:: - H = \\sum _{i=0}^N \\left ( X_iX_{i + 1} + Y_iY_{i + 1} + \\delta Z_iZ_{i + 1} \\right ). + H = \\sum _{k=0}^N \\, \\left( X_{k} \\, X_{k + 1} + Y_{k} \\, Y_{k + 1} + + \\delta Z_{k} \\, Z_{k + 1} \\right) \\, . Args: - nqubits (int): number of quantum bits. - delta (float): coefficient for the Z component (default 0.5). - dense (bool): If ``True`` it creates the Hamiltonian as a + nqubits (int): number of qubits. + delta (float, optional): coefficient for the :math:`Z` component. + Defaults to :math:`0.5`. + dense (bool, optional): If ``True``, creates the Hamiltonian as a :class:`qibo.core.hamiltonians.Hamiltonian`, otherwise it creates a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`. + Defaults to ``True``. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. Example: .. testcode:: @@ -60,9 +64,9 @@ def XXZ(nqubits, delta=0.5, dense=True, backend=None): matrix = hx + hy + delta * hz return Hamiltonian(nqubits, matrix, backend=backend) - hx = multikron([matrices.X, matrices.X]) - hy = multikron([matrices.Y, matrices.Y]) - hz = multikron([matrices.Z, matrices.Z]) + hx = _multikron([matrices.X, matrices.X]) + hy = _multikron([matrices.Y, matrices.Y]) + hz = _multikron([matrices.Z, matrices.Z]) matrix = hx + hy + delta * hz terms = [HamiltonianTerm(matrix, i, i + 1) for i in range(nqubits - 1)] terms.append(HamiltonianTerm(matrix, nqubits - 1, 0)) @@ -71,8 +75,8 @@ def XXZ(nqubits, delta=0.5, dense=True, backend=None): return ham -def _OneBodyPauli(nqubits, matrix, dense=True, backend=None): - """Helper method for constracting non-interacting X, Y, Z Hamiltonians.""" +def _OneBodyPauli(nqubits, matrix, dense: bool = True, backend=None): + """Helper method for constracting non-interacting :math:`X`, :math:`Y`, and :math:`Z` Hamiltonians.""" if dense: condition = lambda i, j: i == j % nqubits ham = -_build_spin_model(nqubits, matrix, condition) @@ -85,63 +89,74 @@ def _OneBodyPauli(nqubits, matrix, dense=True, backend=None): return ham -def X(nqubits, dense=True, backend=None): - """Non-interacting Pauli-X Hamiltonian. +def X(nqubits, dense: bool = True, backend=None): + """Non-interacting Pauli-:math:`X` Hamiltonian. .. math:: - H = - \\sum _{i=0}^N X_i. + H = - \\sum _{k=0}^N \\, X_{k} \\, . Args: - nqubits (int): number of quantum bits. - dense (bool): If ``True`` it creates the Hamiltonian as a + nqubits (int): number of qubits. + dense (bool, optional): If ``True`` it creates the Hamiltonian as a :class:`qibo.core.hamiltonians.Hamiltonian`, otherwise it creates a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`. + Defaults to ``True``. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. """ return _OneBodyPauli(nqubits, matrices.X, dense, backend=backend) -def Y(nqubits, dense=True, backend=None): - """Non-interacting Pauli-Y Hamiltonian. +def Y(nqubits, dense: bool = True, backend=None): + """Non-interacting Pauli-:math:`Y` Hamiltonian. .. math:: - H = - \\sum _{i=0}^N Y_i. + H = - \\sum _{k=0}^{N} \\, Y_{k} \\, . Args: - nqubits (int): number of quantum bits. + nqubits (int): number of qubits. dense (bool): If ``True`` it creates the Hamiltonian as a :class:`qibo.core.hamiltonians.Hamiltonian`, otherwise it creates a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. """ return _OneBodyPauli(nqubits, matrices.Y, dense, backend=backend) -def Z(nqubits, dense=True, backend=None): - """Non-interacting Pauli-Z Hamiltonian. +def Z(nqubits, dense: bool = True, backend=None): + """Non-interacting Pauli-:math:`Z` Hamiltonian. .. math:: - H = - \\sum _{i=0}^N Z_i. + H = - \\sum _{k=0}^{N} \\, Z_{k} \\, . Args: - nqubits (int): number of quantum bits. + nqubits (int): number of qubits. dense (bool): If ``True`` it creates the Hamiltonian as a :class:`qibo.core.hamiltonians.Hamiltonian`, otherwise it creates a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. """ return _OneBodyPauli(nqubits, matrices.Z, dense, backend=backend) -def TFIM(nqubits, h=0.0, dense=True, backend=None): +def TFIM(nqubits, h: float = 0.0, dense: bool = True, backend=None): """Transverse field Ising model with periodic boundary conditions. .. math:: - H = - \\sum _{i=0}^N \\left ( Z_i Z_{i + 1} + h X_i \\right ). + H = - \\sum _{k=0}^{N} \\, \\left(Z_{k} \\, Z_{k + 1} + h \\, X_{k}\\right) \\, . Args: - nqubits (int): number of quantum bits. - h (float): value of the transverse field. - dense (bool): If ``True`` it creates the Hamiltonian as a + nqubits (int): number of qubits. + h (float, optional): value of the transverse field. Defaults to :math:`0.0`. + dense (bool, optional): If ``True`` it creates the Hamiltonian as a :class:`qibo.core.hamiltonians.Hamiltonian`, otherwise it creates a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`. + Defaults to ``True``. """ if nqubits < 2: raise_error(ValueError, "Number of qubits must be larger than one.") @@ -154,7 +169,7 @@ def TFIM(nqubits, h=0.0, dense=True, backend=None): return Hamiltonian(nqubits, ham, backend=backend) matrix = -( - multikron([matrices.Z, matrices.Z]) + h * multikron([matrices.X, matrices.I]) + _multikron([matrices.Z, matrices.Z]) + h * _multikron([matrices.X, matrices.I]) ) terms = [HamiltonianTerm(matrix, i, i + 1) for i in range(nqubits - 1)] terms.append(HamiltonianTerm(matrix, nqubits - 1, 0)) @@ -163,17 +178,20 @@ def TFIM(nqubits, h=0.0, dense=True, backend=None): return ham -def MaxCut(nqubits, dense=True, backend=None): +def MaxCut(nqubits, dense: bool = True, backend=None): """Max Cut Hamiltonian. .. math:: - H = - \\sum _{i,j=0}^N \\frac{1 - Z_i Z_j}{2}. + H = -\\frac{1}{2} \\, \\sum _{j, k = 0}^{N} \\, \\left(1 - Z_{j} \\, Z_{k}\\right) \\, . Args: - nqubits (int): number of quantum bits. + nqubits (int): number of qubits. dense (bool): If ``True`` it creates the Hamiltonian as a :class:`qibo.core.hamiltonians.Hamiltonian`, otherwise it creates a :class:`qibo.core.hamiltonians.SymbolicHamiltonian`. + backend (:class:`qibo.backends.abstract.Backend`, optional): backend to be used + in the execution. If ``None``, it uses :class:`qibo.backends.GlobalBackend`. + Defaults to ``None``. """ import sympy as sp from numpy import ones diff --git a/src/qibo/symbols.py b/src/qibo/symbols.py index 9aa12a1dcc..edb03eb677 100644 --- a/src/qibo/symbols.py +++ b/src/qibo/symbols.py @@ -99,13 +99,13 @@ def full_matrix(self, nqubits): Matrix of dimension (2^nqubits, 2^nqubits) composed of the Kronecker product between identities and the symbol's single-qubit matrix. """ - from qibo.hamiltonians.models import multikron + from qibo.hamiltonians.models import _multikron matrix_list = self.target_qubit * [matrices.I] matrix_list.append(self.matrix) n = nqubits - self.target_qubit - 1 matrix_list.extend(matrices.I for _ in range(n)) - return multikron(matrix_list) + return _multikron(matrix_list) class PauliSymbol(Symbol): From 1d1d086331693e23ea4799af6d13cee0816e1259 Mon Sep 17 00:00:00 2001 From: "pre-commit-ci[bot]" <66853113+pre-commit-ci[bot]@users.noreply.github.com> Date: Mon, 26 Aug 2024 11:06:06 +0000 Subject: [PATCH 101/116] [pre-commit.ci] auto fixes from pre-commit.com hooks for more information, see https://pre-commit.ci --- doc/source/api-reference/qibo.rst | 2 +- src/qibo/derivative.py | 8 ++++---- src/qibo/hamiltonians/abstract.py | 8 ++++---- src/qibo/hamiltonians/hamiltonians.py | 4 ++-- 4 files changed, 11 insertions(+), 11 deletions(-) diff --git a/doc/source/api-reference/qibo.rst b/doc/source/api-reference/qibo.rst index d086154dc4..1b254088b3 100644 --- a/doc/source/api-reference/qibo.rst +++ b/doc/source/api-reference/qibo.rst @@ -1213,7 +1213,7 @@ Matrix Hamiltonian ^^^^^^^^^^^^^^^^^^ The first implementation of Hamiltonians uses the full matrix representation -of the Hamiltonian operator in the computational basis. +of the Hamiltonian operator in the computational basis. For :math:`n` qubits, this matrix has size :math:`2^{n} \times 2^{n}`. Therefore, its construction is feasible only when :math:`n` is small. diff --git a/src/qibo/derivative.py b/src/qibo/derivative.py index 8d2d934e41..8361f9b7ec 100644 --- a/src/qibo/derivative.py +++ b/src/qibo/derivative.py @@ -21,8 +21,8 @@ def parameter_shift( parameter and an external object, such as a training variable in a Quantum Machine Learning problem. For example, performing a re-uploading strategy to embed some data into a circuit, we apply to the quantum state rotations - whose angles are in the form :math:`\\theta^{\\prime} = x \\, \\theta`, - where :math:`\\theta` is a variational parameter, and :math:`x` an input variable. + whose angles are in the form :math:`\\theta^{\\prime} = x \\, \\theta`, + where :math:`\\theta` is a variational parameter, and :math:`x` an input variable. The PSR allows to calculate the derivative with respect to :math:`\\theta^{\\prime}`. However, if we want to optimize a system with respect to its variational parameters, we need to "free" this procedure from the :math:`x` depencency. @@ -41,7 +41,7 @@ def parameter_shift( parameter_index (int): the index which identifies the target parameter in the ``circuit.get_parameters()`` list. initial_state (ndarray, optional): initial state on which the circuit - acts. If ``None``, defaults to the zero state :math:`\\ket{\\mathbf{0}}`. + acts. If ``None``, defaults to the zero state :math:`\\ket{\\mathbf{0}}`. Defaults to ``None``. scale_factor (float, optional): parameter scale factor. Defaults to :math:`1`. nshots (int, optional): number of shots if derivative is evaluated on @@ -184,7 +184,7 @@ def finite_differences( parameter_index (int): the index which identifies the target parameter in the :meth:`qibo.models.Circuit.get_parameters` list. initial_state (ndarray, optional): initial state on which the circuit - acts. If ``None``, defaults to the zero state :math:`\\ket{\\mathbf{0}}`. + acts. If ``None``, defaults to the zero state :math:`\\ket{\\mathbf{0}}`. Defaults to ``None``. step_size (float, optional): step size used to evaluate the finite difference. Defaults to :math:`10^{-7}`. diff --git a/src/qibo/hamiltonians/abstract.py b/src/qibo/hamiltonians/abstract.py index 4abf7d43af..bf19341b76 100644 --- a/src/qibo/hamiltonians/abstract.py +++ b/src/qibo/hamiltonians/abstract.py @@ -70,7 +70,7 @@ def expectation(self, state, normalize=False): # pragma: no cover Args: state (ndarray): state in which to calculate the expectation value. - normalize (bool, optional): If ``True``, the expectation value + normalize (bool, optional): If ``True``, the expectation value :math:`\\ell_{2}`-normalized. Defaults to ``False``. Returns: @@ -80,15 +80,15 @@ def expectation(self, state, normalize=False): # pragma: no cover @abstractmethod def expectation_from_samples(self, freq, qubit_map=None): # pragma: no cover - """Computes the expectation value of a diagonal observable, + """Computes the expectation value of a diagonal observable, given computational-basis measurement frequencies. Args: freq (collections.Counter): the keys are the observed values in binary form and the values the corresponding frequencies, that is the number of times each measured value/bitstring appears. - qubit_map (tuple): Mapping between frequencies and qubits. - If ``None``, then defaults to + qubit_map (tuple): Mapping between frequencies and qubits. + If ``None``, then defaults to :math:`[1, \\, 2, \\, \\cdots, \\, \\mathrm{len}(\\mathrm{key})]`. Defaults to ``None``. diff --git a/src/qibo/hamiltonians/hamiltonians.py b/src/qibo/hamiltonians/hamiltonians.py index d138d83e2e..d8264b4b44 100644 --- a/src/qibo/hamiltonians/hamiltonians.py +++ b/src/qibo/hamiltonians/hamiltonians.py @@ -84,7 +84,7 @@ def from_symbolic(cls, symbolic_hamiltonian, symbol_map, backend=None): Defaults to ``None``. Returns: - :class:`qibo.hamiltonians.SymbolicHamiltonian`: object that implements the + :class:`qibo.hamiltonians.SymbolicHamiltonian`: object that implements the Hamiltonian represented by the given symbolic expression. """ log.warning( @@ -177,7 +177,7 @@ def energy_fluctuation(self, state): Evaluate energy fluctuation: .. math:: - \\Xi_{k}(\\mu) = \\sqrt{\\bra{\\mu} \\, H^{2} \\, \\ket{\\mu} + \\Xi_{k}(\\mu) = \\sqrt{\\bra{\\mu} \\, H^{2} \\, \\ket{\\mu} - \\bra{\\mu} \\, H \\, \\ket{\\mu}^2} \\, . for a given state :math:`\\ket{\\mu}`. From 5b26fe696dbac5acfacbbf746c33be60ef405d41 Mon Sep 17 00:00:00 2001 From: Renato Mello Date: Mon, 26 Aug 2024 11:07:39 +0000 Subject: [PATCH 102/116] Update src/qibo/derivative.py --- src/qibo/derivative.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/derivative.py b/src/qibo/derivative.py index 8361f9b7ec..51ff7c39ea 100644 --- a/src/qibo/derivative.py +++ b/src/qibo/derivative.py @@ -36,7 +36,7 @@ def parameter_shift( circuit (:class:`qibo.models.circuit.Circuit`): custom quantum circuit. hamiltonian (:class:`qibo.hamiltonians.Hamiltonian`): target observable. if you want to execute on hardware, a symbolic hamiltonian must be - provided as follows (example with Pauli:math:`Z` and :math:`n = 1`): + provided as follows (example with Pauli-:math:`Z` and :math:`n = 1`): ``SymbolicHamiltonian(np.prod([ Z(i) for i in range(1) ]))``. parameter_index (int): the index which identifies the target parameter in the ``circuit.get_parameters()`` list. From 84597960d7e42900ce3d1f3426e4067e36269d75 Mon Sep 17 00:00:00 2001 From: Alessandro Candido Date: Wed, 21 Aug 2024 18:27:21 +0200 Subject: [PATCH 103/116] fix: Fix error type raised by backend construction --- src/qibo/backends/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/backends/__init__.py b/src/qibo/backends/__init__.py index f9334d00c1..b10357e805 100644 --- a/src/qibo/backends/__init__.py +++ b/src/qibo/backends/__init__.py @@ -228,7 +228,7 @@ def construct_backend(backend, **kwargs) -> Backend: if provider not in e.msg: raise e raise_error( - ValueError, + ImportError, f"The '{backend}' backends' provider is not available. Check that a Python " f"package named '{provider}' is installed, and it is exposing valid Qibo " "backends.", From 62a511c15302dcf38362c799947eaeb8bccf9563 Mon Sep 17 00:00:00 2001 From: Alessandro Candido Date: Thu, 22 Aug 2024 03:04:09 +0200 Subject: [PATCH 104/116] fix: Make error type more specific --- src/qibo/backends/__init__.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/src/qibo/backends/__init__.py b/src/qibo/backends/__init__.py index b10357e805..3498c1c23d 100644 --- a/src/qibo/backends/__init__.py +++ b/src/qibo/backends/__init__.py @@ -14,6 +14,10 @@ QIBO_NATIVE_BACKENDS = ("numpy", "tensorflow", "pytorch", "qulacs") +class MissingBackend(ValueError): + """Impossible to locate backend provider package.""" + + class MetaBackend: """Meta-backend class which takes care of loading the qibo backends.""" @@ -89,7 +93,7 @@ def __new__(cls): try: cls._instance = construct_backend(**kwargs) break - except (ModuleNotFoundError, ImportError): + except MissingBackend: pass if cls._instance is None: # pragma: no cover @@ -228,7 +232,7 @@ def construct_backend(backend, **kwargs) -> Backend: if provider not in e.msg: raise e raise_error( - ImportError, + MissingBackend, f"The '{backend}' backends' provider is not available. Check that a Python " f"package named '{provider}' is installed, and it is exposing valid Qibo " "backends.", From 94594968ed6366808a507ce153fd2b5d8bf5e898 Mon Sep 17 00:00:00 2001 From: Alessandro Candido Date: Thu, 22 Aug 2024 03:27:11 +0200 Subject: [PATCH 105/116] fix: Catch all errors during default backend creation --- src/qibo/backends/__init__.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/backends/__init__.py b/src/qibo/backends/__init__.py index 3498c1c23d..77aaab3442 100644 --- a/src/qibo/backends/__init__.py +++ b/src/qibo/backends/__init__.py @@ -93,7 +93,7 @@ def __new__(cls): try: cls._instance = construct_backend(**kwargs) break - except MissingBackend: + except (ImportError, MissingBackend): pass if cls._instance is None: # pragma: no cover From 8b080b0f9c1c5a49b54f8c1ecf1cbaf8ac6bf5a5 Mon Sep 17 00:00:00 2001 From: Alessandro Candido Date: Thu, 22 Aug 2024 12:47:47 +0200 Subject: [PATCH 106/116] test: Catch errors in uniform and non-redundant way --- tests/conftest.py | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/tests/conftest.py b/tests/conftest.py index 87ac46a011..538ed7a1e5 100644 --- a/tests/conftest.py +++ b/tests/conftest.py @@ -43,13 +43,13 @@ def get_backend(backend_name): AVAILABLE_BACKENDS.append(backend_name) if _backend.supports_multigpu: # pragma: no cover MULTIGPU_BACKENDS.append(backend_name) - except (ModuleNotFoundError, ImportError): + except ImportError: pass try: get_backend("qulacs") QULACS_INSTALLED = True -except ModuleNotFoundError: +except ImportError: QULACS_INSTALLED = False From 64461631f239ba988b171f6ad46762712a5dcb9c Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Thu, 29 Aug 2024 19:42:27 +0200 Subject: [PATCH 107/116] feat: implemented raw for M gate --- src/qibo/gates/abstract.py | 15 ++++++++++++++- src/qibo/gates/measurements.py | 24 +++++++++++++++++------- src/qibo/measurements.py | 9 +++++++-- 3 files changed, 38 insertions(+), 10 deletions(-) diff --git a/src/qibo/gates/abstract.py b/src/qibo/gates/abstract.py index b829392995..4ed3eadb32 100644 --- a/src/qibo/gates/abstract.py +++ b/src/qibo/gates/abstract.py @@ -14,7 +14,18 @@ "_target_qubits", "_control_qubits", ] -REQUIRED_FIELDS_INIT_KWARGS = ["theta", "phi", "lam", "phi0", "phi1"] +REQUIRED_FIELDS_INIT_KWARGS = [ + "theta", + "phi", + "lam", + "phi0", + "phi1", + "register_name", + "collapse", + "basis", + "p0", + "p1", +] class Gate: @@ -107,6 +118,8 @@ def from_dict(raw: dict): raise ValueError(f"Unknown gate {raw['_class']}") gate = cls(*raw["init_args"], **raw["init_kwargs"]) + if raw["_class"] == "M" and raw["samples"] is not None: + gate.result.register_samples(self.backend.cast(raw["samples"], int)) try: return gate.controlled_by(*raw["_control_qubits"]) except RuntimeError as e: diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py index 34e1ca4f1a..bf7af782c7 100644 --- a/src/qibo/gates/measurements.py +++ b/src/qibo/gates/measurements.py @@ -70,6 +70,7 @@ def __init__( self.init_kwargs = { "register_name": register_name, "collapse": collapse, + "basis": self.basis_gates, "p0": p0, "p1": p1, } @@ -102,6 +103,22 @@ def __init__( if gate is not None: self.basis.append(gate) + @property + def raw(self) -> dict: + """Serialize to dictionary. + + The values used in the serialization should be compatible with a + JSON dump (or any other one supporting a minimal set of scalar + types). Though the specific implementation is up to the specific + gate. + """ + encoded_simple = super().raw + encoded_simple.pop("_control_qubits") + basis = [g.__name__ for g in encoded_simple["init_kwargs"]["basis"]] + encoded_simple["init_kwargs"]["basis"] = basis + encoded_simple.update(self.result.raw) + return encoded_simple + @staticmethod def _get_bitflip_tuple( qubits: Tuple[int, ...], probs: "ProbsType" @@ -204,13 +221,6 @@ def apply_clifford(self, backend, state, nqubits): self.result.add_shot_from_sample(sample[0]) return state - def to_json(self): - """Serializes the measurement gate to json.""" - encoding = json.loads(super().to_json()) - encoding.pop("_control_qubits") - encoding.update({"basis": [g.__name__ for g in self.basis_gates]}) - return json.dumps(encoding) - @classmethod def load(cls, payload): """Constructs a measurement gate starting from a json serialized diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py index 7fae1fd695..1f6de9f893 100644 --- a/src/qibo/measurements.py +++ b/src/qibo/measurements.py @@ -96,6 +96,11 @@ def __repr__(self): nshots = self.nshots return f"MeasurementResult(qubits={qubits}, nshots={nshots})" + @property + def raw(self) -> dict: + samples = self._samples.tolist() if self.has_samples() else self._samples + return {"samples": samples} + def add_shot(self, probs): qubits = sorted(self.measurement_gate.target_qubits) shot = self.backend.sample_shots(probs, 1) @@ -117,12 +122,12 @@ def add_shot_from_sample(self, sample): def has_samples(self): return self._samples is not None - def register_samples(self, samples, backend=None): + def register_samples(self, samples): """Register samples array to the ``MeasurementResult`` object.""" self._samples = samples self.nshots = len(samples) - def register_frequencies(self, frequencies, backend=None): + def register_frequencies(self, frequencies): """Register frequencies to the ``MeasurementResult`` object.""" self._frequencies = frequencies self.nshots = sum(frequencies.values()) From fe42b66dea9737121aba15f5866b13b0ea4d0d41 Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Fri, 30 Aug 2024 10:19:34 +0200 Subject: [PATCH 108/116] fix: moving cast inside register_samples --- src/qibo/gates/abstract.py | 2 +- src/qibo/measurements.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/gates/abstract.py b/src/qibo/gates/abstract.py index 4ed3eadb32..e00733b72f 100644 --- a/src/qibo/gates/abstract.py +++ b/src/qibo/gates/abstract.py @@ -119,7 +119,7 @@ def from_dict(raw: dict): gate = cls(*raw["init_args"], **raw["init_kwargs"]) if raw["_class"] == "M" and raw["samples"] is not None: - gate.result.register_samples(self.backend.cast(raw["samples"], int)) + gate.result.register_samples(raw["samples"]) try: return gate.controlled_by(*raw["_control_qubits"]) except RuntimeError as e: diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py index 1f6de9f893..4c602ef17a 100644 --- a/src/qibo/measurements.py +++ b/src/qibo/measurements.py @@ -124,7 +124,7 @@ def has_samples(self): def register_samples(self, samples): """Register samples array to the ``MeasurementResult`` object.""" - self._samples = samples + self._samples = self.backend.cast(samples, int) self.nshots = len(samples) def register_frequencies(self, frequencies): From 5679978699b3b1783af6e799069391d7d8fe6b08 Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Fri, 30 Aug 2024 14:25:05 +0200 Subject: [PATCH 109/116] feat: accepting string as basis + replaced the load function --- src/qibo/backends/clifford.py | 2 +- src/qibo/gates/measurements.py | 51 +++++++++++++------------------ src/qibo/measurements.py | 6 ++-- src/qibo/quantum_info/clifford.py | 2 +- src/qibo/result.py | 6 ++-- 5 files changed, 30 insertions(+), 37 deletions(-) diff --git a/src/qibo/backends/clifford.py b/src/qibo/backends/clifford.py index 5fd2d1cd6d..1ba071cd40 100644 --- a/src/qibo/backends/clifford.py +++ b/src/qibo/backends/clifford.py @@ -259,7 +259,7 @@ def execute_circuit_repeated(self, circuit, nshots: int = 1000, initial_state=No samples = self.np.vstack(samples) for meas in circuit.measurements: - meas.result.register_samples(samples[:, meas.target_qubits], self) + meas.result.register_samples(samples[:, meas.target_qubits]) result = Clifford( self.zero_state(circuit.nqubits), diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py index bf7af782c7..4b63a58cb9 100644 --- a/src/qibo/gates/measurements.py +++ b/src/qibo/gates/measurements.py @@ -1,5 +1,5 @@ import json -from typing import Dict, Optional, Tuple +from typing import Dict, Optional, Tuple, Union from qibo import gates from qibo.config import raise_error @@ -23,11 +23,13 @@ class M(Gate): performed. Can be used only for single shot measurements. If ``True`` the collapsed state vector is returned. If ``False`` the measurement result is returned. - basis (:class:`qibo.gates.Gate`, list): Basis to measure. - Can be a qibo gate or a callable that accepts a qubit, - for example: ``lambda q: gates.RX(q, 0.2)`` - or a list of these, if a different basis will be used for each - measurement qubit. + basis (:class:`qibo.gates.Gate`, str, list): Basis to measure. + Can be either: + - a qibo gate + - the string representing the gate + - a callable that accepts a qubit, for example: ``lambda q: gates.RX(q, 0.2)`` + - a list of the above, if a different basis will be used for each + measurement qubit. Default is Z. p0 (dict): Optional bitflip probability map. Can be: A dictionary that maps each measured qubit to the probability @@ -46,7 +48,7 @@ def __init__( *q, register_name: Optional[str] = None, collapse: bool = False, - basis: Gate = Z, + basis: Union[Gate, str] = Z, p0: Optional["ProbsType"] = None, p1: Optional["ProbsType"] = None, ): @@ -61,16 +63,24 @@ def __init__( # relevant for experiments only self.pulses = None # saving basis for __repr__ ans save to file + to_gate = lambda x: getattr(gates, x) if isinstance(x, str) else x if not isinstance(basis, list): - self.basis_gates = len(q) * [basis] + self.basis_gates = len(q) * [to_gate(basis)] + basis = len(self.target_qubits) * [basis] + elif len(basis) != len(self.target_qubits): + raise_error( + ValueError, + f"Given basis list has length {len(basis)} while " + f"we are measuring {len(self.target_qubits)} qubits.", + ) else: - self.basis_gates = basis + self.basis_gates = [to_gate(g) for g in basis] self.init_args = q self.init_kwargs = { "register_name": register_name, "collapse": collapse, - "basis": self.basis_gates, + "basis": [g.__name__ for g in self.basis_gates], "p0": p0, "p1": p1, } @@ -89,16 +99,8 @@ def __init__( # list of gates that will be added to the circuit before the # measurement, in order to rotate to the given basis - if not isinstance(basis, list): - basis = len(self.target_qubits) * [basis] - elif len(basis) != len(self.target_qubits): - raise_error( - ValueError, - f"Given basis list has length {len(basis)} while " - f"we are measuring {len(self.target_qubits)} qubits.", - ) self.basis = [] - for qubit, basis_cls in zip(self.target_qubits, basis): + for qubit, basis_cls in zip(self.target_qubits, self.basis_gates): gate = basis_cls(qubit).basis_rotation() if gate is not None: self.basis.append(gate) @@ -113,9 +115,6 @@ def raw(self) -> dict: gate. """ encoded_simple = super().raw - encoded_simple.pop("_control_qubits") - basis = [g.__name__ for g in encoded_simple["init_kwargs"]["basis"]] - encoded_simple["init_kwargs"]["basis"] = basis encoded_simple.update(self.result.raw) return encoded_simple @@ -226,13 +225,7 @@ def load(cls, payload): """Constructs a measurement gate starting from a json serialized one.""" args = json.loads(payload) - # drop general serialization data, unused in this specialized loader - for key in ("name", "init_args", "_class"): - args.pop(key) - qubits = args.pop("_target_qubits") - args["basis"] = [getattr(gates, g) for g in args["basis"]] - args.update(args.pop("init_kwargs")) - return cls(*qubits, **args) + return cls.from_dict(args) # Overload on_qubits to copy also gate.result, controlled by can be removed for measurements def on_qubits(self, qubit_map) -> "Gate": diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py index 4c602ef17a..2409f8a134 100644 --- a/src/qibo/measurements.py +++ b/src/qibo/measurements.py @@ -80,8 +80,10 @@ class MeasurementResult: """ def __init__(self, gate, nshots=0, backend=None): + from qibo.backends import _check_backend + self.measurement_gate = gate - self.backend = backend + self.backend = _check_backend(backend) self.nshots = nshots self.circuit = None @@ -124,7 +126,7 @@ def has_samples(self): def register_samples(self, samples): """Register samples array to the ``MeasurementResult`` object.""" - self._samples = self.backend.cast(samples, int) + self._samples = self.backend.cast(samples, self.backend.np.int64) self.nshots = len(samples) def register_frequencies(self, frequencies): diff --git a/src/qibo/quantum_info/clifford.py b/src/qibo/quantum_info/clifford.py index 11d1b4e9ec..000aa6bcd0 100644 --- a/src/qibo/quantum_info/clifford.py +++ b/src/qibo/quantum_info/clifford.py @@ -269,7 +269,7 @@ def samples(self, binary: bool = True, registers: bool = False): self._samples = self._backend.cast(samples, dtype="int32") for gate in self.measurements: rqubits = tuple(qubit_map.get(q) for q in gate.target_qubits) - gate.result.register_samples(self._samples[:, rqubits], self._backend) + gate.result.register_samples(self._samples[:, rqubits]) if registers: return { diff --git a/src/qibo/result.py b/src/qibo/result.py index f9b101ac9e..b2fa8a95fd 100644 --- a/src/qibo/result.py +++ b/src/qibo/result.py @@ -244,7 +244,7 @@ def frequencies(self, binary: bool = True, registers: bool = False): if int(bitstring[qubit_map.get(q)]): idx += 2 ** (len(rqubits) - i - 1) rfreqs[idx] += freq - gate.result.register_frequencies(rfreqs, self.backend) + gate.result.register_frequencies(rfreqs) else: self._frequencies = self.backend.calculate_frequencies( self.samples(binary=False) @@ -356,9 +356,7 @@ def samples(self, binary: bool = True, registers: bool = False): self._samples = samples for gate in self.measurements: rqubits = tuple(qubit_map.get(q) for q in gate.target_qubits) - gate.result.register_samples( - self._samples[:, rqubits], self.backend - ) + gate.result.register_samples(self._samples[:, rqubits]) if registers: return { From 78f65d4019e0f0a9c6b0166bdebc5778a9ca36da Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Fri, 30 Aug 2024 18:12:59 +0200 Subject: [PATCH 110/116] feat: made nshots a property of measurement result --- src/qibo/measurements.py | 12 +++++++----- 1 file changed, 7 insertions(+), 5 deletions(-) diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py index 2409f8a134..88133cb20a 100644 --- a/src/qibo/measurements.py +++ b/src/qibo/measurements.py @@ -84,7 +84,6 @@ def __init__(self, gate, nshots=0, backend=None): self.measurement_gate = gate self.backend = _check_backend(backend) - self.nshots = nshots self.circuit = None self._samples = None @@ -103,6 +102,13 @@ def raw(self) -> dict: samples = self._samples.tolist() if self.has_samples() else self._samples return {"samples": samples} + @property + def nshots(self) -> int: + if self.has_samples(): + return len(self._samples) + elif self._frequencies is not None: + return sum(self._frequencies.values()) + def add_shot(self, probs): qubits = sorted(self.measurement_gate.target_qubits) shot = self.backend.sample_shots(probs, 1) @@ -111,7 +117,6 @@ def add_shot(self, probs): self._samples.append(bshot[0]) else: self._samples = [bshot[0]] - self.nshots += 1 return shot def add_shot_from_sample(self, sample): @@ -119,7 +124,6 @@ def add_shot_from_sample(self, sample): self._samples.append(sample) else: self._samples = [sample] - self.nshots += 1 def has_samples(self): return self._samples is not None @@ -127,12 +131,10 @@ def has_samples(self): def register_samples(self, samples): """Register samples array to the ``MeasurementResult`` object.""" self._samples = self.backend.cast(samples, self.backend.np.int64) - self.nshots = len(samples) def register_frequencies(self, frequencies): """Register frequencies to the ``MeasurementResult`` object.""" self._frequencies = frequencies - self.nshots = sum(frequencies.values()) def reset(self): """Remove all registered samples and frequencies.""" From 21da5d0eb23ea1d6b0d2b358dfe4523a56bf3a8e Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Fri, 30 Aug 2024 18:35:05 +0200 Subject: [PATCH 111/116] feat: removed backend from the measurement result attributes --- src/qibo/gates/measurements.py | 4 ++-- src/qibo/measurements.py | 31 +++++++++++++++++++------------ tests/test_states.py | 6 +++--- 3 files changed, 24 insertions(+), 17 deletions(-) diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py index 4b63a58cb9..6c911c343a 100644 --- a/src/qibo/gates/measurements.py +++ b/src/qibo/gates/measurements.py @@ -194,7 +194,7 @@ def apply(self, backend, state, nqubits): qubits = sorted(self.target_qubits) # measure and get result probs = backend.calculate_probabilities(state, qubits, nqubits) - shot = self.result.add_shot(probs) + shot = self.result.add_shot(probs, backend=backend) # collapse state return backend.collapse_state(state, qubits, shot, nqubits) @@ -206,7 +206,7 @@ def apply_density_matrix(self, backend, state, nqubits): qubits = sorted(self.target_qubits) # measure and get result probs = backend.calculate_probabilities_density_matrix(state, qubits, nqubits) - shot = self.result.add_shot(probs) + shot = self.result.add_shot(probs, backend=backend) # collapse state return backend.collapse_density_matrix(state, qubits, shot, nqubits) diff --git a/src/qibo/measurements.py b/src/qibo/measurements.py index 88133cb20a..3c8f6d2231 100644 --- a/src/qibo/measurements.py +++ b/src/qibo/measurements.py @@ -7,6 +7,13 @@ from qibo.config import raise_error +def _check_backend(backend): + """This is only needed due to the circular import with qibo.backends.""" + from qibo.backends import _check_backend + + return _check_backend(backend) + + def frequencies_to_binary(frequencies, nqubits): return collections.Counter( {"{:b}".format(k).zfill(nqubits): v for k, v in frequencies.items()} @@ -79,11 +86,8 @@ class MeasurementResult: to use for calculations. """ - def __init__(self, gate, nshots=0, backend=None): - from qibo.backends import _check_backend - + def __init__(self, gate): self.measurement_gate = gate - self.backend = _check_backend(backend) self.circuit = None self._samples = None @@ -109,10 +113,11 @@ def nshots(self) -> int: elif self._frequencies is not None: return sum(self._frequencies.values()) - def add_shot(self, probs): + def add_shot(self, probs, backend=None): + backend = _check_backend(backend) qubits = sorted(self.measurement_gate.target_qubits) - shot = self.backend.sample_shots(probs, 1) - bshot = self.backend.samples_to_binary(shot, len(qubits)) + shot = backend.sample_shots(probs, 1) + bshot = backend.samples_to_binary(shot, len(qubits)) if self._samples: self._samples.append(bshot[0]) else: @@ -130,7 +135,7 @@ def has_samples(self): def register_samples(self, samples): """Register samples array to the ``MeasurementResult`` object.""" - self._samples = self.backend.cast(samples, self.backend.np.int64) + self._samples = samples def register_frequencies(self, frequencies): """Register frequencies to the ``MeasurementResult`` object.""" @@ -153,7 +158,7 @@ def symbols(self): return self._symbols - def samples(self, binary=True, registers=False): + def samples(self, binary=True, registers=False, backend=None): """Returns raw measurement samples. Args: @@ -168,6 +173,7 @@ def samples(self, binary=True, registers=False): samples are returned in decimal form as a tensor of shape `(nshots,)`. """ + backend = _check_backend(backend) if self._samples is None: if self.circuit is None: raise_error( @@ -181,9 +187,9 @@ def samples(self, binary=True, registers=False): return self._samples qubits = self.measurement_gate.target_qubits - return self.backend.samples_to_decimal(self._samples, len(qubits)) + return backend.samples_to_decimal(self._samples, len(qubits)) - def frequencies(self, binary=True, registers=False): + def frequencies(self, binary=True, registers=False, backend=None): """Returns the frequencies of measured samples. Args: @@ -201,8 +207,9 @@ def frequencies(self, binary=True, registers=False): If `binary` is `False` the keys of the `Counter` are integers. """ + backend = _check_backend(backend) if self._frequencies is None: - self._frequencies = self.backend.calculate_frequencies( + self._frequencies = backend.calculate_frequencies( self.samples(binary=False) ) if binary: diff --git a/tests/test_states.py b/tests/test_states.py index fc0cd512d2..9ce556485b 100644 --- a/tests/test_states.py +++ b/tests/test_states.py @@ -8,12 +8,12 @@ def test_measurement_result_repr(): - result = MeasurementResult(gates.M(0), nshots=10) - assert str(result) == "MeasurementResult(qubits=(0,), nshots=10)" + result = MeasurementResult(gates.M(0)) + assert str(result) == "MeasurementResult(qubits=(0,), nshots=None)" def test_measurement_result_error(): - result = MeasurementResult(gates.M(0), nshots=10) + result = MeasurementResult(gates.M(0)) with pytest.raises(RuntimeError): samples = result.samples() From 66332782ba85274aea8b63fbbec6507ab39562a5 Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Fri, 30 Aug 2024 18:52:40 +0200 Subject: [PATCH 112/116] feat: changed raw of M --- src/qibo/gates/abstract.py | 2 +- src/qibo/gates/measurements.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/src/qibo/gates/abstract.py b/src/qibo/gates/abstract.py index e00733b72f..d8bfc9dd21 100644 --- a/src/qibo/gates/abstract.py +++ b/src/qibo/gates/abstract.py @@ -119,7 +119,7 @@ def from_dict(raw: dict): gate = cls(*raw["init_args"], **raw["init_kwargs"]) if raw["_class"] == "M" and raw["samples"] is not None: - gate.result.register_samples(raw["samples"]) + gate.result.register_samples(raw["measurement_result"]["samples"]) try: return gate.controlled_by(*raw["_control_qubits"]) except RuntimeError as e: diff --git a/src/qibo/gates/measurements.py b/src/qibo/gates/measurements.py index 6c911c343a..7e1559e9d9 100644 --- a/src/qibo/gates/measurements.py +++ b/src/qibo/gates/measurements.py @@ -115,7 +115,7 @@ def raw(self) -> dict: gate. """ encoded_simple = super().raw - encoded_simple.update(self.result.raw) + encoded_simple.update({"measurement_result": self.result.raw}) return encoded_simple @staticmethod From aa574459557bcc78c98a6be6e41595fd99ee6795 Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Fri, 30 Aug 2024 19:11:45 +0200 Subject: [PATCH 113/116] fix: tiny fix --- src/qibo/gates/abstract.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/qibo/gates/abstract.py b/src/qibo/gates/abstract.py index d8bfc9dd21..250c309934 100644 --- a/src/qibo/gates/abstract.py +++ b/src/qibo/gates/abstract.py @@ -118,7 +118,7 @@ def from_dict(raw: dict): raise ValueError(f"Unknown gate {raw['_class']}") gate = cls(*raw["init_args"], **raw["init_kwargs"]) - if raw["_class"] == "M" and raw["samples"] is not None: + if raw["_class"] == "M" and raw["measurement_result"]["samples"] is not None: gate.result.register_samples(raw["measurement_result"]["samples"]) try: return gate.controlled_by(*raw["_control_qubits"]) From 8df290787613df62998a5dc8a4a94eb3a4fd7194 Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Sat, 31 Aug 2024 11:26:57 +0200 Subject: [PATCH 114/116] test: added test for nshots --- tests/test_measurements.py | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/tests/test_measurements.py b/tests/test_measurements.py index 050d2c1970..55fb4b665f 100644 --- a/tests/test_measurements.py +++ b/tests/test_measurements.py @@ -6,6 +6,7 @@ import pytest from qibo import gates, models +from qibo.measurements import MeasurementResult def assert_result( @@ -473,3 +474,23 @@ def test_measurementsymbol_pickling(backend): assert symbol.index == new_symbol.index assert symbol.name == new_symbol.name backend.assert_allclose(symbol.result.samples(), new_symbol.result.samples()) + + +def test_measurementresult_nshots(backend): + gate = gates.M(*range(3)) + result = MeasurementResult(gate) + # nshots starting from samples + nshots = 10 + samples = backend.cast( + [[i % 2, i % 2, i % 2] for i in range(nshots)], backend.np.int64 + ) + result.register_samples(samples) + assert result.nshots == nshots + # nshots starting from frequencies + result = MeasurementResult(gate) + states, counts = np.unique(samples, axis=0, return_counts=True) + to_str = lambda x: [str(item) for item in x] + states = ["".join(to_str(s)) for s in states.tolist()] + freq = dict(zip(states, counts.tolist())) + result.register_frequencies(freq) + assert result.nshots == nshots From 7864590905c676d043f5ede50567529ba5ddc267 Mon Sep 17 00:00:00 2001 From: BrunoLiegiBastonLiegi Date: Sat, 31 Aug 2024 11:55:01 +0200 Subject: [PATCH 115/116] test: added test for M serialization --- tests/test_measurements.py | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+) diff --git a/tests/test_measurements.py b/tests/test_measurements.py index 55fb4b665f..979cb843b6 100644 --- a/tests/test_measurements.py +++ b/tests/test_measurements.py @@ -1,5 +1,6 @@ """Test circuit result measurements and measurement gate and as part of circuit.""" +import json import pickle import numpy as np @@ -494,3 +495,21 @@ def test_measurementresult_nshots(backend): freq = dict(zip(states, counts.tolist())) result.register_frequencies(freq) assert result.nshots == nshots + + +def test_measurement_serialization(backend): + kwargs = { + "register_name": "test", + "collapse": False, + "basis": ["Z", "X", "Y"], + "p0": 0.1, + "p1": 0.2, + } + gate = gates.M(*range(3), **kwargs) + samples = backend.cast(np.random.randint(2, size=(100, 3)), backend.np.int64) + gate.result.register_samples(samples) + dump = gate.to_json() + load = gates.M.from_dict(json.loads(dump)) + for k, v in kwargs.items(): + assert load.init_kwargs[k] == v + backend.assert_allclose(samples, load.result.samples()) From 6464a6d52df870bf41ab2d82beab51fc3d11a4f0 Mon Sep 17 00:00:00 2001 From: sergiomtzlosa Date: Wed, 4 Sep 2024 10:14:06 +0200 Subject: [PATCH 116/116] update documentation for new matplotlib circuit plot --- doc/source/code-examples/examples.rst | 45 +++++++ src/qibo/ui/drawer_utils.py | 10 +- src/qibo/ui/mpldrawer.py | 177 +++++++++++++++++++------- 3 files changed, 187 insertions(+), 45 deletions(-) diff --git a/doc/source/code-examples/examples.rst b/doc/source/code-examples/examples.rst index 1d3d43b52b..1896cffb51 100644 --- a/doc/source/code-examples/examples.rst +++ b/doc/source/code-examples/examples.rst @@ -327,3 +327,48 @@ For example q2: ──────o──|──|────o──|──|──H─U1─U1────────|─|─ q3: ─────────o──|───────o──|────o──|──H─U1───|─x─ q4: ────────────o──────────o───────o────o──H─x─── + +How to visualize a circuit with style? +-------------------------------------- + +Qibo is able to draw a circuit using ``matplotlib`` library by calling the function ``plot_circuit``. It also have built-in styles ready to use +and also it is possible to apply custom styles to the circuit. The function is able to cluster the gates to reduce the circuit depth. +The built-in styles are: ``garnacha``, ``fardelejo``, ``quantumspain``, ``color-blind``, ``cachirulo`` or custom dictionary. + +For example, we can draw the QFT circuit for 5-qubits: + +.. testcode:: + + import matplotlib.pyplot as plt + import qibo + from qibo import gates, models + from qibo.models import QFT + + # new plot function based on matplotlib + from qibo.ui import plot_circuit + + %matplotlib inline + + # create a 5-qubits QFT circuit + c = QFT(5) + c.add(gates.M(qubit) for qubit in range(2)) + + # print circuit with default options (default black & white style, scale factor of 0.6 and clustered gates) + plot_circuit(c); + + # print the circuit with built-int style "garnacha", clustering gates and a custom scale factor + # built-in styles: "garnacha", "fardelejo", "quantumspain", "color-blind", "cachirulo" or custom dictionary + plot_circuit(c, scale = 0.8, cluster_gates = True, style="garnacha"); + + # plot the Qibo circuit with a custom style + custom_style = { + "facecolor" : "#6497bf", + "edgecolor" : "#01016f", + "linecolor" : "#01016f", + "textcolor" : "#01016f", + "fillcolor" : "#ffb9b9", + "gatecolor" : "#d8031c", + "controlcolor" : "#360000" + } + + plot_circuit(c, scale = 0.8, cluster_gates = True, style=custom_style); diff --git a/src/qibo/ui/drawer_utils.py b/src/qibo/ui/drawer_utils.py index d6779c4821..59e8fc2ab7 100644 --- a/src/qibo/ui/drawer_utils.py +++ b/src/qibo/ui/drawer_utils.py @@ -2,7 +2,10 @@ class FusedStartGateBarrier(Gate): - """Special gate barrier gate to pin the starting point of fused gates""" + """ + :class:`qibo.ui.drawer_utils.FusedStartGateBarrier` gives room to fused group of gates. + Inherit from ``qibo.gates.abstract.Gate``. A special gate barrier gate to pin the starting point of fused gates. + """ def __init__(self, q_ctrl, q_trgt, nfused, equal_qbits=False): @@ -22,7 +25,10 @@ def __init__(self, q_ctrl, q_trgt, nfused, equal_qbits=False): class FusedEndGateBarrier(Gate): - """Special gate barrier gate to pin the ending point of fused gates""" + """ + :class:`qibo.ui.drawer_utils.FusedEndGateBarrier` gives room to fused group of gates. + Inherit from ``qibo.gates.abstract.Gate``. A special gate barrier gate to pin the ending point of fused gates. + """ def __init__(self, q_ctrl, q_trgt): diff --git a/src/qibo/ui/mpldrawer.py b/src/qibo/ui/mpldrawer.py index 6997743d62..778a429fe2 100644 --- a/src/qibo/ui/mpldrawer.py +++ b/src/qibo/ui/mpldrawer.py @@ -38,15 +38,22 @@ def _plot_quantum_schedule( schedule, inits, plot_params, labels=[], plot_labels=True, **kwargs ): - """Use Matplotlib to plot a quantum circuit. - schedule List of time steps, each containing a sequence of gates during that step. - Each gate is a tuple containing (name,target,control1,control2...). - Targets and controls initially defined in terms of labels - inits Initialization list of gates - plot_params Style plot configuration - labels List of qubit labels, optional - - kwargs Can override plot_parameters + """Use Matplotlib to plot a queue of quantum circuit. + + Args: + schedule (list): List of time steps, each containing a sequence of gates during that step. + Each gate is a tuple containing (name,target,control1,control2...). Targets and controls initially defined in terms of labels. + + inits (list): Initialization list of gates. + + plot_params (list): Style plot configuration. + + labels (list): List of qubit labels, optional. + + kwargs (list): Variadic list that can override plot parameters. + + Returns: + matplotlib.axes.Axes: An Axes object encapsulates all the plt elements of a plot in a figure. """ return _plot_quantum_circuit( @@ -64,14 +71,21 @@ def _plot_quantum_circuit( gates, inits, plot_params, labels=[], plot_labels=True, schedule=False, **kwargs ): """Use Matplotlib to plot a quantum circuit. - gates List of tuples for each gate in the quantum circuit. - (name,target,control1,control2...). Targets and controls initially - defined in terms of labels. - inits Initialization list of gates - plot_params Style plot configuration - labels List of qubit labels. optional - - kwargs Can override plot_parameters + + Args: + gates (list): List of tuples for each gate in the quantum circuit. (name,target,control1,control2...). + Targets and controls initially defined in terms of labels. + + inits (list): Initialization list of gates. + + plot_params (list): Style plot configuration. + + labels (list): List of qubit labels. (optional). + + kwargs (list): Variadic list that can override plot parameters. + + Returns: + matplotlib.axes.Axes: An Axes object encapsulates all the plt elements of a plot in a figure. """ plot_params.update(kwargs) @@ -118,7 +132,19 @@ def _plot_quantum_circuit( def _enumerate_gates(gates_plot, schedule=False): - "Enumerate the gates in a way that can take l as either a list of gates or a schedule" + """Enumerate the gates in a way that can take l as either a list of gates or a schedule + + Args: + gates_plot (list): List of gates to plot. + + schedule (bool): Check whether process single gate or array of gates at a time. + + Returns: + int: Index of gate or list of gates. + + list: Processed list of gates ready to plot. + """ + if schedule: for i, gates in enumerate(gates_plot): for gate in gates: @@ -129,7 +155,6 @@ def _enumerate_gates(gates_plot, schedule=False): def _measured_wires(gates_plot, labels, schedule=False): - "measured[i] = j means wire i is measured at step j" measured = {} for i, gate in _enumerate_gates(gates_plot, schedule=schedule): name, target = gate[:2] @@ -140,7 +165,14 @@ def _measured_wires(gates_plot, labels, schedule=False): def _draw_gates( - ax, gates_plot, labels, gate_grid, wire_grid, plot_params, measured={}, schedule=False + ax, + gates_plot, + labels, + gate_grid, + wire_grid, + plot_params, + measured={}, + schedule=False, ): for i, gate in _enumerate_gates(gates_plot, schedule=schedule): _draw_target(ax, i, gate, labels, gate_grid, wire_grid, plot_params) @@ -427,13 +459,6 @@ def _get_all_tuple_items(iterable): def _get_flipped_index(target, labels): - """Get qubit labels from the rest of the line,and return indices - - >>> _get_flipped_index('q0', ['q0', 'q1']) - 1 - >>> _get_flipped_index('q1', ['q0', 'q1']) - 0 - """ nq = len(labels) i = labels.index(target) return nq - i - 1 @@ -466,13 +491,6 @@ def _get_flipped_indices(targets, labels): def _render_label(label, inits={}): - """Slightly more flexible way to render labels. - - >>> _render_label('q0') - '$|q0\\\\rangle$' - >>> _render_label('q0', {'q0':'0'}) - '$|0\\\\rangle$' - """ if label in inits: s = inits[label] if s is None: @@ -482,7 +500,20 @@ def _render_label(label, inits={}): return r"$|%s\rangle$" % label +def _check_list_str(substrings, string): + return any(item in string for item in substrings) + + def _make_cluster_gates(gates_items): + """ + Given a list of gates from a Qibo circuit, this fucntion gathers all gates to reduce the depth of the circuit making the circuit more user-friendly to avoid very large circuits printed on screen. + + Args: + gates_items (list): List of gates to gather for circuit depth reduction. + + Returns: + list: List of gathered gates. + """ temp_gates = [] temp_mgates = [] @@ -522,11 +553,16 @@ def _make_cluster_gates(gates_items): return cluster_gates -def _check_list_str(substrings, string): - return any(item in string for item in substrings) +def _process_gates(array_gates): + """ + Transforms the list of gates given by the Qibo circuit into a list of gates with a suitable structre to print on screen with matplotlib. + Args: + array_gates (list): List of gates provided by the Qibo circuit. -def _process_gates(array_gates): + Returns: + list: List of suitable gates to plot with matplotlib. + """ if len(array_gates) == 0: return [] @@ -591,6 +627,15 @@ def _process_gates(array_gates): def _plot_params(style: Union[dict, str, None]) -> dict: + """ + Given a style name, the function gets the style configuration, if the style is not available, it return the default style. It is allowed to give a custom dictionary to give the circuit a style. + + Args: + style (Union[dict, str, None]): Name of the style. + + Returns: + dict: Style configuration. + """ if not isinstance(style, dict): try: style = STYLE.get(style) if (style is not None) else STYLE["default"] @@ -602,13 +647,59 @@ def _plot_params(style: Union[dict, str, None]) -> dict: def plot_circuit(circuit, scale=0.6, cluster_gates=True, style=None): """Main matplotlib plot function for Qibo circuit - circuit A Qibo circuit to plot (type: qibo.models.circuit.Circuit) - scale Scale the ouput plot - cluster_gates Group single-qubit gates - style Style applied to the circuit (built-in styles: garnacha, fardelejo, quantumspain, color-blind and cachirulo) - ax An Axes object encapsulates all the elements of an individual plot in a figure (type: matplotlib.axes._axes.Axes) - ax.figure A Figure object (type: matplotlib.figure.Figure) + Args: + circuit (qibo.models.circuit.Circuit): A Qibo circuit to plot. + + scale (float): Scaling factor for matplotlib output drawing. + + cluster_gates (boolean): Group (or not) circuit gates on drawing. + + style (Union[dict, str, None]): Style applied to the circuit, it can a built-in sytle or custom + (built-in styles: garnacha, fardelejo, quantumspain, color-blind, cachirulo or custom dictionary). + + Returns: + matplotlib.axes.Axes: Axes object that encapsulates all the elements of an individual plot in a figure. + + matplotlib.figure.Figure: A matplotlib figure object. + + Example: + + .. testcode:: + + import matplotlib.pyplot as plt + import qibo + from qibo import gates, models + from qibo.models import QFT + + # new plot function based on matplotlib + from qibo.ui import plot_circuit + + %matplotlib inline + + # create a 5-qubits QFT circuit + c = QFT(5) + c.add(gates.M(qubit) for qubit in range(2)) + + # print circuit with default options (default black & white style, scale factor of 0.6 and clustered gates) + plot_circuit(c); + + # print the circuit with built-int style "garnacha", clustering gates and a custom scale factor + # built-in styles: "garnacha", "fardelejo", "quantumspain", "color-blind", "cachirulo" or custom dictionary + plot_circuit(c, scale = 0.8, cluster_gates = True, style="garnacha"); + + # plot the Qibo circuit with a custom style + custom_style = { + "facecolor" : "#6497bf", + "edgecolor" : "#01016f", + "linecolor" : "#01016f", + "textcolor" : "#01016f", + "fillcolor" : "#ffb9b9", + "gatecolor" : "#d8031c", + "controlcolor" : "#360000" + } + + plot_circuit(c, scale = 0.8, cluster_gates = True, style=custom_style); """ params = PLOT_PARAMS.copy()