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
qregs = list(dag.qregs.values())
cregs = list(dag.cregs.values())
for register in qregs:
dagdependency.add_qreg(register)
for register in cregs:
dagdependency.add_creg(register)
for node in dag.topological_op_nodes():
# Get arguments for classical control (if any)
inst = node.op.copy()
inst.condition = node.condition
dagdependency.add_op_node(inst, node.qargs, node.cargs)
dagdependency._add_successors()
return dagdependency
def __init__(self, max_matches, circuit_dag_dep, template_dag_dep):
"""
Initialize TemplateSubstitution with necessary arguments.
Args:
max_matches (list): list of maximal matches obtained from the running
the template matching algorithm.
circuit_dag_dep (DAGDependency): circuit in the dag dependency form.
template_dag_dep (DAGDependency): template in the dag dependency form.
"""
self.match_stack = max_matches
self.circuit_dag_dep = circuit_dag_dep
self.template_dag_dep = template_dag_dep
self.substitution_list = []
self.unmatched_list = []
self.dag_dep_optimized = DAGDependency()
self.dag_optimized = DAGCircuit()
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)
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
dagdependency.metadata = circuit.metadata
dagdependency.add_qubits(circuit.qubits)
dagdependency.add_clbits(circuit.clbits)
for register in circuit.qregs:
dagdependency.add_qreg(register)
for register in circuit.cregs:
dagdependency.add_creg(register)
for instruction in circuit.data:
dagdependency.add_op_node(instruction.operation, instruction.qubits,
instruction.clbits)
dagdependency._add_successors()
dagdependency.calibrations = circuit.calibrations
return dagdependency
def __init__(self,
max_matches,
circuit_dag_dep,
template_dag_dep,
user_cost_dict=None):
"""
Initialize TemplateSubstitution with necessary arguments.
Args:
max_matches (list): list of maximal matches obtained from the running
the template matching algorithm.
circuit_dag_dep (DAGDependency): circuit in the dag dependency form.
template_dag_dep (DAGDependency): template in the dag dependency form.
user_cost_dict (Optional[dict]): user provided cost dictionary that will override
the default cost dictionary.
"""
self.match_stack = max_matches
self.circuit_dag_dep = circuit_dag_dep
self.template_dag_dep = template_dag_dep
self.substitution_list = []
self.unmatched_list = []
self.dag_dep_optimized = DAGDependency()
self.dag_optimized = DAGCircuit()
if user_cost_dict is not None:
self.cost_dict = dict(user_cost_dict)
else:
self.cost_dict = {
'id': 0,
'x': 1,
'y': 1,
'z': 1,
'h': 1,
't': 1,
'tdg': 1,
's': 1,
'sdg': 1,
'u1': 1,
'u2': 2,
'u3': 2,
'rx': 1,
'ry': 1,
'rz': 1,
'r': 2,
'cx': 2,
'cy': 4,
'cz': 4,
'ch': 8,
'swap': 6,
'iswap': 8,
'rxx': 9,
'ryy': 9,
'rzz': 5,
'rzx': 7,
'ms': 9,
'cu3': 10,
'crx': 10,
'cry': 10,
'crz': 10,
'ccx': 21,
'rccx': 12,
'c3x': 96,
'rc3x': 24,
'c4x': 312,
'p': 1
}
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()
return dagdependency
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()
inst.condition = node.condition
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 __init__(self,
max_matches,
circuit_dag_dep,
template_dag_dep,
user_cost_dict=None):
"""
Initialize TemplateSubstitution with necessary arguments.
Args:
max_matches (list): list of maximal matches obtained from the running
the template matching algorithm.
circuit_dag_dep (DAGDependency): circuit in the dag dependency form.
template_dag_dep (DAGDependency): template in the dag dependency form.
user_cost_dict (Optional[dict]): user provided cost dictionary that will override
the default cost dictionary.
"""
self.match_stack = max_matches
self.circuit_dag_dep = circuit_dag_dep
self.template_dag_dep = template_dag_dep
self.substitution_list = []
self.unmatched_list = []
self.dag_dep_optimized = DAGDependency()
self.dag_optimized = DAGCircuit()
if user_cost_dict is not None:
self.cost_dict = dict(user_cost_dict)
else:
self.cost_dict = {
"id": 0,
"x": 1,
"y": 1,
"z": 1,
"h": 1,
"t": 1,
"tdg": 1,
"s": 1,
"sdg": 1,
"u1": 1,
"u2": 2,
"u3": 2,
"rx": 1,
"ry": 1,
"rz": 1,
"r": 2,
"cx": 2,
"cy": 4,
"cz": 4,
"ch": 8,
"swap": 6,
"iswap": 8,
"rxx": 9,
"ryy": 9,
"rzz": 5,
"rzx": 7,
"ms": 9,
"cu3": 10,
"crx": 10,
"cry": 10,
"crz": 10,
"ccx": 21,
"rccx": 12,
"c3x": 96,
"rc3x": 24,
"c4x": 312,
"p": 1,
}