quarkcircuit 0.3.0.dev2__tar.gz → 0.3.2__tar.gz

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quarkcircuit
-Version: 0.3.0.dev2
+Version: 0.3.2
 Summary: Construction, visualization, and transpilation of quantum circuits
 Author-email: Xiaoxiao Xiao <xiaoxx@baqis.ac.cn>
 License-Expression: MIT

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "quarkcircuit"
-version = "0.3.0dev2"
+version = "0.3.2"
 authors = [
   { name="Xiaoxiao Xiao", email="xiaoxx@baqis.ac.cn" }
 ]

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.2}/quark/circuit/backend.py

@@ -56,7 +56,7 @@ class Backend:
             self.priority_qubits = self.chip_info['priority_qubits']
             self.qubits_with_attributes = self._collect_qubits_with_attributes()
             self.couplers_with_attributes = self._collect_couplers_with_attributes()
-        elif chip in ['Baihua','Dongling','Haituo','Yunmeng','Miaofeng',]:
+        elif chip in ['Baihua','Dongling','Haituo','Yunmeng','Miaofeng','Yudu','Hongluo']:
             self.chip_name = chip
             try:
                 self.chip_info = load_chip_basic_info(chip)
@@ -140,14 +140,14 @@ class Backend:
         G.add_edges_from(self.couplers_with_attributes)
         return G
         
-    def draw(self,show_couplers_fidelity:bool = False, show_quibts_attributes:Literal['T1','T2','fidelity','frequency','']='', 
+    def draw(self,show_couplers_fidelity:bool = False, show_qubits_attributes:Literal['T1','T2','fidelity','frequency','']='', 
              show_qubits_index:bool=False,show_couplers_index:bool=False,
-             highlight_nodes:list = [], save_svg_fname: str|None = None,):
+             highlight_nodes:list = [], save_svg_fname: str|None = None):
         """Draw the chip layout.
     
         Args:
             show_couplers_fidelity (bool, optional): Whether to display the fidelity of couplers. Defaults to False.
-            show_quibts_attributes (Literal['T1', 'T2', 'fidelity', 'frequancy', ''], optional): 
+            show_qubits_attributes (Literal['T1', 'T2', 'fidelity', 'frequancy', ''], optional): 
                 Specify which qubit attribute to display. Options include:
                 - 'T1': Display the T1 time of qubits (in microseconds).
                 - 'T2': Display the T2 time of qubits (in microseconds).
@@ -167,7 +167,7 @@ class Backend:
     
         Notes:
             - `highlight_nodes` specifies the qubits to be visually highlighted.
-            - `show_couplers_fidelity` and `show_quibts_attributes` can be enabled simultaneously without conflicts.
+            - `show_couplers_fidelity` and `show_qubits_attributes` can be enabled simultaneously without conflicts.
             - When `save_svg_fname` is provided, the drawing will be saved as an SVG file.
         """
         import matplotlib.pyplot as plt 
@@ -176,15 +176,15 @@ class Backend:
 
 
         edge_fidelity = nx.get_edge_attributes(self.graph, 'fidelity') 
-        node_attributes = nx.get_node_attributes(self.graph,show_quibts_attributes)
+        node_attributes = nx.get_node_attributes(self.graph,show_qubits_attributes)
         if show_couplers_fidelity:
-            if set(list(edge_fidelity.values())) == {None}:
+            if set(list(edge_fidelity.values())) == {0}:
                 print('The two-qubit gate fidelity is N/A now.')
                 is_edge_info_avaliable = False
             else:
                 is_edge_info_avaliable = True
-        if show_quibts_attributes:
-            if set(list(node_attributes.values())) == {None}:
+        if show_qubits_attributes:
+            if set(list(node_attributes.values())) == {0}:
                 print('The qubit attributes is N/A now.')
                 is_node_info_avaliable = False
             else:
@@ -213,13 +213,13 @@ class Backend:
             else:
                 edge_labels[k] = self.graph.edges[k].get('index')
 
-        if show_quibts_attributes != '' and is_node_info_avaliable is True:
+        if show_qubits_attributes != '' and is_node_info_avaliable is True:
             min_attributes = sorted(list(node_attributes.values()))[0]
             max_attributes = sorted(list(node_attributes.values()))[-1]
             node_norm = Normalize(vmin = min_attributes, vmax = max_attributes)
             node_cmap = LinearSegmentedColormap.from_list('truncated_blues', plt.get_cmap('Blues')(np.linspace(0.31, 1.0, 1000))) #plt.get_cmap('Blues') 
             node_colors = [ScalarMappable(norm = node_norm, cmap = node_cmap).to_rgba(attribute) for attribute in node_attributes.values()]
-            if show_quibts_attributes == 'fidelity':
+            if show_qubits_attributes == 'fidelity':
                 if show_qubits_index:
                     node_labels = {node:node for node in self.graph.nodes()} 
                 else:
@@ -244,6 +244,8 @@ class Backend:
                 figsize = (15, 13)
 
         if len(highlight_nodes) > 0:
+            if isinstance(highlight_nodes, list) and any(isinstance(i, list) for i in highlight_nodes):
+                highlight_nodes = list(set(e for sub in highlight_nodes for e in sub))
             node_colors_update = []
             node_labels_update = {}
             for idx, node in enumerate(self.graph.nodes()):
@@ -273,16 +275,16 @@ class Backend:
         pos = nx.get_node_attributes(self.graph, 'coordinate') 
         nx.draw(self.graph, pos,ax=ax, with_labels=False, node_color=node_colors, node_size=800, edgecolors='white',edge_color = edge_colors ,width = 18,) 
         nx.draw_networkx_labels(self.graph,pos,labels=node_labels,font_size=node_font_size, font_color='white')
-        nx.draw_networkx_edge_labels(self.graph, pos, edge_labels=edge_labels,font_size=8, font_color='white',bbox=dict(facecolor='none', edgecolor='none'))
+        nx.draw_networkx_edge_labels(self.graph, pos, edge_labels=edge_labels,font_size=8, font_color='white',bbox=dict(facecolor='none', edgecolor='none'),rotate=False)
 
-        if show_quibts_attributes != '' and is_node_info_avaliable is True:
-            if show_quibts_attributes == 'T1':
+        if show_qubits_attributes != '' and is_node_info_avaliable is True:
+            if show_qubits_attributes == 'T1':
                 show_label = 'T1 ($\mu s$)'
-            elif show_quibts_attributes == 'T2':
+            elif show_qubits_attributes == 'T2':
                 show_label = 'T2 ($\mu s$)'
-            elif show_quibts_attributes == 'fidelity':
+            elif show_qubits_attributes == 'fidelity':
                 show_label = 'Single qubit gate fidelity'
-            elif show_quibts_attributes == 'frequency':
+            elif show_qubits_attributes == 'frequency':
                 show_label = 'Frequency (GHz)'
             node_sm = ScalarMappable(cmap=node_cmap, norm=node_norm)
             node_sm.set_array(list(node_attributes.values()))  # 设置包含数据的数组
@@ -298,12 +300,14 @@ class Backend:
             edge_cbar = fig.colorbar(edge_sm, ax=ax, orientation='horizontal',  pad=0.001, fraction=0.0333, aspect=25)# 调整颜色条大小和位置，放置在底部
             edge_cbar.set_label('CZ fidelity')
 
-        xlim = ax.get_xlim()
+        xlim = ax.get_xlim() 
         ylim = ax.get_ylim()
         xpos = (xlim[0] + xlim[1]) / 2
-        ypos = ylim[1] * 0.96
+        ypos = ylim[0] - (ylim[1] - ylim[0]) * -0.03  # 计算标题位置
         ax.text(xpos, ypos, f'{self.chip_name}', va='center', ha='center', fontsize=24, fontweight='bold', color='k', family='serif')
 
+        ax.invert_yaxis() # y 轴正半轴朝下
+
         if save_svg_fname:
             plt.savefig(save_svg_fname + '.svg', transparent=True, dpi=300, bbox_inches='tight') 
         plt.show()

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.2}/quark/circuit/decompose.py

@@ -147,7 +147,7 @@ def cx_decompose(control_qubit: int, target_qubit: int,convert_single_qubit_gate
     return gates
 
 def cy_decompose(control_qubit: int, target_qubit: int, convert_single_qubit_gate_to_u:bool, two_qubit_gate_basis:Literal['cz','cx']) -> list:
-    """ Decompose CY gate with kak algorithm. 
+    """ Decompose CY gate to U3 gates and CZ gates. 
 
     Args:
         control_qubit (int): The qubit used as control.
@@ -366,6 +366,40 @@ def rzz_decompose(theta:float, qubit1:int, qubit2:int, convert_single_qubit_gate
         gates += cx_decompose(qubit1,qubit2,convert_single_qubit_gate_to_u,two_qubit_gate_basis)  
     return gates
 
+
+def cp_decompose(theta:float, control_qubit:int, target_qubit:int, convert_single_qubit_gate_to_u:bool) -> list:
+    """Decompose CPhase gate to U3 gates and CZ gates. ref: Quantum Sci. Technol. 7 (2022) 025021
+
+    Args:
+        theta (float): The rotation angle of the gate.
+        control_qubit (int): The qubit used as control.
+        target_qubit (int): The qubit targeted by the gate.
+
+    Returns:
+        list: A list of U3 gates and CZ gates.
+    """ 
+    gates = []
+    if convert_single_qubit_gate_to_u:
+        gates.append(h2u(target_qubit))
+    else:
+        gates.append(('h',target_qubit))
+    gates.append(('cz', control_qubit, target_qubit))
+    if convert_single_qubit_gate_to_u:
+        gates.append(rx2u(theta/2,target_qubit))
+    else:
+        gates.append(('rx',theta/2,target_qubit))
+    gates.append(('cz', control_qubit, target_qubit))
+    if convert_single_qubit_gate_to_u:
+        gates.append(rz2u(-1*theta/2, control_qubit))
+        gates.append(h2u(target_qubit))
+        gates.append(rz2u(-1*theta/2,target_qubit))
+    else:
+        gates.append(('rz',-1*theta/2,control_qubit))
+        gates.append(('h',target_qubit))
+        gates.append(('rz',-1*theta/2,target_qubit))
+    return gates
+
+
 def ccx_decompose(control_qubit1: int, control_qubit2: int, target_qubit: int,):
     """Decompose ccx gate. Reference: A biological sequence comparison algorithm using quantum computers
 

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.2}/quark/circuit/layout.py

@@ -29,16 +29,14 @@ import numpy as np
 from typing import Literal
 from itertools import combinations,zip_longest,product
 from multiprocessing import Pool
-from functools import partial,lru_cache
+from functools import partial
 from .backend import Backend
 
 class Layout:
     """
     Responsible for selecting suitable qubit layouts from a given chip for a quantum circuit.
 
-    This class generates qubit layouts based on the required number of qubits, performance metrics, 
-    and the topology of the chip. It is designed to help map and execute quantum circuits on 
-    specific quantum hardware.
+    This class generates qubit layouts based on the required number of qubits, performance metrics, and the topology of the chip. It is designed to help map and execute quantum circuits on specific quantum hardware.
     """
     def __init__(self,nqubits: int, chip_backend: Backend):
         """Initialize the Layout class with the required number of qubits and chip backend.
@@ -51,11 +49,11 @@ class Layout:
         self.nqubits = nqubits
         self.size = chip_backend.size
         self.priority_qubits = chip_backend.priority_qubits
-        self.graph = chip_backend.edge_filtered_graph()
+        self.graph = chip_backend.edge_filtered_graph(thres=0.95)
         self.ncore = os.cpu_count() // 2 
         self.fidelity_mean_threshold = 0.9
+        self.edge_fidelitys = nx.get_edge_attributes(self.graph,'fidelity')
 
-    @lru_cache(maxsize=128)
     def _get_node_neighbours(self,node:int):
         return list(self.graph.neighbors(node))
     
@@ -154,7 +152,7 @@ class Layout:
         """
         subgraph = self.graph.subgraph(nodes)
         subgraph_degree = dict(subgraph.degree())
-        subgraph_fidelity = np.array([data['fidelity'] for _, _, data in subgraph.edges(data=True)])
+        subgraph_fidelity = np.array([self.edge_fidelitys[(min(edge),max(edge))] for edge in subgraph.edges])
         fidelity_mean = np.mean(subgraph_fidelity)
         fidelity_var  = np.var(subgraph_fidelity)  
         if fidelity_mean >= self.fidelity_mean_threshold:
@@ -162,7 +160,7 @@ class Layout:
             return nodes_info
         else:
             return None
-    
+     
     def collect_all_subgraph_info_in_parallel(self):
         """Collects information about all subgraphs in parallel.
 
@@ -188,9 +186,8 @@ class Layout:
             tuple[list, list, list, list]: A tuple containing four lists, each corresponding 
             to one of the four categories of subgraphs.
         """
-        cycle_subgraph_list  = []
-        linear1_subgraph_list  = []
-        linear2_subgraph_list = []
+
+        linear_subgraph_list  = []
         nonlinear_subgraph_list = []
         all_subgraph_info = self.collect_all_subgraph_info_in_parallel()
 
@@ -198,22 +195,10 @@ class Layout:
             nodes,subgraph_degree,fidelity_mean,fidelity_var = subgraph_info
             nodes_info = (nodes, fidelity_mean, fidelity_var)
             if max(subgraph_degree.values()) <= 2:
-                if min(subgraph_degree.values()) == 2:
-                    cycle_subgraph_list.append(nodes_info)
-                else:
-                    in_a_line = []
-                    for node1, node2 in combinations(nodes,2):
-                        if abs(node1-node2) <= (self.size[1]-1):
-                            in_a_line.append(True)
-                        else:
-                            in_a_line.append(False)
-                    if len(set(in_a_line)) == 1:
-                        linear1_subgraph_list.append(nodes_info)
-                    else:
-                        linear2_subgraph_list.append(nodes_info)
+                linear_subgraph_list.append(nodes_info)
             else:
                 nonlinear_subgraph_list.append(nodes_info)
-        return linear1_subgraph_list,linear2_subgraph_list,cycle_subgraph_list,nonlinear_subgraph_list
+        return linear_subgraph_list,nonlinear_subgraph_list
     
     def sort_subgraph_according_mean_fidelity(self, num:int=1,  printdetails: bool = True):
         """Sort each of the four subgraph categories based on the main of fidelity on the edges (couplers), 
@@ -226,40 +211,29 @@ class Layout:
             tuple[list, list, list, list]: Four sorted lists, each corresponding to one of the four 
             subgraph categories, with subgraphs sorted by edge fidelity variance.
         """
-        linear1_subgraph_list, linear2_subgraph_list, cycle_subgraph_list, nonlinear_subgraph_list = self.classify_all_subgraph_according_topology()
-        linear1_subgraph_list_sort = sorted(linear1_subgraph_list,key=lambda x: x[1],reverse=True)
-        linear2_subgraph_list_sort = sorted(linear2_subgraph_list,key=lambda x: x[1],reverse=True)
-        cycle_subgraph_list_sort = sorted(cycle_subgraph_list,key=lambda x: x[1],reverse=True)
+        linear_subgraph_list, nonlinear_subgraph_list = self.classify_all_subgraph_according_topology()
+        linear_subgraph_list_sort = sorted(linear_subgraph_list,key=lambda x: x[1],reverse=True)
         nonlinear_subgraph_list_sort = sorted(nonlinear_subgraph_list,key=lambda x: x[1],reverse=True)
         if printdetails:
-            print(len(linear1_subgraph_list_sort),len(linear2_subgraph_list_sort),len(cycle_subgraph_list_sort),len(nonlinear_subgraph_list_sort))
+            print(len(linear_subgraph_list_sort),len(nonlinear_subgraph_list_sort))
             print('The average fidelity is arranged in descending order,only print the first ten.')
             length = self.nqubits*5+22
 
-            print('{:<3} | {:^{}} | {:^{}} | {:^{}} | {:^{}} |'.format(\
-                'idx','subgraph with linear1 topology',length,'subgraph with linear2 topology',length,'subgraph with cycle topology',length,'subgraph with nonlinear topology',length))
-            for i, (linear1,linear2,cycle,nonlinear) in enumerate(zip_longest(linear1_subgraph_list_sort,\
-                                                                              linear2_subgraph_list_sort,\
-                                                                              cycle_subgraph_list_sort,\
-                                                                              nonlinear_subgraph_list_sort, fillvalue=' ')):
-                if i >= len(linear1_subgraph_list_sort):
-                    linear1 = ('(                  )',0.0,0.0)
-                if i >= len(linear2_subgraph_list_sort):
-                    linear2 = ('(                  )',0.0,0.0)
-                if i >= len(cycle_subgraph_list_sort):
-                    cycle = ('(                  )',0.0,0.0)
+            print('{:<3} | {:^{}} | {:^{}} '.format(\
+                'idx','subgraph with linear topology',length,'subgraph with nonlinear topology',length))
+            for i, (linear,nonlinear) in enumerate(zip_longest(linear_subgraph_list_sort,nonlinear_subgraph_list_sort, fillvalue=' ')):
+                if i >= len(linear_subgraph_list_sort):
+                    linear = ('(                  )',0.0,0.0)
                 if i >= len(nonlinear_subgraph_list_sort):
                     nonlinear = ('(                  )',0.0,0.0)
                 if i <= num:
-                    print('{:<3} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f}'\
+                    print('{:<3} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f} '\
                           .format(i, \
-                                  str(linear1[0]),self.nqubits*5,linear1[1],linear1[2],\
-                                  str(linear2[0]),self.nqubits*5,linear2[1],linear2[2],\
-                                  str(cycle[0]),self.nqubits*5,cycle[1],cycle[2],\
+                                  str(linear[0]),self.nqubits*5,linear[1],linear[2],\
                                   str(nonlinear[0]),self.nqubits*5,nonlinear[1],nonlinear[2])\
                                   )
                     
-        return linear1_subgraph_list_sort[:num],linear2_subgraph_list_sort[:num],cycle_subgraph_list_sort[:num],nonlinear_subgraph_list_sort[:num]
+        return linear_subgraph_list_sort[:num],nonlinear_subgraph_list_sort[:num]
     
     def sort_subgraph_according_var_fidelity(self, num:int = 1, printdetails: bool = True):
         """
@@ -276,46 +250,47 @@ class Layout:
             tuple[list, list, list, list]: Four sorted lists, each corresponding to one of the four 
             subgraph categories, with subgraphs sorted by edge fidelity variance.
         """
-        linear1_subgraph_list, linear2_subgraph_list, cycle_subgraph_list, nonlinear_subgraph_list = self.classify_all_subgraph_according_topology()
-        linear1_subgraph_list_sort = sorted(linear1_subgraph_list,key=lambda x: x[2])
-        linear2_subgraph_list_sort = sorted(linear2_subgraph_list,key=lambda x: x[2])
-        cycle_subgraph_list_sort = sorted(cycle_subgraph_list,key=lambda x: x[2])
+        linear_subgraph_list, nonlinear_subgraph_list = self.classify_all_subgraph_according_topology()
+        linear_subgraph_list_sort = sorted(linear_subgraph_list,key=lambda x: x[2])
         nonlinear_subgraph_list_sort = sorted(nonlinear_subgraph_list,key=lambda x: x[2])
         
         if printdetails:
-            print(len(linear1_subgraph_list_sort),len(linear2_subgraph_list_sort),len(cycle_subgraph_list_sort),len(nonlinear_subgraph_list_sort))
+            print(len(linear_subgraph_list_sort),len(nonlinear_subgraph_list_sort))
             print('The average fidelity is arranged in descending order, only print the first ten.')
             length = self.nqubits*5+22
 
-            print('{:<3} | {:^{}} | {:^{}} | {:^{}} | {:^{}} |'.format(\
-                'idx','subgraph with linear1 topology',length,'subgraph with linear2 topology',length,'subgraph with cycle topology',length,'subgraph with nonlinear topology',length))
-            for i, (linear1,linear2,cycle,nonlinear) in enumerate(zip_longest(linear1_subgraph_list_sort,\
-                                                                              linear2_subgraph_list_sort,\
-                                                                              cycle_subgraph_list_sort,\
-                                                                              nonlinear_subgraph_list_sort, fillvalue=' ')):
-                if i >= len(linear1_subgraph_list_sort):
-                    linear1 = ('(                  )',0.0,0.0)
-                if i >= len(linear2_subgraph_list_sort):
-                    linear2 = ('(                  )',0.0,0.0)
-                if i >= len(cycle_subgraph_list_sort):
-                    cycle = ('(                  )',0.0,0.0)
+            print('{:<3} | {:^{}} | {:^{}} '.format(\
+                'idx','subgraph with linear topology',length,'subgraph with nonlinear topology',length))
+            for i, (linear,nonlinear) in enumerate(zip_longest(linear_subgraph_list_sort, nonlinear_subgraph_list_sort, fillvalue=' ')):
+                if i >= len(linear_subgraph_list_sort):
+                    linear = ('(                  )',0.0,0.0)
                 if i >= len(nonlinear_subgraph_list_sort):
                     nonlinear = ('(                  )',0.0,0.0)
                 
                 if i <= num:
-                    print('{:<3} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f}'\
+                    print('{:<3} | {:<{}} {:<10.6f} {:<10.6f} | {:<{}} {:<10.6f} {:<10.6f} '\
                           .format(i, \
-                                  str(linear1[0]),self.nqubits*5,linear1[1],linear1[2],\
-                                  str(linear2[0]),self.nqubits*5,linear2[1],linear2[2],\
-                                  str(cycle[0]),self.nqubits*5,cycle[1],cycle[2],\
+                                  str(linear[0]),self.nqubits*5,linear[1],linear[2],\
                                   str(nonlinear[0]),self.nqubits*5,nonlinear[1],nonlinear[2])\
                                   )
 
-        return linear1_subgraph_list_sort[:num],linear2_subgraph_list_sort[:num],cycle_subgraph_list_sort[:num],nonlinear_subgraph_list_sort[:num]
+        return linear_subgraph_list_sort[:num], nonlinear_subgraph_list_sort[:num]
+    
+    def select_qubit_from_backend(self,):
+        # 当线路中只有一个qubit时，挑选单比特门保真度最大的比特
+
+        for nodes in nx.connected_components(self.graph):
+            if len(nodes) > 1:
+                subgraph = self.graph.subgraph(nodes)
+                break
+        node_fidelity_dic = nx.get_node_attributes(subgraph,'fidelity')
+        sorted_dict = dict(sorted(node_fidelity_dic.items(), key=lambda item: item[1], reverse=True))
+        qubit = list(sorted_dict.keys())[0]
+        return qubit, sorted_dict[qubit]
 
     def select_layout_from_backend(self,
                       key: Literal['fidelity_mean', 'fidelity_var'] = 'fidelity_var',
-                      topology: Literal['cycle', 'linear1', 'linear', 'nonlinear'] = 'linear1',
+                      topology: Literal['linear', 'nonlinear'] = 'linear',
                       printdetails: bool = False):
         """
         Select a qubit layout based on the given performance metric and topology.
@@ -336,28 +311,16 @@ class Layout:
             list: A list of qubits representing the selected layout.
         """
         if key == 'fidelity_mean':
-            linear1_list,linear2_list,cycle_list,nonlinear_list = self.sort_subgraph_according_mean_fidelity(printdetails=printdetails)
+            linear_list,nonlinear_list = self.sort_subgraph_according_mean_fidelity(printdetails=printdetails)
         elif key == 'fidelity_var':
-            linear1_list,linear2_list,cycle_list,nonlinear_list = self.sort_subgraph_according_var_fidelity(printdetails=printdetails)
+            linear_list,nonlinear_list = self.sort_subgraph_according_var_fidelity(printdetails=printdetails)
         
-        if topology == 'linear1':
-            if len(linear1_list) == 0:
+        if topology == 'linear':
+            if len(linear_list) == 0:
                 print(f'There is no {self.nqubits} qubits that meets both key = {key} and topology = {topology}. Please change the conditions.')
                 return [] #exit(1)
             else:
-                return linear1_list[0][0]
-        elif topology == 'linear2':
-            if len(linear2_list) == 0:
-                print(f'There is no {self.nqubits} qubits that meets both key = {key} and topology = {topology}. Please change the conditions.')
-                return []  #exit(1)
-            else:
-                return linear2_list[0][0]
-        elif topology == 'cycle':
-            if len(cycle_list) == 0:
-                print(f'There is no {self.nqubits} qubits that meets both key = {key} and topology = {topology}. Please change the conditions.')
-                return [] #exit(1)
-            else:
-                return cycle_list[0][0]
+                return linear_list[0][0]
         elif topology == 'nonlinear':
             if len(nonlinear_list) == 0:
                 print(f'There is no {self.nqubits} qubits that meets both key = {key} and topology = {topology}. Please change the conditions.')
@@ -368,7 +331,7 @@ class Layout:
     def select_layout(self,
                       target_qubits:list = [], 
                       use_chip_priority: bool = True, 
-                      select_criteria: dict = {'key':'fidelity_var','topology':'linear1'},
+                      select_criteria: dict = {'key':'fidelity_var','topology':'linear'},
                         ):
         
         if target_qubits != []:
@@ -391,47 +354,109 @@ class Layout:
                 if is_connected is False:
                     raise(ValueError(f'The physical qubit layout {target_qubits} constructed from target_qubits is not connected.'))  
             coupling_map = list(subgraph.edges)
-            print(f'Physical qubits layout {target_qubits} are user-defined, with the corresponding coupling being {coupling_map}.')            
-            subgraph_fidelity = np.array([data['fidelity'] for _, _, data in subgraph.edges(data=True)])
-            fidelity_mean = np.mean(subgraph_fidelity)
-            fidelity_var  = np.var(subgraph_fidelity)  
-            print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')
+            print(f'Physical qubits layout {target_qubits} are user-defined, with the corresponding coupling being {coupling_map}.')       
+
+            if len(subgraph.edges())>0:     
+                subgraph_fidelity = np.array([self.edge_fidelitys[(min(edge),max(edge))] for edge in subgraph.edges])
+                fidelity_mean = np.mean(subgraph_fidelity)
+                fidelity_var  = np.var(subgraph_fidelity)  
+                print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')
             return subgraph
-        if use_chip_priority: # 如果列表中没有满足的比特则启动筛选，todos:把筛选机制转成数据库
+        if use_chip_priority: # 如果列表中没有满足的比特则启动筛选，如果是单比特则保留原比特，不再筛选，todos:把筛选机制转成数据库
             priority_qubits_list = self.priority_qubits
             for qubits in priority_qubits_list:
                 if len(qubits) == self.nqubits:
                     subgraph = self.graph.subgraph(qubits)
-                    coupling_map = list(subgraph.edges)
-                    print(f'Physical qubits layout {list(qubits)} are derived from the chip backend priority qubits, with the corresponding coupling being {coupling_map}.')
-                    subgraph_fidelity = np.array([data['fidelity'] for _, _, data in subgraph.edges(data=True)])
-                    fidelity_mean = np.mean(subgraph_fidelity)
-                    fidelity_var  = np.var(subgraph_fidelity)  
-                    print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')
-                    return subgraph
+                    if nx.is_connected(subgraph):
+                        coupling_map = list(subgraph.edges)
+                        print(f'Physical qubits layout {list(qubits)} are derived from the chip backend priority qubits, with the corresponding coupling being {coupling_map}.')
+                        if len(subgraph.edges())>0: 
+                            subgraph_fidelity = np.array([self.edge_fidelitys[(min(edge),max(edge))] for edge in subgraph.edges])
+                            fidelity_mean = np.mean(subgraph_fidelity)
+                            fidelity_var  = np.var(subgraph_fidelity)  
+                            print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')
+                        return subgraph
             print(f'No priority qubits with {self.nqubits} qubits found. it will check the select_criteria for search')
 
-        key_first = select_criteria['key']
-        topology_first = select_criteria['topology']
-        all_keys = ['fidelity_var','fidelity_mean']
-        all_topologys = ['linear1','linear2','cycle','nonlinear']
-        all_keys.remove(key_first)
-        all_topologys.remove(topology_first)
-        sorted_keys = [key_first,] + all_keys
-        sorted_topologys = [topology_first,] + all_topologys
-        physical_qubits_layout = []
-        for key, topology in product(sorted_keys,sorted_topologys):
-            physical_qubits_layout = self.select_layout_from_backend(key=key,topology=topology)
-            if physical_qubits_layout != []:
-                break
-        if physical_qubits_layout == []:
-            raise(ValueError(f'Unable to find a suitable layout. If this message appears, please contact the developer for assistance.'))
-        physical_qubits_layout = list(physical_qubits_layout)
-        subgraph = self.graph.subgraph(physical_qubits_layout)
-        coupling_map = list(subgraph.edges)
-        print(f'Physical qubits layout {physical_qubits_layout} are selected by the Transpile algorithm using key = {key} and topology = {topology}, \nwith the corresponding coupling being {coupling_map}.')
-        subgraph_fidelity = np.array([data['fidelity'] for _, _, data in subgraph.edges(data=True)])
-        fidelity_mean = np.mean(subgraph_fidelity)
-        fidelity_var  = np.var(subgraph_fidelity)  
-        print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')              
-        return subgraph
+        if self.nqubits == 1:
+            qubit, fidelity = self.select_qubit_from_backend()
+            #The selected qubit has the highest single-qubit gate fidelity.
+            print(f'The selected physical qubit {qubit} is 	recommend, with single-qubit gate fidelity {fidelity}')
+            subgraph = self.graph.subgraph([qubit])
+            return subgraph
+        elif 1< self.nqubits <= 10:
+            key_first = select_criteria['key']
+            topology_first = select_criteria['topology']
+            all_keys = ['fidelity_var','fidelity_mean']
+            all_topologys = ['linear','nonlinear']
+            all_keys.remove(key_first)
+            all_topologys.remove(topology_first)
+            sorted_keys = [key_first,] + all_keys
+            sorted_topologys = [topology_first,] + all_topologys
+            physical_qubits_layout = []
+            for key, topology in product(sorted_keys,sorted_topologys):
+                physical_qubits_layout = self.select_layout_from_backend(key=key,topology=topology)
+                if physical_qubits_layout != []:
+                    break
+            if physical_qubits_layout == []:
+                raise(ValueError(f'Unable to find a suitable layout. If this message appears, please contact the developer for assistance.'))
+            physical_qubits_layout = list(physical_qubits_layout)
+            subgraph = self.graph.subgraph(physical_qubits_layout)
+            coupling_map = list(subgraph.edges)
+            print(f'Physical qubits layout {physical_qubits_layout} are selected by the Transpile algorithm using key = {key} and topology = {topology}, \nwith the corresponding coupling being {coupling_map}.')
+            subgraph_fidelity = np.array([self.edge_fidelitys[(min(edge),max(edge))] for edge in subgraph.edges])
+            fidelity_mean = np.mean(subgraph_fidelity)
+            fidelity_var  = np.var(subgraph_fidelity)  
+            print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')              
+            return subgraph
+        elif self.nqubits >10:
+            physical_qubits_layout = self.get_BFS_layout()
+            subgraph = self.graph.subgraph(physical_qubits_layout)
+            coupling_map = list(subgraph.edges)
+            print(f'Physical qubits layout {physical_qubits_layout} are selected by BFS algorithm with the corresponding coupling being {coupling_map}.')
+            subgraph_fidelity = np.array([self.edge_fidelitys[(min(edge),max(edge))] for edge in subgraph.edges])
+            fidelity_mean = np.mean(subgraph_fidelity)
+            fidelity_var  = np.var(subgraph_fidelity)  
+            print(f'The average fidelity of the coupler(s) between the selected qubits is {fidelity_mean}, and the variance of the fidelity is {fidelity_var}.')  
+            return subgraph
+        else:
+            raise(ValueError('Wrong qubits error!'))
+
+    # large qubit layour    
+    def get_one_component(self):
+        components = list(nx.connected_components(self.graph))
+        for i, comp in enumerate(components):
+            if len(comp)>=self.nqubits:
+                return comp
+        raise(ValueError(f'The user circuit requires {self.nqubits} more qubits than are available in the largest connected subgraph.'))
+    
+    def get_BFS_layout(self):
+        """ Perform a breadth-first search (BFS) on the graph starting from the start node,
+        collecting up to `nqubits` unique nodes including the start node.
+
+        Returns:
+            list: A list of up to `nqubits` unique nodes, discovered in BFS order.
+        """
+        comp = self.get_one_component()
+        one_subgraph = self.graph.subgraph(comp)
+
+        if self.priority_qubits is None:
+            start_node = np.random.choice(comp)
+        else:
+            priority_qubits_list = list(set(i for sublist in self.priority_qubits for i in sublist))
+            start_node = np.random.choice(priority_qubits_list)
+
+        visited = set([start_node])
+        queue = [(start_node, 0)]  
+    
+        while queue and len(visited) < self.nqubits:
+            current_node, depth = queue.pop(0)  
+            if depth >= self.nqubits - 1:
+                continue
+            for neighbor in one_subgraph.neighbors(current_node):
+                if neighbor not in visited:
+                    visited.add(neighbor)
+                    queue.append((neighbor, depth + 1))
+                    if len(visited) == self.nqubits:
+                        break
+        return list(visited)

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.2}/quark/circuit/matrix.py

@@ -316,6 +316,16 @@ def rzz_mat(theta: float) -> np.ndarray:
         ], dtype=complex
     )
 
+def cp_mat(theta: float) -> np.ndarray:
+    return np.array(
+        [
+            [1, 0, 0, 0],
+            [0, 1, 0, 0],
+            [0, 0, 1, 0],
+            [0, 0, 0, np.exp(1j*theta)]
+        ], dtype=complex
+    )
+
 gate_matrix_dict = {
     'id':id_mat, 'x':x_mat, 'y':y_mat, 'z':z_mat, 'h':h_mat,
     's':s_mat, 'sdg':sdg_mat, 't':t_mat, 'tdg':tdg_mat, 'sx':sx_mat, 'sxdg':sxdg_mat,
@@ -323,5 +333,6 @@ gate_matrix_dict = {
     'cx':cx_mat, 'cnot':cx_mat, 'cy':cy_mat, 'cz':cz_mat,
     'rx':rx_mat, 'ry':ry_mat, 'rz':rz_mat,
     'p':p_mat, 'u':u_mat,'r':r_mat,
-    'rxx':rxx_mat,'ryy':ryy_mat,'rzz':rzz_mat,'ccz':ccz_mat,'ccx':ccx_mat,'cswap':cswap_mat,
+    'rxx':rxx_mat,'ryy':ryy_mat,'rzz':rzz_mat, 'cp':cp_mat,
+    'ccz':ccz_mat,'ccx':ccx_mat,'cswap':cswap_mat,
     }