quarkcircuit 0.3.6.dev0__tar.gz → 0.3.7__tar.gz

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/PKG-INFO

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

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/pyproject.toml

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

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quark/circuit/__init__.py

@@ -48,5 +48,4 @@ from .decompose import ThreeQubitGateDecompose
 from .layout import Layout
 from .routing import SabreRouting
 from .translate import TranslateToBasisGates
-from .optimize import GateCompressor
-from .test_transpiler import call_quark_transpiler
+from .optimize import GateCompressor

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quark/circuit/backend.py

@@ -24,15 +24,14 @@ This module contains the Backend class, which processes superconducting chip inf
 import networkx as nx
 import numpy as np
 from typing import Literal
+import requests
+import json
 
 def load_chip_basic_info(chip_name):
-    import requests
-    import json
     session = requests.Session()
     URL = 'https://quafu-sqc.baqis.ac.cn'
     info0 = session.get(f'{URL}/task/backendtest/{chip_name}1') 
     chip_info = json.loads(info0.content.decode())
-
     if chip_info:
         print(f'{chip_name} configuration loading done!')
         return chip_info
@@ -56,6 +55,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()
+            self.two_qubit_gate_basis = self.chip_info['global_info']['two_qubit_gate_basis'].lower()
         elif chip in ['Baihua','Dongling','Haituo','Yunmeng','Miaofeng','Yudu','Hongluo']:
             self.chip_name = chip
             try:
@@ -67,6 +67,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()
+            self.two_qubit_gate_basis = self.chip_info['global_info']['two_qubit_gate_basis'].lower()
             
         elif chip == 'Custom':
             self.chip_name = chip
@@ -75,6 +76,7 @@ class Backend:
             self.qubits_with_attributes = list()
             self.couplers_with_attributes = list()
             self.priority_qubits = []
+            self.two_qubit_gate_basis = 'cz'
         else:
             raise(ValueError(f'Wrong chip name! {chip}'))
     

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quark/circuit/layout.py

@@ -339,7 +339,8 @@ class Layout:
             if len(target_qubits) != self.nqubits:
                 raise(ValueError(f'The number of qubits {len(target_qubits)} in target_qubits does not match the number of qubits {self.nqubits} in the circuit.'))
             # check qubits existance and fidelity 
-            subgraph = self.graph.subgraph(target_qubits)
+            subgraph = self.graph.subgraph(target_qubits).copy()
+            subgraph.graph["normal_order"] = target_qubits
             for node in target_qubits:
                 if subgraph.has_node(node):
                     fidelity = nx.get_node_attributes(subgraph,'fidelity')[node]
@@ -369,7 +370,8 @@ class Layout:
             priority_qubits_list = self.priority_qubits
             for qubits in priority_qubits_list:
                 if len(qubits) == self.nqubits:
-                    subgraph = self.graph.subgraph(qubits)
+                    subgraph = self.graph.subgraph(qubits).copy()
+                    subgraph.graph["normal_order"] = qubits
                     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}.')
@@ -385,9 +387,10 @@ class Layout:
             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])
+            subgraph = self.graph.subgraph([qubit]).copy()
+            subgraph.graph["normal_order"] = [qubit]
             return subgraph
-        elif 1< self.nqubits <= self.algorithm_switch_threshold:
+        elif 1 < self.nqubits <= self.algorithm_switch_threshold:
             key_first = select_criteria['key']
             topology_first = select_criteria['topology']
             all_keys = ['fidelity_var','fidelity_mean']
@@ -404,7 +407,8 @@ class Layout:
             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)
+            subgraph = self.graph.subgraph(physical_qubits_layout).copy()
+            subgraph.graph["normal_order"] = 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])
@@ -414,7 +418,8 @@ class Layout:
             return subgraph
         elif self.nqubits > self.algorithm_switch_threshold:
             physical_qubits_layout = self.get_BFS_layout()
-            subgraph = self.graph.subgraph(physical_qubits_layout)
+            subgraph = self.graph.subgraph(physical_qubits_layout).copy()
+            subgraph.graph["normal_order"] = 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])

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quark/circuit/routing.py

@@ -117,8 +117,8 @@ class SabreRouting(TranspilerPass):
         super().__init__()
         self.coupling_graph = subgraph
         self.distance_matrix = floyd_warshall_numpy(subgraph)
-        self.physical_qubits = list(subgraph.nodes) # list(sorted(subgraph.nodes()))
-        self.physical_qubits_index = dict(zip(self.physical_qubits,range(len(self.physical_qubits))))
+        self.physical_qubits = subgraph.graph['normal_order'] # list(sorted(subgraph.nodes()))
+        self.physical_qubits_index = dict(zip(list(subgraph.nodes),range(len(subgraph.nodes))))
         self.initial_mapping = initial_mapping
         self.do_random_choice = do_random_choice
         self.iterations = iterations
@@ -209,7 +209,7 @@ class SabreRouting(TranspilerPass):
             if len(set(virtual_qubits)) != len(set(self.physical_qubits)):
                 raise(ValueError(f'The number of virtual qubits does not match the number of physical qubits.{virtual_qubits} {self.physical_qubits}'))
             if self.initial_mapping == 'trivial':
-                v2p = dict(zip(virtual_qubits,sorted(self.physical_qubits)))
+                v2p = dict(zip(virtual_qubits,self.physical_qubits))
             elif self.initial_mapping == 'random':
                 shuffle_physical_qubits = random.sample(self.physical_qubits,len(self.physical_qubits))
                 v2p = dict(zip(virtual_qubits,shuffle_physical_qubits))

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quark/circuit/translate.py

@@ -127,5 +127,5 @@ class TranslateToBasisGates(TranspilerPass):
                 raise(TypeError(f'Input {gate} gate is not support to basic gates now.'))
             
         new_qc.gates = new
-        print('Mapping to basic gates done !')
+        print(f'Mapping to basic gates done ! {self.two_qubit_gate_basis}')
         return new_qc

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quark/circuit/transpiler.py

@@ -75,17 +75,17 @@ class Transpiler:
         if optimize_level == 0:
             passes = [ThreeQubitGateDecompose(),
                       SabreRouting(subgraph,initial_mapping='trivial',do_random_choice=False,iterations=1),
-                      TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis='cz'),
+                      TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis=self.chip_backend.two_qubit_gate_basis),
                       ]
         elif optimize_level == 1:
             passes = [ThreeQubitGateDecompose(),
                       SabreRouting(subgraph,initial_mapping='trivial',do_random_choice=False,iterations=5),
-                      TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis='cz'),
+                      TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis=self.chip_backend.two_qubit_gate_basis),
                       GateCompressor()]
         elif optimize_level == 2:
             passes = [ThreeQubitGateDecompose(),
                       SabreRouting(subgraph,initial_mapping='random',do_random_choice=True,iterations=5),
-                      TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis='cz'),
+                      TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis=self.chip_backend.two_qubit_gate_basis),
                       GateCompressor()]
         else:
             raise(ValueError(f'Currently, only optimize_level values of 0 or 1 are supported.'))

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quarkcircuit.egg-info/PKG-INFO

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

{quarkcircuit-0.3.6.dev0 → quarkcircuit-0.3.7}/quarkcircuit.egg-info/SOURCES.txt

@@ -11,7 +11,6 @@ quark/circuit/optimize.py
 quark/circuit/quantumcircuit.py
 quark/circuit/quantumcircuit_helpers.py
 quark/circuit/routing.py
-quark/circuit/test_transpiler.py
 quark/circuit/translate.py
 quark/circuit/transpiler.py
 quark/circuit/utils.py

quarkcircuit-0.3.6.dev0/quark/circuit/test_transpiler.py

@@ -1,176 +0,0 @@
-import networkx as nx
-import json,copy
-from .quantumcircuit import QuantumCircuit
-from .quantumcircuit_helpers import one_qubit_gates_available,one_qubit_parameter_gates_available
-from .backend import Backend
-from .layout import Layout
-from .decompose import ThreeQubitGateDecompose
-from .routing import SabreRouting
-from .translate import TranslateToBasisGates
-from .optimize import GateCompressor
-
-from .dag import qc2dag
-from pathlib import Path
-
-def call_quark_transpiler(qc:QuantumCircuit|list|str,chip_name:str,compile:bool, options:dict,dev=False,return_qlisp=True):
-    """ Transpiler for quantum cloud.
-
-    Args:
-        qc (QuantumCircuit | list | str): _description_
-        chip_name (str): _description_
-        compile (bool): _description_
-        options (dict): _description_
-        dev (bool, optional): _description_. Defaults to False.
-        return_qlisp (bool, optional): _description_. Defaults to True.
-
-    Returns:
-        _type_: _description_
-    """
-    if dev:
-        with open(Path.home()/f'Desktop/home/test/{chip_name}1.json') as f:
-            chip_info =  json.loads(f.read())
-        chip_backend = Backend(chip_info)
-        chip_backend.chip_name = chip_name
-    else:
-        chip_backend = Backend(chip_name)
-
-    two_qubit_gate_basis = chip_backend.chip_info['global_info']['two_qubit_gate_basis'].lower()
-
-    # 初始化线路,检查线路中的门是否都支持。
-    if isinstance(qc, QuantumCircuit):
-        quarkQC = qc
-    elif isinstance(qc, str):
-        quarkQC = QuantumCircuit().from_openqasm2(qc)
-    elif isinstance(qc, list):
-        quarkQC = QuantumCircuit().from_qlisp(qc)
-    else:
-        raise(TypeError(f'The qc format is incorrect, only str, list and QuantumCircuit are supported. The format you provided is {type(qc)}.'))
-    
-    # check measure 是否存在，且位于线路末尾
-    dag = qc2dag(quarkQC)
-    n_measure = 0
-    insert_barrier = False
-    for node in dag.nodes():
-        if 'measure' in node:
-            n_measure += 1
-            if dag.out_degree(node) > 0:
-                gate = node.split('_')[0]
-                raise(ValueError(f'There are gate {gate} after the measurement gate.'))
-            for predecessor in dag.predecessors(node):
-                if 'barrier' not in predecessor:
-                    insert_barrier = True
-    # 如果 measure 不存在，add barrier, add measure
-    if n_measure == 0:
-        print('There is no measurement gate in the circuit, quarkcircuit will add measure for all qubits.')
-        quarkQC.barrier()
-        quarkQC.ncbits = len(quarkQC.qubits)
-        quarkQC.measure(quarkQC.qubits,[i for i in range(quarkQC.ncbits)])
-    # 如果 measure存在 但没有隔离则添加隔离
-    if n_measure > 0 and insert_barrier:
-        new = []
-        measure_gates = []
-        barrier_gates = [('barrier',tuple(quarkQC.qubits))]
-        for gate_info in quarkQC.gates:
-            gate = gate_info[0]
-            if gate == 'measure':
-                measure_gates.append(gate_info)
-            else:
-                new.append(gate_info)
-        quarkQC.gates = new + barrier_gates + measure_gates
-
-    # delay duration
-    for gate_info in quarkQC.gates:
-        if gate_info[0] == 'delay':
-            duration = gate_info[1] #quarkcircuit unit is ns
-            if duration*1e-9 > 100e-6:
-                raise(ValueError(f'The maximum delay is 100us, you provided is {duration} ns.'))
-            
-    # compile
-    if compile:
-        # 'options':{"target_qubits":[],"optimze_level":1}
-        set_target_qubits = options.get('target_qubits',[])
-        set_optimize_level = options.get('optimize_level',1)
-        subgraph = Layout(len(quarkQC.qubits),chip_backend).select_layout(target_qubits=set_target_qubits,
-                                                                          use_chip_priority=True,
-                                                                          select_criteria={ 'key': 'fidelity_var','topology': 'linear' })
-        quarkQC_compiled = ThreeQubitGateDecompose().run(quarkQC)
-
-        if set_optimize_level == 0:
-            quarkQC_compiled= SabreRouting(subgraph,initial_mapping='trivial',do_random_choice=False,iterations=1).run(quarkQC_compiled) 
-        elif set_optimize_level == 1:
-            quarkQC_compiled = SabreRouting(subgraph,initial_mapping='trivial',do_random_choice=False,iterations=5).run(quarkQC_compiled) 
-        elif set_optimize_level == 2:
-            quarkQC_compiled = SabreRouting(subgraph,initial_mapping='random',do_random_choice=True,iterations=5).run(quarkQC_compiled) 
-        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=two_qubit_gate_basis).run(quarkQC_half_compiled)
-        quarkQC_half_compiled = GateCompressor().run(quarkQC_half_compiled) 
-
-        if two_qubit_gate_basis == 'cx':
-            two_qubit_gate_basis = 'cz'
-        quarkQC_compiled = TranslateToBasisGates(convert_single_qubit_gate_to_u=True,two_qubit_gate_basis=two_qubit_gate_basis).run(quarkQC_compiled)
-        quarkQC_compiled = GateCompressor().run(quarkQC_compiled) 
-    else:
-        gates_availale = list(one_qubit_gates_available.keys()) \
-            + list(one_qubit_parameter_gates_available.keys()) \
-            + ['barrier','measure','delay'] + [two_qubit_gate_basis]#chip 支持的语法
-        if 'cz' in gates_availale:
-            gates_availale.append('cx')
-
-        collect_two_qubit_gates = []
-        for gate_info in quarkQC.gates:
-            gate = gate_info[0]
-            if gate not in gates_availale:
-                raise(ValueError(f'The {gate} gate you provided is not supported by the current chip. Please convert to basis gates.'))
-            if gate in ['cx','cz','iswap']:
-                collect_two_qubit_gates.append(gate_info)
-
-        # check qubits existance and fidelity 
-        subgraph = chip_backend.graph.subgraph(quarkQC.qubits)
-        for node in quarkQC.qubits:
-            if subgraph.has_node(node):
-                fidelity = nx.get_node_attributes(subgraph,'fidelity')[node]
-                if fidelity == 0.:
-                    raise(ValueError(f'The physical qubit {node} selected by the user is died.')) 
-            else:
-                raise(KeyError(f'Physical qubit {node} does not exit.'))
-        # check edge fidelity and connectivity
-        
-        is_connected = nx.is_connected(subgraph)
-        for _, fidelity in nx.get_edge_attributes(subgraph,'fidelity').items():
-            if fidelity == 0.:
-                is_connected = False
-            if is_connected is False:
-                raise(ValueError(f'The physical qubit layout {quarkQC.qubits} selected by the user is not connected.'))  
-            
-        for two_qubit_gates_info in collect_two_qubit_gates:
-            gate,qubit1,qubit2 = two_qubit_gates_info
-            if subgraph.has_edge(qubit1, qubit2):
-                continue
-            else:
-                raise(ValueError(f'The {two_qubit_gates_info} cannot be executed directly by the chip. Please insert SWAP gates or reselect the layout.'))
-        quarkQC_half_compiled = quarkQC
-        quarkQC_compiled = quarkQC
-
-    # check CZ
-    ncz = quarkQC_compiled.ncz
-    if  ncz > 200:
-        raise(ValueError(f'The number of two-qubit gates in the circuit is {ncz} exceeds 100.'))
-    
-    if return_qlisp:
-        return quarkQC_compiled.to_qlisp,quarkQC_half_compiled.to_openqasm2
-    else:
-        return quarkQC_compiled,quarkQC_half_compiled
-
-if __name__ == '__main__':
-    nqubits = 4
-    qc = QuantumCircuit(nqubits)
-    for i in range(1,nqubits):
-        qc.cx(0,i)
-    qc.barrier()
-    qc.measure_all()
-    qct_qlisp,qct_qasm = call_quark_transpiler(qc,'Baihua',True,{},)
-    print(qct_qlisp)
-    print(qct_qasm)