def dag_to_dagdependency(dag):
"""Build a ``DAGDependency`` object from a ``DAGCircuit``.
Args:
dag (DAGCircuit): the input dag.
Return:
DAGDependency: the DAG representing the input circuit as a dag dependency.
"""
dagdependency = DAGDependency()
dagdependency.name = dag.name
dagdependency.metadata = dag.metadata
dagdependency.add_qubits(dag.qubits)
dagdependency.add_clbits(dag.clbits)
for register in dag.qregs.values():
dagdependency.add_qreg(register)
for register in dag.cregs.values():
dagdependency.add_creg(register)
for node in dag.topological_op_nodes():
# Get arguments for classical control (if any)
inst = node.op.copy()
dagdependency.add_op_node(inst, node.qargs, node.cargs)
dagdependency._add_successors()
# copy metadata
dagdependency.global_phase = dag.global_phase
dagdependency.calibrations = dag.calibrations
return dagdependency
def circuit_to_dagdependency(circuit):
"""Build a ``DAGDependency`` object from a ``QuantumCircuit``.
Args:
circuit (QuantumCircuit): the input circuits.
Return:
DAGDependency: the DAG representing the input circuit as a dag dependency.
"""
dagdependency = DAGDependency()
dagdependency.name = circuit.name
for register in circuit.qregs:
dagdependency.add_qreg(register)
for register in circuit.cregs:
dagdependency.add_creg(register)
for operation, qargs, cargs in circuit.data:
dagdependency.add_op_node(operation, qargs, cargs)
dagdependency._add_successors()
dagdependency.calibrations = circuit.calibrations
return dagdependency
def run_dag_opt(self):
"""
It runs the substitution algorithm and creates the optimized DAGCircuit().
"""
self._substitution()
dag_dep_opt = DAGDependency()
dag_dep_opt.name = self.circuit_dag_dep.name
qregs = list(self.circuit_dag_dep.qregs.values())
cregs = list(self.circuit_dag_dep.cregs.values())
for register in qregs:
dag_dep_opt.add_qreg(register)
for register in cregs:
dag_dep_opt.add_creg(register)
already_sub = []
if self.substitution_list:
# Loop over the different matches.
for group in self.substitution_list:
circuit_sub = group.circuit_config
template_inverse = group.template_config
pred = group.pred_block
qubit = group.qubit_config[0]
if group.clbit_config:
clbit = group.clbit_config[0]
else:
clbit = []
# First add all the predecessors of the given match.
for elem in pred:
node = self.circuit_dag_dep.get_node(elem)
inst = node.op.copy()
inst.condition = node.condition
dag_dep_opt.add_op_node(inst, node.qargs, node.cargs)
already_sub.append(elem)
already_sub = already_sub + circuit_sub
# Then add the inverse of the template.
for index in template_inverse:
all_qubits = self.circuit_dag_dep.qubits
qarg_t = self.template_dag_dep.get_node(index).qindices
qarg_c = [qubit[x] for x in qarg_t]
qargs = [all_qubits[x] for x in qarg_c]
all_clbits = self.circuit_dag_dep.clbits
carg_t = self.template_dag_dep.get_node(index).cindices
if all_clbits and clbit:
carg_c = [clbit[x] for x in carg_t]
cargs = [all_clbits[x] for x in carg_c]
else:
cargs = []
node = self.template_dag_dep.get_node(index)
inst = node.op.copy()
inst.condition = node.condition
dag_dep_opt.add_op_node(inst.inverse(), qargs, cargs)
# Add the unmatched gates.
for node_id in self.unmatched_list:
node = self.circuit_dag_dep.get_node(node_id)
inst = node.op.copy()
inst.condition = node.condition
dag_dep_opt.add_op_node(inst, node.qargs, node.cargs)
dag_dep_opt._add_successors()
# If there is no valid match, it returns the original dag.
else:
dag_dep_opt = self.circuit_dag_dep
self.dag_dep_optimized = dag_dep_opt
self.dag_optimized = dagdependency_to_dag(dag_dep_opt)