quarkcircuit 0.3.0.dev2__tar.gz → 0.3.1__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: quarkcircuit
-Version: 0.3.0.dev2
+Version: 0.3.1
 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.1}/pyproject.toml

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

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

@@ -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.
+
+    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.1}/quark/circuit/layout.py

@@ -312,6 +312,18 @@ class Layout:
                                   )
 
         return linear1_subgraph_list_sort[:num],linear2_subgraph_list_sort[:num],cycle_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',
@@ -391,47 +403,59 @@ 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([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 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}.')
+                    if len(subgraph.edges())>0: 
+                        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
             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 self.nqubits > 1:
+            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
+        else:
+            raise(ValueError('Wrong qubits error!'))

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.1}/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,
     }

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.1}/quark/circuit/quantumcircuit.py

@@ -802,7 +802,40 @@ class QuantumCircuit:
                 raise ValueError(f"Qubit index conflict: qubit1 and qubit2 are both {qubit1}")
         else:
             raise ValueError("Qubit index out of range")
-        
+
+    def cp(self, theta: float, control_qubit: int, target_qubit:int) -> None:
+        r"""
+        Add a Cphase gate.
+
+        $$
+        Rzz(\theta) = I \otimes |0\rangle\lange 0| + P \otimes |1\rangle\langle 1| = 
+        \begin{bmatrix}
+         1  & 0 & 0 & 0 \\
+         0 & 1 & 0 & 0 \\
+         0 & 0 & 1 & 0 \\
+         0 & 0 & 0 & e^{i\theta}
+        \end{bmatrix}.
+        $$
+
+        Args:
+            theta (float): The rotation angle of the gate.
+            control_qubit (int): The qubit to apply the gate to.
+            target_qubit (int): The qubit to apply the gate to.
+
+        Raises:
+            ValueError: If qubit out of circuit range.
+        """
+        if max(control_qubit, target_qubit) < self.nqubits:
+            if control_qubit != target_qubit:
+                self.gates.append(('cp', theta, control_qubit, target_qubit))
+                self._add_qubits(control_qubit, target_qubit)
+                if isinstance(theta,str):
+                    self.params_value[theta] = theta
+            else:
+                raise ValueError(f"Qubit index conflict: qubit1 and qubit2 are both {control_qubit}")
+        else:
+            raise ValueError("Qubit index out of range")
+               
     def shallow_apply_value(self,params_dic):
         for k,v in self.params_value.items():
             self.params_value[k] = k
@@ -1183,6 +1216,15 @@ class QuantumCircuit:
                 qlisp.append(('iSWAP', tuple('Q'+str(i) for i in gate_info[1:])))
             elif gate in three_qubit_gates_available.keys():
                 qlisp.append((gate.upper(), tuple('Q'+str(i) for i in gate_info[1:])))
+            elif gate in ['cp']:
+                if isinstance(gate_info[1],float):
+                    qlisp.append(((gate.upper(), gate_info[1]),tuple('Q'+str(i) for i in gate_info[1:])))
+                elif isinstance(gate_info[1],str):
+                    param = self.params_value[gate_info[1]]
+                    if isinstance(param,float):
+                        qlisp.append(((gate.upper(), param),tuple('Q'+str(i) for i in gate_info[2:])))
+                    else:
+                        raise(ValueError(f'please apply value for parameter {param}')) 
             elif gate in ['rx', 'ry', 'rz', 'p']:
                 if isinstance(gate_info[1],float):
                     qlisp.append(((gate.capitalize(), gate_info[1]), 'Q'+str(gate_info[2])))
@@ -1328,6 +1370,7 @@ class QuantumCircuit:
             'rxx':qc.rxx, 
             'ryy':qc.ryy, 
             'rzz':qc.rzz, 
+            'cp':qc.cp,
             }
         functional_gates_in_qiskit = {
             'barrier':qc.barrier, 

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.1}/quark/circuit/quantumcircuit_helpers.py

@@ -30,10 +30,10 @@ one_qubit_gates_available = {
     }
 two_qubit_gates_available = {
     'cx':'●X', 'cnot':'●X', 'cy':'●Y', 'cz':'●Z', 'swap':'XX', 'iswap':'✶✶',
-    }
-three_qubit_gates_available = {'ccz':'●●●','ccx':'●●X','cswap':'●XX'}
+    } 
+three_qubit_gates_available = {'ccz':'●●●','ccx':'●●X','cswap':'●XX'} 
 one_qubit_parameter_gates_available = {'rx':'Rx', 'ry':'Ry', 'rz':'Rz', 'p':'P', 'u':'U', 'u3':'U', 'r':'R'}
-two_qubit_parameter_gates_available = {'rxx':'Rxx', 'ryy':'Ryy', 'rzz':'Rzz',}
+two_qubit_parameter_gates_available = {'rxx':'Rxx', 'ryy':'Ryy', 'rzz':'Rzz','cp':'●P'} # CPhase
 functional_gates_available = {'barrier':'░', 'measure':'M', 'reset':'|0>','delay':'Delay'}
 
 def convert_gate_info_to_dag_info(nqubits:int,qubits:list,gates:list,show_qubits:bool=True) -> tuple[list,list]:
@@ -271,6 +271,9 @@ def parse_openqasm2_to_gates(openqasm2_str) -> None:
             continue
         else:
             raise(ValueError(f"Sorry, an unrecognized OpenQASM 2.0 syntax {gate} was detected by quarkcircuit. Please contact the developer for assistance."))
+    
+    if cbit_used == []:
+        cbit_used = [i for i in range(len(set(qubit_used)))]
     return new,set(qubit_used),set(cbit_used)
 
 def parse_qlisp_to_gates(qlisp: list) -> tuple[list, list, list]:
@@ -338,6 +341,12 @@ def parse_qlisp_to_gates(qlisp: list) -> tuple[list, list, list]:
         #elif gate[0] in ['rfUnitary']:
         #    qubit0 = int(gate_info[1].split('Q')[1])
         #    new.append(('r', gate[1], gate[2], qubit0))
+        elif gate[0] in ['CU']:
+            qubit1 = int(gate_info[1][0].split('Q')[1])
+            qubit2 = int(gate_info[1][1].split('Q')[1])
+            new.append((gate[0].lower(),gate[1],qubit1,qubit2))
+            qubit_used.append(qubit1)
+            qubit_used.append(qubit2)
         elif gate in ['Cnot']:
             qubit1 = int(gate_info[1][0].split('Q')[1])
             qubit2 = int(gate_info[1][1].split('Q')[1])
@@ -483,41 +492,71 @@ def generate_gates_layerd(nqubits:int,ncbits:int,gates:list,params_value:dict) -
                         gates_layerd[idx+1][i] = '│'
                     break
         elif gate in two_qubit_parameter_gates_available.keys():
-            #print(gate_info)
-            pos0 = min(gate_info[2],gate_info[3])
-            pos1 = max(gate_info[2],gate_info[3])
-            if isinstance(gate_info[1],float):
-                theta0_str = is_multiple_of_pi(gate_info[1])
-            elif isinstance(gate_info[1],str):
-                param = params_value[gate_info[1]]
-                if isinstance(param,float):
-                    theta0_str = is_multiple_of_pi(param)
-                elif isinstance(param,str):
-                    theta0_str = param
-            gate_express = two_qubit_parameter_gates_available[gate]+f'({theta0_str})'
-            if len(gate_express)%2 == 0:
-                gate_express += ' '
-            for idx in range(len(gates_layerd)-1,-1,-1):
-                if gates_layerd[idx][2*pos0:2*pos1+1] != list('─ ')*(pos1-pos0)+['─']:
-                    dif0 = (len(gate_express) - 1)//2
-                    if pos0 == gate_info[2]: 
-                        gates_layerd[idx+1][2*pos0] = '┌' + '─'*dif0 +'0'+'─'*dif0 + '┐'
-                        gates_layerd[idx+1][2*pos1] = '└' + '─'*dif0 +'1'+'─'*dif0 + '┘'
-                        lines_use.append(2*pos0)
-                        lines_use.append(2*pos0 + 1)
-                        lines_use.append(2*pos1)
-                        lines_use.append(2*pos1 + 1)
-                    elif pos0 == gate_info[3]:
-                        gates_layerd[idx+1][2*pos0] = '┌' + '─'*dif0 +'1'+'─'*dif0 + '┐'
-                        gates_layerd[idx+1][2*pos1] = '└' + '─'*dif0 +'0'+'─'*dif0 + '┘'
+            if gate in ['cp']:
+                pos0 = min(gate_info[2],gate_info[3])
+                pos1 = max(gate_info[2],gate_info[3])
+                if isinstance(gate_info[1],float):
+                    theta0_str = is_multiple_of_pi(gate_info[1])
+                elif isinstance(gate_info[1],str):
+                    param = params_value[gate_info[1]]
+                    if isinstance(param,float):
+                        theta0_str = is_multiple_of_pi(param)
+                    elif isinstance(param,str):
+                        theta0_str = param
+                gate_express = two_qubit_parameter_gates_available[gate][1]+f'({theta0_str})'
+                if len(gate_express) % 2 == 0:
+                    gate_express = two_qubit_parameter_gates_available[gate][1]+f'({theta0_str})─'
+                for idx in range(len(gates_layerd)-1,-1,-1):
+                    if gates_layerd[idx][2*pos0:2*pos1+1] != list('─ ')*(pos1-pos0)+['─']:
+                        gates_layerd[idx+1][2*gate_info[2]] = (len(gate_express)//2)*'─' + two_qubit_parameter_gates_available[gate][0] + (len(gate_express)//2)*'─'
+                        gates_layerd[idx+1][2*gate_info[3]] = gate_express
                         lines_use.append(2*pos0)
-                        lines_use.append(2*pos0 + 1)
+                        lines_use.append(2*pos0+1)
                         lines_use.append(2*pos1)
-                        lines_use.append(2*pos1 + 1)
-                    for i in range(2*pos0+1,2*pos1):
-                        gates_layerd[idx+1][i] = '│' + ' '*len(gate_express) + '│'
-                    gates_layerd[idx+1][2*pos0 + (pos1-pos0)] = '│' + gate_express + '│'
-                    break
+                        lines_use.append(2*pos1+1)
+                        for i in range(2*pos0+1,2*pos1):
+                            if i % 2 == 0:
+                                gates_layerd[idx+1][i] = (len(gate_express)//2)*'─' + '│' + (len(gate_express)//2)*'─'
+                            else:
+                                gates_layerd[idx+1][i] = (len(gate_express)//2)*' ' + '│' + (len(gate_express)//2)*' '
+
+                        break
+
+            else:
+                pos0 = min(gate_info[2],gate_info[3])
+                pos1 = max(gate_info[2],gate_info[3])
+                if isinstance(gate_info[1],float):
+                    theta0_str = is_multiple_of_pi(gate_info[1])
+                elif isinstance(gate_info[1],str):
+                    param = params_value[gate_info[1]]
+                    if isinstance(param,float):
+                        theta0_str = is_multiple_of_pi(param)
+                    elif isinstance(param,str):
+                        theta0_str = param
+                gate_express = two_qubit_parameter_gates_available[gate]+f'({theta0_str})'
+                if len(gate_express)%2 == 0:
+                    gate_express += ' '
+                for idx in range(len(gates_layerd)-1,-1,-1):
+                    if gates_layerd[idx][2*pos0:2*pos1+1] != list('─ ')*(pos1-pos0)+['─']:
+                        dif0 = (len(gate_express) - 1)//2
+                        if pos0 == gate_info[2]: 
+                            gates_layerd[idx+1][2*pos0] = '┌' + '─'*dif0 +'0'+'─'*dif0 + '┐'
+                            gates_layerd[idx+1][2*pos1] = '└' + '─'*dif0 +'1'+'─'*dif0 + '┘'
+                            lines_use.append(2*pos0)
+                            lines_use.append(2*pos0 + 1)
+                            lines_use.append(2*pos1)
+                            lines_use.append(2*pos1 + 1)
+                        elif pos0 == gate_info[3]:
+                            gates_layerd[idx+1][2*pos0] = '┌' + '─'*dif0 +'1'+'─'*dif0 + '┐'
+                            gates_layerd[idx+1][2*pos1] = '└' + '─'*dif0 +'0'+'─'*dif0 + '┘'
+                            lines_use.append(2*pos0)
+                            lines_use.append(2*pos0 + 1)
+                            lines_use.append(2*pos1)
+                            lines_use.append(2*pos1 + 1)
+                        for i in range(2*pos0+1,2*pos1):
+                            gates_layerd[idx+1][i] = '│' + ' '*len(gate_express) + '│'
+                        gates_layerd[idx+1][2*pos0 + (pos1-pos0)] = '│' + gate_express + '│'
+                        break
         elif gate in one_qubit_parameter_gates_available.keys():
             if gate == 'u':
                 if isinstance(gate_info[1],float):

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.1}/quark/circuit/test_transpiler.py

@@ -96,7 +96,7 @@ def call_quark_transpiler(qc:QuantumCircuit|list|str,chip_name:str,compile:bool,
             quarkQC_compiled = SabreRouting(subgraph,initial_mapping='trivial',do_random_choice=False,iterations=5).run(quarkQC) 
         else:
             raise(ValueError('More optimize_level is not support now!'))
-        
+
         quarkQC_half_compiled = copy.deepcopy(quarkQC_compiled)
         quarkQC_half_compiled = TranslateToBasisGates(convert_single_qubit_gate_to_u=False,two_qubit_gate_basis='cx').run(quarkQC_half_compiled)
         quarkQC_half_compiled = GateCompressor().run(quarkQC_half_compiled) 
@@ -144,7 +144,7 @@ def call_quark_transpiler(qc:QuantumCircuit|list|str,chip_name:str,compile:bool,
 
     # check CZ
     ncz = quarkQC_compiled.ncz
-    if  ncz > 100:
+    if  ncz > 200:
         raise(ValueError(f'The number of two-qubit gates in the circuit is {ncz} exceeds 100.'))
     
     if return_qlisp:

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.1}/quark/circuit/translate.py

@@ -34,6 +34,7 @@ from .decompose import (cx_decompose,
                                 rxx_decompose,
                                 ryy_decompose,
                                 rzz_decompose,
+                                cp_decompose,
                                 u3_decompose,
                                 )
 from .basepasses import TranspilerPass
@@ -114,6 +115,8 @@ class TranslateToBasisGates(TranspilerPass):
                     new += ryy_decompose(*gate_info[1:],self.convert_single_qubit_gate_to_u,self.two_qubit_gate_basis)
                 elif gate == 'rzz':
                     new += rzz_decompose(*gate_info[1:],self.convert_single_qubit_gate_to_u,self.two_qubit_gate_basis)
+                elif gate == 'cp':
+                    new += cp_decompose(*gate_info[1:],self.convert_single_qubit_gate_to_u)
             elif gate in functional_gates_available.keys():
                 new.append(gate_info)
             else:

{quarkcircuit-0.3.0.dev2 → quarkcircuit-0.3.1}/quarkcircuit.egg-info/PKG-INFO

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