def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the Decompose pass on `dag`. Args: dag: input dag. Returns: output dag where ``gate`` was expanded. """ # Walk through the DAG and expand each non-basis node for node in dag.op_nodes(self.gate): # opaque or built-in gates are not decomposable if not node.op.definition: continue if node.op.definition.global_phase: dag.global_phase += node.op.definition.global_phase # TODO: allow choosing among multiple decomposition rules rule = node.op.definition.data if len(rule) == 1 and len(node.qargs) == len(rule[0][1]) == 1: dag.substitute_node(node, rule[0][0], inplace=True) else: decomposition = circuit_to_dag(node.op.definition) dag.substitute_node_with_dag(node, decomposition) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the Decompose pass on `dag`. Args: dag: input dag. Returns: output dag where ``gate`` was expanded. """ # Walk through the DAG and expand each non-basis node for node in dag.op_nodes(): if self._should_decompose(node): if getattr(node.op, "definition", None) is None: continue # TODO: allow choosing among multiple decomposition rules rule = node.op.definition.data if len(rule) == 1 and len(node.qargs) == len( rule[0].qubits) == 1: if node.op.definition.global_phase: dag.global_phase += node.op.definition.global_phase dag.substitute_node(node, rule[0].operation, inplace=True) else: decomposition = circuit_to_dag(node.op.definition) dag.substitute_node_with_dag(node, decomposition) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the UnitarySynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with UnitaryGates synthesized to target basis. """ for node in dag.nodes(): if node.type != 'op': continue # skip all nodes that do not represent operations if not node.op.num_qubits == 1: continue # ignore all non-single qubit gates, possible raise error here? matrix = node.op.to_matrix() # call solovay kitaev approximation = self._sk.run(matrix, self._recursion_degree) # convert to a dag and replace the gate by the approximation substitute = circuit_to_dag(approximation) dag.substitute_node_with_dag(node, substitute) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the Decompose pass on `dag`. Args: dag: input dag. Returns: output dag where ``gate`` was expanded. """ # Walk through the DAG and expand each non-basis node for node in dag.op_nodes(self.gate): # opaque or built-in gates are not decomposable if not node.op.definition: continue # TODO: allow choosing among multiple decomposition rules rule = node.op.definition if len(rule) == 1 and len(node.qargs) == len(rule[0][1]): dag.substitute_node(node, rule[0][0], inplace=True) else: # hacky way to build a dag on the same register as the rule is defined # TODO: need anonymous rules to address wires by index decomposition = DAGCircuit() qregs = {qb.register for inst in rule for qb in inst[1]} cregs = {cb.register for inst in rule for cb in inst[2]} for qreg in qregs: decomposition.add_qreg(qreg) for creg in cregs: decomposition.add_creg(creg) for inst in rule: decomposition.apply_operation_back(*inst) dag.substitute_node_with_dag(node, decomposition) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the UnitarySynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with UnitaryGates synthesized to target basis. Raises: TranspilerError: 1. pulse_optimize is True but pulse optimal decomposition is not known for requested basis. 2. pulse_optimize is True and natural_direction is True but a preferred gate direction can't be determined from the coupling map or the relative gate lengths. """ euler_basis = _choose_euler_basis(self._basis_gates) kak_gate = _choose_kak_gate(self._basis_gates) decomposer1q, decomposer2q = None, None if euler_basis is not None: decomposer1q = one_qubit_decompose.OneQubitEulerDecomposer( euler_basis) if kak_gate is not None: decomposer2q = TwoQubitBasisDecomposer( kak_gate, euler_basis=euler_basis, pulse_optimize=self._pulse_optimize) for node in dag.named_nodes(*self._synth_gates): if self._basis_gates and node.name in self._basis_gates: continue synth_dag = None wires = None if len(node.qargs) == 1: if decomposer1q is None: continue synth_dag = circuit_to_dag( decomposer1q._decompose(node.op.to_matrix())) elif len(node.qargs) == 2: if decomposer2q is None: continue synth_dag, wires = self._synth_natural_direction( node, dag, decomposer2q) else: synth_dag = circuit_to_dag( isometry.Isometry(node.op.to_matrix(), 0, 0).definition) dag.substitute_node_with_dag(node, synth_dag, wires=wires) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the HighLevelSynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with high level objects synthesized. """ for node in dag.named_nodes("clifford"): decomposition = circuit_to_dag(decompose_clifford(node.op)) dag.substitute_node_with_dag(node, decomposition) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the LinearFunctionsSynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with LinearFunctions synthesized. """ for node in dag.named_nodes("linear_function"): decomposition = circuit_to_dag(node.op.definition) dag.substitute_node_with_dag(node, decomposition) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the UnitarySynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with UnitaryGates synthesized to target basis. """ euler_basis = _choose_euler_basis(self._basis_gates) kak_gate = _choose_kak_gate(self._basis_gates) decomposer1q, decomposer2q = None, None if euler_basis is not None: decomposer1q = one_qubit_decompose.OneQubitEulerDecomposer( euler_basis) if kak_gate is not None: decomposer2q = TwoQubitBasisDecomposer(kak_gate, euler_basis=euler_basis) for node in dag.named_nodes("unitary"): synth_dag = None if len(node.qargs) == 1: if decomposer1q is None: continue synth_dag = circuit_to_dag( decomposer1q._decompose(node.op.to_matrix())) elif len(node.qargs) == 2: if decomposer2q is None: continue synth_dag = circuit_to_dag( decomposer2q(node.op.to_matrix(), basis_fidelity=self._approximation_degree)) else: synth_dag = circuit_to_dag( isometry.Isometry(node.op.to_matrix(), 0, 0).definition) dag.substitute_node_with_dag(node, synth_dag) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the UnitarySynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with UnitaryGates synthesized to target basis. Raises: TranspilerError: if a 'method' was specified for the class and is not found in the installed plugins list. The list of installed plugins can be queried with :func:`~qiskit.transpiler.passes.synthesis.plugin.unitary_synthesis_plugin_names` """ if self.method not in self.plugins.ext_plugins: raise TranspilerError( "Specified method: %s not found in plugin list" % self.method) default_method = self.plugins.ext_plugins["default"].obj plugin_method = self.plugins.ext_plugins[self.method].obj if plugin_method.supports_coupling_map: dag_bit_indices = {bit: idx for idx, bit in enumerate(dag.qubits)} kwargs = {} if plugin_method.supports_basis_gates: kwargs["basis_gates"] = self._basis_gates if plugin_method.supports_natural_direction: kwargs["natural_direction"] = self._natural_direction if plugin_method.supports_pulse_optimize: kwargs["pulse_optimize"] = self._pulse_optimize if plugin_method.supports_gate_lengths: kwargs["gate_lengths"] = _build_gate_lengths(self._backend_props) if plugin_method.supports_gate_errors: kwargs["gate_errors"] = _build_gate_errors(self._backend_props) supported_bases = plugin_method.supported_bases if supported_bases is not None: kwargs["matched_basis"] = _choose_bases(self._basis_gates, supported_bases) # Handle approximation degree as a special case for backwards compatibility, it's # not part of the plugin interface and only something needed for the default # pass. default_method._approximation_degree = self._approximation_degree if self.method == "default": plugin_method._approximation_degree = self._approximation_degree for node in dag.named_nodes(*self._synth_gates): if self._min_qubits is not None and len( node.qargs) < self._min_qubits: continue if plugin_method.supports_coupling_map: kwargs["coupling_map"] = ( self._coupling_map, [dag_bit_indices[x] for x in node.qargs], ) synth_dag = None unitary = node.op.to_matrix() n_qubits = len(node.qargs) if (plugin_method.max_qubits is not None and n_qubits > plugin_method.max_qubits) or ( plugin_method.min_qubits is not None and n_qubits < plugin_method.min_qubits): synth_dag = default_method.run(unitary, **kwargs) else: synth_dag = plugin_method.run(unitary, **kwargs) if synth_dag is not None: if isinstance(synth_dag, tuple): dag.substitute_node_with_dag(node, synth_dag[0], wires=synth_dag[1]) else: dag.substitute_node_with_dag(node, synth_dag) return dag
def run(self, dag: DAGCircuit) -> DAGCircuit: """Run the UnitarySynthesis pass on `dag`. Args: dag: input dag. Returns: Output dag with UnitaryGates synthesized to target basis. Raises: TranspilerError: if a 'method' was specified for the class and is not found in the installed plugins list. The list of installed plugins can be queried with :func:`~qiskit.transpiler.passes.synthesis.plugin.unitary_synthesis_plugin_names` """ if self.method not in self.plugins.ext_plugins: raise TranspilerError( "Specified method: %s not found in plugin list" % self.method) # Return fast if we have no synth gates (ie user specified an empty # list or the synth gates are all in the basis if not self._synth_gates: return dag plugin_method = self.plugins.ext_plugins[self.method].obj plugin_kwargs = {"config": self._plugin_config} _gate_lengths = _gate_errors = None dag_bit_indices = {} if self.method == "default": # If the method is the default, we only need to evaluate one set of keyword arguments. # To simplify later logic, and avoid cases where static analysis might complain that we # haven't initialised the "default" handler, we rebind the names so they point to the # same object as the chosen method. default_method = plugin_method default_kwargs = plugin_kwargs method_list = [(plugin_method, plugin_kwargs)] else: # If the method is not the default, we still need to initialise the default plugin's # keyword arguments in case we have to fall back on it during the actual run. default_method = self.plugins.ext_plugins["default"].obj default_kwargs = {} method_list = [(plugin_method, plugin_kwargs), (default_method, default_kwargs)] for method, kwargs in method_list: if method.supports_basis_gates: kwargs["basis_gates"] = self._basis_gates if method.supports_coupling_map: dag_bit_indices = dag_bit_indices or { bit: i for i, bit in enumerate(dag.qubits) } if method.supports_natural_direction: kwargs["natural_direction"] = self._natural_direction if method.supports_pulse_optimize: kwargs["pulse_optimize"] = self._pulse_optimize if method.supports_gate_lengths: _gate_lengths = _gate_lengths or _build_gate_lengths( self._backend_props, self._target) kwargs["gate_lengths"] = _gate_lengths if method.supports_gate_errors: _gate_errors = _gate_errors or _build_gate_errors( self._backend_props, self._target) kwargs["gate_errors"] = _gate_errors supported_bases = method.supported_bases if supported_bases is not None: kwargs["matched_basis"] = _choose_bases( self._basis_gates, supported_bases) if method.supports_target: kwargs["target"] = self._target # Handle approximation degree as a special case for backwards compatibility, it's # not part of the plugin interface and only something needed for the default # pass. default_method._approximation_degree = self._approximation_degree if self.method == "default": plugin_method._approximation_degree = self._approximation_degree for node in dag.named_nodes(*self._synth_gates): if self._min_qubits is not None and len( node.qargs) < self._min_qubits: continue synth_dag = None unitary = node.op.to_matrix() n_qubits = len(node.qargs) if (plugin_method.max_qubits is not None and n_qubits > plugin_method.max_qubits) or ( plugin_method.min_qubits is not None and n_qubits < plugin_method.min_qubits): method, kwargs = default_method, default_kwargs else: method, kwargs = plugin_method, plugin_kwargs if method.supports_coupling_map: kwargs["coupling_map"] = ( self._coupling_map, [dag_bit_indices[x] for x in node.qargs], ) synth_dag = method.run(unitary, **kwargs) if synth_dag is not None: if isinstance(synth_dag, tuple): dag.substitute_node_with_dag(node, synth_dag[0], wires=synth_dag[1]) else: dag.substitute_node_with_dag(node, synth_dag) return dag