def test_empty_coupling_class(self): coupling = CouplingMap() self.assertEqual(0, coupling.size()) self.assertEqual([], coupling.physical_qubits) self.assertEqual([], coupling.get_edges()) self.assertFalse(coupling.is_connected()) self.assertEqual("", str(coupling))
def setUp(self): coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]] coupling_map = CouplingMap(couplinglist=coupling) qr = QuantumRegister(7, 'q') layout = Layout({qr[i]: i for i in range(coupling_map.size())}) self.config = TranspileConfig(optimization_level=1, basis_gates=['u1', 'u3', 'u2', 'cx'], initial_layout=layout, coupling_map=coupling_map, seed_transpiler=987, backend_properties=None)
def _parse_coupling_map(coupling_map, backend, num_circuits): # try getting coupling_map from user, else backend if coupling_map is None: backend_version = getattr(backend, "version", 0) if not isinstance(backend_version, int): backend_version = 0 if backend_version <= 1: if getattr(backend, "configuration", None): configuration = backend.configuration() if hasattr(configuration, "coupling_map") and configuration.coupling_map: faulty_map = _create_faulty_qubits_map(backend) if faulty_map: faulty_edges = [ gate.qubits for gate in backend.properties().faulty_gates() ] functional_gates = [ edge for edge in configuration.coupling_map if edge not in faulty_edges ] coupling_map = CouplingMap() for qubit1, qubit2 in functional_gates: if faulty_map[qubit1] is not None and faulty_map[ qubit2] is not None: coupling_map.add_edge(faulty_map[qubit1], faulty_map[qubit2]) if configuration.n_qubits != coupling_map.size(): warnings.warn( "The backend has currently some qubits/edges out of service." " This temporarily reduces the backend size from " f"{configuration.n_qubits} to {coupling_map.size()}", UserWarning, ) else: coupling_map = CouplingMap(configuration.coupling_map) else: coupling_map = backend.coupling_map # coupling_map could be None, or a list of lists, e.g. [[0, 1], [2, 1]] if coupling_map is None or isinstance(coupling_map, CouplingMap): coupling_map = [coupling_map] * num_circuits elif isinstance(coupling_map, list) and all( isinstance(i, list) and len(i) == 2 for i in coupling_map): coupling_map = [coupling_map] * num_circuits coupling_map = [ CouplingMap(cm) if isinstance(cm, list) else cm for cm in coupling_map ] return coupling_map
def create_direction_only_pass_manager(device): # type: (BaseBackend) -> PassManager LOG.info("Creating direction-only PassManager for {}".format(device)) cp = CouplingMap(couplinglist=device.configuration().coupling_map) basis = device.configuration().basis_gates pm = PassManager() pm.append(Unroller(basis=basis)) # noinspection PyTypeChecker if cp.size() > 0: pm.append(CXDirection(coupling_map=cp)) pm.append(Optimize1qGates()) return pm
def setUp(self): coupling = [[0, 1], [1, 2], [2, 3], [3, 4], [4, 5], [5, 6]] coupling_map = CouplingMap(couplinglist=coupling) basis_gates = ['u1', 'u3', 'u2', 'cx'] qr = QuantumRegister(7, 'q') layout = Layout({qr[i]: i for i in range(coupling_map.size())}) # Create a pass manager with a variety of passes and flow control structures self.pass_manager = PassManager() self.pass_manager.append(SetLayout(layout)) self.pass_manager.append(TrivialLayout(coupling_map), condition=lambda x: True) self.pass_manager.append(FullAncillaAllocation(coupling_map)) self.pass_manager.append(EnlargeWithAncilla()) self.pass_manager.append(Unroller(basis_gates)) self.pass_manager.append(CheckMap(coupling_map)) self.pass_manager.append(BarrierBeforeFinalMeasurements(), do_while=lambda x: False) self.pass_manager.append(CXDirection(coupling_map)) self.pass_manager.append(RemoveResetInZeroState())
def benchmark(depth, trail, parameters): if gdv_name == "TFL": folder = "BNTF" depth_string = "{:02}".format(depth) name_end = "TFL" if nr_qubits == 54: name_end = "QSE" elif gdv_name == "QSE": folder = "BSS" depth_string = "{:03}".format(depth) name_end = "QSE" # if nr_qubits==54: # gdv_name = "QSE" qasm_file_name = "_private_benchmark/{}/{}QBT_{}CYC_{}_{}.qasm".format( folder, nr_qubits, depth_string, name_end, trail) solution_file_name = "_private_benchmark/meta/{}QBT_{}CYC_{}_{}_solution.csv".format( nr_qubits, depth_string, name_end, trail) # print("qiskit", depth) # input qasm file as circuit test_circuit = qiskit.QuantumCircuit.from_qasm_file(qasm_file_name) """ Construct the optimal initial mapping """ qiskit_layout_dict = dict() original_nodes = list() with open(solution_file_name, 'r') as csvfile: for original_node in csv.reader(csvfile, delimiter=','): original_nodes.append(literal_eval(original_node[0])) csvfile.close() # print(original_nodes) for i in range(len(original_nodes)): qiskit_layout_dict[test_circuit.qregs[0][i]] = original_nodes[i] # construct passes that use the optimal initial mapping and BasicSwap # however, no swapping gates should be ever necessary original_pm = PassManager() # print(original_nodes) qiskit_coupling_map = CouplingMap( couplinglist=connection_list[qubits[nr_qubits]]) optimal_layout = Layout() optimal_layout.from_dict(qiskit_layout_dict) original_pm.append([ SetLayout(optimal_layout), ApplyLayout(), BasicSwap(qiskit_coupling_map) ]) map_original_circuit = original_pm.run(test_circuit) optimal_depth = map_original_circuit.depth() # print("optimal mapping: the circuit has", optimal_depth, "cycles") # print(map_original_circuit.draw(style="text")) # construct passes that use the DenseLayout+StochasticSwap without initial mapping """ K7M """ gate_costs = { 'id': 0, 'u1': 0, 'measure': 0, 'reset': 0, 'barrier': 0, 'u2': 1, 'u3': 1, 'U': 1, "ok": 0, # update the costs "rev_cnot": 4 * 1 + 10, # 4 u2/hadamard + 1 cnot "swap": 3 * 10 + 4, # 4 u2/hadamard + 3 cnot 'seed': 19 } # pass the seed through gate costs # parameters_string = str(parameters) # the number of qubits in the device parameters["nisq_qubits"] = qiskit_coupling_map.size() # Add the gate costs parameters["gate_costs"] = gate_costs # Should the initial mapping be chosen random? parameters["initial_map"] = K7MInitialMapping.HEURISTIC parameters["unidirectional_coupling"] = False parameters["dry_run"] = False k7mcomp = K7MCompiler(connection_list[qubits[nr_qubits]], parameters) execution_time = time.time() map_test_circuit, init_time, init_map = k7mcomp.run(test_circuit) execution_time = time.time() - execution_time if (map_test_circuit is None) and (init_map is None): # this happens when the execution was interrupted return optimal_depth, -1, execution_time, init_time, -1, -1 # print(map_test_circuit.draw(output="text", fold=-1)) # tmp_circuit = map_test_circuit.decompose() tmp_circuit = map_test_circuit # print(tmp_circuit.draw(output="text", fold=-1)) # tmp_circuit = qiskit_to_tk(map_test_circuit) # Transform.RebaseToQiskit().DecomposeSWAPtoCX().apply(tmp_circuit) depth_result = tmp_circuit.depth() # print("k7m mapping: the circuit has", depth_result, "cycles") # print(map_test_circuit.draw(style="text")) # accumulate result # print("----") nr_t1 = noOfTranspositions(list(range(nr_qubits)), original_nodes, nr_qubits) nr_t2 = noOfTranspositions(original_nodes, init_map, nr_qubits) return optimal_depth, depth_result, execution_time, init_time, nr_t1, nr_t2
def benchmark(depth, trail, varying_param): # qasm_file_name = "_private_benchmark/BNTF/16QBT_{:02}CYC_{}_{}.qasm".format( # depth, gdv_name, trail) # # solution_file_name = "_private_benchmark/meta/16QBT_{:02}CYC_{}_{}_solution.csv".format( # depth, gdv_name, trail) if gdv_name == "TFL": folder = "BNTF" depth_string = "{:02}".format(depth) name_end = "TFL" if nr_qubits == 54: name_end = "QSE" elif gdv_name == "QSE": folder = "BSS" depth_string = "{:03}".format(depth) name_end = "QSE" # if nr_qubits==54: # gdv_name = "QSE" qasm_file_name = "_private_benchmark/{}/{}QBT_{}CYC_{}_{}.qasm".format( folder, nr_qubits, depth_string, name_end, trail) solution_file_name = "_private_benchmark/meta/{}QBT_{}CYC_{}_{}_solution.csv".format( nr_qubits, depth_string, name_end, trail) # print("qiskit", depth) # input qasm file as circuit test_circuit = qiskit.QuantumCircuit.from_qasm_file(qasm_file_name) """ Construct the optimal initial mapping """ qiskit_layout_dict = dict() original_nodes = list() with open(solution_file_name, 'r') as csvfile: for original_node in csv.reader(csvfile, delimiter=','): original_nodes.append(literal_eval(original_node[0])) csvfile.close() print(original_nodes) for i in range(len(original_nodes)): qiskit_layout_dict[test_circuit.qregs[0][i]] = original_nodes[i] # construct passes that use the optimal initial mapping and BasicSwap # however, no swapping gates should be ever necessary original_pm = PassManager() # print(original_nodes) qiskit_coupling_map = CouplingMap(couplinglist=connection_list[qubits[nr_qubits]]) optimal_layout = Layout() optimal_layout.from_dict(qiskit_layout_dict) original_pm.append([SetLayout(optimal_layout), ApplyLayout(), BasicSwap(qiskit_coupling_map)]) map_original_circuit = original_pm.run(test_circuit) optimal_depth = map_original_circuit.depth() print("optimal mapping: the circuit has", optimal_depth, "cycles") # print(map_original_circuit.draw(style="text")) # construct passes that use the DenseLayout+StochasticSwap without initial mapping """ K7M """ gate_costs = {'id': 0, 'u1': 0, 'measure': 0, 'reset': 0, 'barrier': 0, 'u2': 1, 'u3': 1, 'U': 1, "ok": 0, # update the costs "rev_cnot": 4 * 1 + 10, # 4 u2/hadamard + 1 cnot "swap": 3 * 10 + 4, # 4 u2/hadamard + 3 cnot 'seed': 19} # pass the seed through gate costs """ 20 secunde 4.093154 :: attr_b=5.00,attr_c=0.61,edge_cost=0.20,max_breadth=4,max_depth=9,movement_factor=2 5 secunde 4.138454 :: attr_b=17.30,attr_c=0.25,edge_cost=0.20,max_breadth=3,max_depth=9,movement_factor=4 0.5 secunde 4.322774 :: attr_b=8.00,attr_c=0.02,edge_cost=0.20,max_breadth=2,max_depth=9,movement_factor=2 0.05 secunde 4.464655 :: attr_b=3.50,attr_c=0.31,edge_cost=0.90,max_breadth=2,max_depth=6,movement_factor=6 # Lucian 2.424873 for [-w9 -d9 -b1.50 -c0.32 -e0.80 -m10] """ parameters = { "att_b": 15, "att_c": 0, "cx": 0.8, "max_children": 2, "max_depth": 9, "div_dist": 10, # UNUSED "opt_att": True, "opt_max_t_min": False, "qubit_increase_factor": 3, "option_skip_cx": False, "penalty_skip_cx": 20, "opt_div_by_act": False, "TIME_LIMIT": 600 # seconds } parameters_string = str(parameters) # the number of qubits in the device parameters["nisq_qubits"] = qiskit_coupling_map.size() # Add the gate costs parameters["gate_costs"] = gate_costs # Should the initial mapping be chosen random? parameters["initial_map"] = K7MInitialMapping.HEURISTIC parameters["unidirectional_coupling"]=False parameters["dry_run"] = False k7mcomp = K7MCompiler(connection_list[qubits[nr_qubits]], parameters) execution_time = time.time() map_test_circuit, init_time, init_map = k7mcomp.run(test_circuit) execution_time = time.time() - execution_time if (map_test_circuit is None) and (init_map is None): # this happens when the execution was interrupted # Will not write to file of results. So the averages are not affected # by the interrupted experiments return optimal_depth, -1, execution_time, init_time, -1, -1 depth_result = map_test_circuit.depth() print("k7m mapping: the circuit has", depth_result, "cycles") # print(map_test_circuit.draw(style="text")) # accumulate result print("----") file_op_type = "a" global first_run if first_run: file_op_type = "w" first_run = False with open( "_private_data/BNTF/_{}_{}.csv".format(name_end, qubits[nr_qubits], ), file_op_type) as csvFile: writer = csv.writer(csvFile) writer.writerow([trail, "k7m", optimal_depth, depth_result, execution_time]) return optimal_depth, depth_result, execution_time, init_time
class ChainLayout(AnalysisPass): """ Maps the qubits in the coupling map to a nearest-neighbor sequence of qubits, called *chain*, to be used as an initial layout. Sometimes not all qubits in a device can be arranged in a chain. If necessary, such outliers will be inserted in the chain after one of their neighbors. """ def __init__(self, coupling_map, backend_prop=None, readout=False): """ChainLayout initializer. Args: coupling_map (CouplingMap or list): directed graph representing a coupling chain. backend_prop (BackendProperties): backend properties object. Raises: TranspilerError: if invalid options. """ super().__init__() if isinstance(coupling_map, list): self.coupling_map = CouplingMap(coupling_map) elif isinstance(coupling_map, CouplingMap): self.coupling_map = coupling_map else: raise TranspilerError('Coupling map of type %s is not valid' % coupling_map.__class__) self.coupling_graph = self.coupling_map.graph.to_undirected() self.backend_prop = backend_prop # collect cx reliability data if self.backend_prop is not None: if readout: self.readout_reliability = dict() i = 0 for q in backend_prop.qubits: for info in q: if info.name == 'readout_error': self.readout_reliability[i] = 1.0 - info.value i += 1 self.cx_reliab = dict() for ginfo in self.backend_prop.gates: if ginfo.gate == 'cx': for item in ginfo.parameters: if item.name == 'gate_error': g_reliab = max(1.0 - item.value, 10**(-10)) break else: g_reliab = 1.0 self.cx_reliab[(ginfo.qubits[0], ginfo.qubits[1])] = g_reliab self.cx_reliab[(ginfo.qubits[1], ginfo.qubits[0])] = g_reliab if readout: qubits_readout_reliab = self.readout_reliability[ ginfo.qubits[0]] * self.readout_reliability[ ginfo.qubits[1]] self.cx_reliab[( ginfo.qubits[0], ginfo.qubits[1])] *= qubits_readout_reliab self.cx_reliab[( ginfo.qubits[1], ginfo.qubits[0])] *= qubits_readout_reliab def run(self, dag): """Sets the layout property set. Args: dag (DAGCircuit): DAG to find layout for. Raises: TranspilerError: if dag wider than the coupling_map. """ num_dag_qubits = sum([qreg.size for qreg in dag.qregs.values()]) if num_dag_qubits > self.coupling_map.size(): raise TranspilerError('Number of qubits greater than device.') # get the chain of qubits as list of integers chain = self.chain(num_dag_qubits) logger.info('Chain: %s' % str(chain)) layout = Layout() chain_iter = 0 # produce a layout from the chain for qreg in dag.qregs.values(): for i in range(qreg.size): layout[qreg[i]] = chain[chain_iter] chain_iter += 1 self.property_set['layout'] = layout logger.info(self.property_set['layout']) def chain(self, num_qubits=None): """Finds a chain of qubits such that qubit *i* has a connection with qubits *(i-1)* and *(i+1)* in the coupling chain. Relies on best_subset() to select a subset of qubits with high cx reliability. Sometimes not all qubits in a device can be arranged in a chain. If necessary, such outliers will be inserted in the chain after one of their neighbors. Args: num_qubits (int): number of virtual qubits, defaults to the number of qubits of the coupling chain. Raises: TranspilerError: if invalid options """ if num_qubits is None: num_qubits = self.coupling_map.size() if num_qubits > self.coupling_map.size(): raise TranspilerError('Number of qubits greater than device.') current = 0 full_map = [current] isolated = [] isolated_with_data = [] explored = set() explored.add(current) last_back_step = None # loop over the coupling map until all qubits no more qubits # can be connected to the chain while True: neighbors = [] no_neighbors = True for n in self.coupling_graph[current].keys(): if n not in explored: if self.check_isolated_not_last(n, explored): if self.backend_prop is None: isolated_with_data.append((current, n)) else: isolated_with_data.append( (current, n, self.cx_reliab[(current, n)])) isolated.append(n) explored.add(n) no_neighbors = False neighbors.append(n) logger.debug('Neighbors: %s' % str(neighbors)) # try to select next qubit from neighbors of last connected qubit if no_neighbors is False: if current + 1 in neighbors: next = current + 1 else: next = min(neighbors) else: # if no neighbors are found, go back the chain until a new neighbor is found # and restart the loop from there if self.backend_prop is None: isolated_with_data.append((full_map[-2], current)) else: isolated_with_data.append( (full_map[-2], current, self.cx_reliab[(full_map[-2], current)])) isolated.append(current) full_map.remove(current) current = full_map[-1] logger.debug('last back step: %s' % str(last_back_step)) if current != last_back_step: last_back_step = current else: break continue explored.add(next) current = next full_map.append(next) logger.debug('Full chain: %s' % str(full_map)) logger.debug('Explored: %s' % str(explored)) logger.debug('Isolated: %s' % str(isolated_with_data)) # check that there are still qubits to explore if len(explored) < self.coupling_map.size() - 1: neighbors1 = [] for n1 in self.coupling_graph[next].keys(): if n1 not in explored: neighbors1.append(n1) # check that the selected qubit does not lead to a dead end for n1 in neighbors1: to_remove = True for n2 in self.coupling_graph[n1].keys(): if n2 not in explored or n2 == next: to_remove = False if to_remove is True: explored.add(n1) if self.backend_prop is None: isolated_with_data.append((next, n1)) else: isolated_with_data.append( (next, n1, self.cx_reliab[(next, n1)])) isolated.append(n1) # break the loop when all qubits have been explored if len(explored) == self.coupling_map.size(): # if enough qubits have been connected, # return a subset with high cx reliability if len(full_map) >= num_qubits: return self.best_subset(full_map, num_qubits) break # check for isolated qubits for q in range(self.coupling_map.size()): if q not in explored and q not in isolated: for i in isolated: if q in self.coupling_graph[i].keys(): if self.backend_prop is None: isolated_with_data.append((i, q)) else: isolated_with_data.append( (i, q, self.cx_reliab[(i, q)])) isolated.append(q) explored.add(q) break if q not in isolated: for n in self.coupling_graph[q].keys(): if n in full_map: if self.backend_prop is None: isolated_with_data.append((n, q)) else: isolated_with_data.append( (n, q, self.cx_reliab[(n, q)])) isolated.append(q) explored.add(q) break # if the chain is not long enough, add the isolated qubits logger.debug('Searching for isolated') remaining = num_qubits - len(full_map) if remaining > 0: if self.backend_prop is not None: isolated_with_data = sorted(isolated_with_data, key=lambda x: x[2], reverse=True) while remaining > 0: for next in isolated_with_data: if next[0] in full_map: logger.debug(next) full_map.insert(full_map.index(next[0]) + 1, next[1]) isolated_with_data.remove(next) isolated.remove(next[1]) remaining -= 1 break return full_map def check_isolated_not_last(self, q, explored): isolated = True for n in self.coupling_graph[q].keys(): if n not in explored: isolated = False return (len(explored) >= self.coupling_map.size() - 2 and isolated) or not isolated def best_subset(self, chain, num_qubits): """Selects from the chain a subset of qubits with high cx reliability. Args: chain (list): a chain of qubits. num_qubits (int): dimension of the subset. Returns: best_subset (list): subset with high cx reliability. """ if self.backend_prop is None: best_reliab = float('inf') else: best_reliab = 0 best = None if len(chain) - num_qubits == 0: return chain # use a moving window over the chain to select a subset with high cx reliability # if no backend information are provided, use the distance between qubits as a metric for offset in range(len(chain) - num_qubits): sub_set = chain[offset:offset + num_qubits] if self.backend_prop is None: tot_reliab = 0 else: tot_reliab = 1 for q in range(len(sub_set) - 1): if sub_set[q + 1] not in self.coupling_graph[q].keys(): path = shortest_path(self.coupling_graph, source=sub_set[q], target=sub_set[q + 1]) for p in range(len(path) - 1): if self.backend_prop is None: tot_reliab += 1 else: tot_reliab *= self.cx_reliab[(path[p], path[p + 1])]**3 else: if self.backend_prop is None: tot_reliab += 1 else: tot_reliab *= self.cx_reliab[(sub_set[q], sub_set[q + 1])] if self.backend_prop is None: if tot_reliab < best_reliab: best_reliab = tot_reliab best = sub_set else: if tot_reliab > best_reliab: best_reliab = tot_reliab best = sub_set return best
def benchmark(depth, trail, varying_param): # qasm_file_name = "_private_benchmark/BNTF/16QBT_{:02}CYC_{}_{}.qasm".format( # depth, gdv_name, trail) # # solution_file_name = "_private_benchmark/meta/16QBT_{:02}CYC_{}_{}_solution.csv".format( # depth, gdv_name, trail) if gdv_name == "TFL": folder = "BNTF" depth_string = "{:02}".format(depth) name_end = "TFL" if nr_qubits == 54: name_end = "QSE" elif gdv_name == "QSE": folder = "BSS" depth_string = "{:03}".format(depth) name_end = "QSE" # if nr_qubits==54: # gdv_name = "QSE" qasm_file_name = "_private_benchmark/{}/{}QBT_{}CYC_{}_{}.qasm".format( folder, nr_qubits, depth_string, name_end, trail) solution_file_name = "_private_benchmark/meta/{}QBT_{}CYC_{}_{}_solution.csv".format( nr_qubits, depth_string, name_end, trail) # print("qiskit", depth) # input qasm file as circuit test_circuit = qiskit.QuantumCircuit.from_qasm_file(qasm_file_name) """ Construct the optimal initial mapping """ qiskit_layout_dict = dict() original_nodes = list() with open(solution_file_name, 'r') as csvfile: for original_node in csv.reader(csvfile, delimiter=','): original_nodes.append(literal_eval(original_node[0])) csvfile.close() print(original_nodes) for i in range(len(original_nodes)): qiskit_layout_dict[test_circuit.qregs[0][i]] = original_nodes[i] # construct passes that use the optimal initial mapping and BasicSwap # however, no swapping gates should be ever necessary original_pm = PassManager() # print(original_nodes) qiskit_coupling_map = CouplingMap( couplinglist=connection_list[qubits[nr_qubits]]) optimal_layout = Layout() optimal_layout.from_dict(qiskit_layout_dict) original_pm.append([ SetLayout(optimal_layout), ApplyLayout(), BasicSwap(qiskit_coupling_map) ]) map_original_circuit = original_pm.run(test_circuit) optimal_depth = map_original_circuit.depth() print("optimal mapping: the circuit has", optimal_depth, "cycles") # print(map_original_circuit.draw(style="text")) # construct passes that use the DenseLayout+StochasticSwap without initial mapping """ K7M """ gate_costs = { 'id': 0, 'u1': 0, 'measure': 0, 'reset': 0, 'barrier': 0, 'u2': 1, 'u3': 1, 'U': 1, "ok": 0, # update the costs "rev_cnot": 4 * 1 + 10, # 4 u2/hadamard + 1 cnot "swap": 3 * 10 + 4, # 4 u2/hadamard + 3 cnot 'seed': 19 } # pass the seed through gate costs parameters = { # maximum depth of the search tree # after this depth, the leafs are evaluated # and only the path with minimum cost is kept in the tree # thus, the tree is pruned "max_depth": test_circuit.n_qubits // 2, # "max_depth": test_circuit.n_qubits/4, # maximum number of children of a node # "max_children": qiskit_coupling_map.size(), "max_children": 2, # the first number_of_qubits * this factor the search maximises the cost # afterwards it minimises it "opt_max_t_min": False, "qubit_increase_factor": 3, "option_skip_cx": False, "penalty_skip_cx": 20, "opt_div_by_act": False, # later changes in the mapping should not affect # the initial mapping of the circuit "opt_att": True, # b \in [0, 10] "att_b": -10, # c \in [0, 1] "att_c": 1, "div_dist": 2, "cx": 0.01 } parameters_string = str(parameters) # the number of qubits in the device parameters["nisq_qubits"] = qiskit_coupling_map.size() # Add the gate costs parameters["gate_costs"] = gate_costs # Should the initial mapping be chosen random? parameters["initial_map"] = K7MInitialMapping.HEURISTIC parameters["unidirectional_coupling"] = False parameters["dry_run"] = False k7mcomp = K7MCompiler(connection_list[qubits[nr_qubits]], parameters) execution_time = time.time() map_test_circuit, init_time = k7mcomp.run(test_circuit) execution_time = time.time() - execution_time # print(map_test_circuit.draw(output="text", fold=-1)) # tmp_circuit = map_test_circuit.decompose() tmp_circuit = map_test_circuit # print(tmp_circuit.draw(output="text", fold=-1)) # tmp_circuit = qiskit_to_tk(map_test_circuit) # Transform.RebaseToQiskit().DecomposeSWAPtoCX().apply(tmp_circuit) depth_result = tmp_circuit.depth() print("k7m mapping: the circuit has", depth_result, "cycles") # print(map_test_circuit.draw(style="text")) # accumulate result print("----") file_op_type = "a" global first_run if first_run: file_op_type = "w" first_run = False with open( "_private_data/BNTF/_{}_{}_{}.csv".format(name_end, qubits[nr_qubits], parameters_string), file_op_type) as csvFile: writer = csv.writer(csvFile) writer.writerow( [trail, "k7m", optimal_depth, depth_result, execution_time]) return optimal_depth, depth_result, execution_time, init_time