def dagdependency_to_dag(dagdependency):
"""Build a ``DAGCircuit`` object from a ``DAGDependency``.
Args:
dag dependency (DAGDependency): the input dag.
Return:
DAGCircuit: the DAG representing the input circuit.
"""
dagcircuit = DAGCircuit()
dagcircuit.name = dagdependency.name
qregs = list(dagdependency.qregs.values())
cregs = list(dagdependency.cregs.values())
for register in qregs:
dagcircuit.add_qreg(register)
for register in cregs:
dagcircuit.add_creg(register)
for node in dagdependency.get_nodes():
# Get arguments for classical control (if any)
inst = node.op.copy()
inst.condition = node.condition
dagcircuit.apply_operation_back(inst, node.qargs, node.cargs,
inst.condition)
return dagcircuit
def circuit_to_dag(circuit):
"""Build a ``DAGCircuit`` object from a ``QuantumCircuit``.
Args:
circuit (QuantumCircuit): the input circuit.
Return:
DAGCircuit: the DAG representing the input circuit.
"""
dagcircuit = DAGCircuit()
dagcircuit.name = circuit.name
for register in circuit.qregs:
dagcircuit.add_qreg(register)
for register in circuit.cregs:
dagcircuit.add_creg(register)
for instruction, qargs, cargs in circuit.data:
# Get arguments for classical control (if any)
if instruction.control is None:
control = None
else:
control = (instruction.control[0], instruction.control[1])
instruction = copy.deepcopy(instruction)
dagcircuit.apply_operation_back(instruction, qargs, cargs, control)
return dagcircuit
def dagdependency_to_dag(dagdependency):
"""Build a ``DAGCircuit`` object from a ``DAGDependency``.
Args:
dag dependency (DAGDependency): the input dag.
Return:
DAGCircuit: the DAG representing the input circuit.
"""
dagcircuit = DAGCircuit()
dagcircuit.name = dagdependency.name
dagcircuit.metadata = dagdependency.metadata
dagcircuit.add_qubits(dagdependency.qubits)
dagcircuit.add_clbits(dagdependency.clbits)
for register in dagdependency.qregs.values():
dagcircuit.add_qreg(register)
for register in dagdependency.cregs.values():
dagcircuit.add_creg(register)
for node in dagdependency.get_nodes():
# Get arguments for classical control (if any)
inst = node.op.copy()
dagcircuit.apply_operation_back(inst, node.qargs, node.cargs)
# copy metadata
dagcircuit.global_phase = dagdependency.global_phase
dagcircuit.calibrations = dagdependency.calibrations
return dagcircuit
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 _create_empty_dagcircuit_from_existing(dagcircuit: DAGCircuit) -> DAGCircuit:
result = DAGCircuit()
for creg in dagcircuit.cregs.values():
result.add_creg(creg)
for qreg in dagcircuit.qregs.values():
result.add_qreg(qreg)
return result
def circuit_to_dag(circuit):
"""Build a ``DAGCircuit`` object from a ``QuantumCircuit``.
Args:
circuit (QuantumCircuit): the input circuit.
Return:
DAGCircuit: the DAG representing the input circuit.
"""
dagcircuit = DAGCircuit()
dagcircuit.name = circuit.name
for register in circuit.qregs:
dagcircuit.add_qreg(register)
for register in circuit.cregs:
dagcircuit.add_creg(register)
for instruction, qargs, cargs in circuit.data:
# Get arguments for classical control (if any)
if instruction.control is None:
control = None
else:
control = (instruction.control[0], instruction.control[1])
def duplicate_instruction(inst):
"""Create a fresh instruction from an input instruction."""
if issubclass(inst.__class__,
inst_mod.Instruction) and inst.__class__ not in [
inst_mod.Instruction, gate.Gate]:
if inst.name == 'barrier':
new_inst = inst.__class__(inst.num_qubits)
elif inst.name == 'initialize':
params = getattr(inst, 'params', [])
new_inst = inst.__class__(params)
elif inst.name == 'snapshot':
label = inst.params[0]
snap_type = inst.params[1]
new_inst = inst.__class__(inst.num_qubits, inst.num_clbits,
label, snap_type)
else:
params = getattr(inst, 'params', [])
new_inst = inst.__class__(*params)
else:
if isinstance(inst, gate.Gate):
new_inst = gate.Gate(inst.name, inst.num_qubits,
inst.params)
else:
new_inst = inst_mod.Instruction(name=inst.name,
num_qubits=inst.num_qubits,
num_clbits=inst.num_clbits,
params=inst.params)
new_inst.definition = inst.definition
return new_inst
dagcircuit.apply_operation_back(duplicate_instruction(instruction),
qargs, cargs, control)
return dagcircuit
def _to_dag(circuit):
qiskit_dag = DAGCircuit()
qreg = QuantumRegister(circuit.num_qubits())
qiskit_dag.add_qreg(qreg)
if circuit.num_cbits():
creg = ClassicalRegister(circuit.num_cbits())
qiskit_dag.add_creg(creg)
for instruction in circuit:
gate = _convert_tweedledum_op(instruction)
qubits = [qreg[qubit.uid()] for qubit in instruction.qubits()]
cbits = [creg[cbit.uid()] for cbit in instruction.cbits()]
qiskit_dag.apply_operation_back(gate, qubits, cbits)
return qiskit_dag
def circuit_to_dag(circuit):
"""Build a ``DAGCircuit`` object from a ``QuantumCircuit``.
Args:
circuit (QuantumCircuit): the input circuit.
Return:
DAGCircuit: the DAG representing the input circuit.
Example:
.. jupyter-execute::
from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
from qiskit.dagcircuit import DAGCircuit
from qiskit.converters import circuit_to_dag
from qiskit.visualization import dag_drawer
%matplotlib inline
q = QuantumRegister(3, 'q')
c = ClassicalRegister(3, 'c')
circ = QuantumCircuit(q, c)
circ.h(q[0])
circ.cx(q[0], q[1])
circ.measure(q[0], c[0])
circ.rz(0.5, q[1]).c_if(c, 2)
dag = circuit_to_dag(circ)
dag_drawer(dag)
"""
dagcircuit = DAGCircuit()
dagcircuit.name = circuit.name
dagcircuit.global_phase = circuit.global_phase
dagcircuit.calibrations = circuit.calibrations
dagcircuit.metadata = circuit.metadata
dagcircuit.add_qubits(circuit.qubits)
dagcircuit.add_clbits(circuit.clbits)
for register in circuit.qregs:
dagcircuit.add_qreg(register)
for register in circuit.cregs:
dagcircuit.add_creg(register)
for instruction in circuit.data:
dagcircuit.apply_operation_back(instruction.operation.copy(),
instruction.qubits, instruction.clbits)
dagcircuit.duration = circuit.duration
dagcircuit.unit = circuit.unit
return dagcircuit
def circuit_to_dag(circuit):
"""Build a ``DAGCircuit`` object from a ``QuantumCircuit``.
Args:
circuit (QuantumCircuit): the input circuit.
Return:
DAGCircuit: the DAG representing the input circuit.
"""
dagcircuit = DAGCircuit()
dagcircuit.name = circuit.name
for register in circuit.qregs:
dagcircuit.add_qreg(register)
for register in circuit.cregs:
dagcircuit.add_creg(register)
for main_instruction in circuit.data:
# TODO: generate nodes for CompositeGates;
# for now simply drop their instructions into the DAG
instruction_list = []
is_composite = isinstance(main_instruction, CompositeGate)
if is_composite:
instruction_list = main_instruction.instruction_list()
else:
instruction_list.append(main_instruction)
for instruction in instruction_list:
# Get arguments for classical control (if any)
if instruction.control is None:
control = None
else:
control = (instruction.control[0], instruction.control[1])
def duplicate_instruction(inst):
"""Create a fresh instruction from an input instruction."""
if inst.name == 'barrier':
params = [inst.qargs]
elif inst.name == 'snapshot':
params = inst.params + [inst.qargs]
else:
params = inst.params + inst.qargs + inst.cargs
new_inst = inst.__class__(*params)
return new_inst
inst = duplicate_instruction(instruction)
dagcircuit.apply_operation_back(inst, inst.qargs, inst.cargs,
control)
return dagcircuit
def circuit_to_dag(circuit):
"""Build a ``DAGCircuit`` object from a ``QuantumCircuit``.
Args:
circuit (QuantumCircuit): the input circuit.
Return:
DAGCircuit: the DAG representing the input circuit.
"""
dagcircuit = DAGCircuit()
dagcircuit.name = circuit.name
for register in circuit.qregs:
dagcircuit.add_qreg(register)
for register in circuit.cregs:
dagcircuit.add_creg(register)
for instruction, qargs, cargs in circuit.data:
dagcircuit.apply_operation_back(instruction.copy(), qargs, cargs,
instruction.condition)
return dagcircuit