qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/converters/circuit_to_dag.py

@@ -0,0 +1,96 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a circuit to a dag"""
+import copy
+
+from qiskit.dagcircuit.dagcircuit import DAGCircuit
+
+
+def circuit_to_dag(circuit, copy_operations=True, *, qubit_order=None, clbit_order=None):
+    """Build a :class:`.DAGCircuit` object from a :class:`.QuantumCircuit`.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        copy_operations (bool): Deep copy the operation objects
+            in the :class:`~.QuantumCircuit` for the output :class:`~.DAGCircuit`.
+            This should only be set to ``False`` if the input :class:`~.QuantumCircuit`
+            will not be used anymore as the operations in the output
+            :class:`~.DAGCircuit` will be shared instances and modifications to
+            operations in the :class:`~.DAGCircuit` will be reflected in the
+            :class:`~.QuantumCircuit` (and vice versa).
+        qubit_order (Iterable[~qiskit.circuit.Qubit] or None): the order that the qubits should be
+            indexed in the output DAG.  Defaults to the same order as in the circuit.
+        clbit_order (Iterable[Clbit] or None): the order that the clbits should be indexed in the
+            output DAG.  Defaults to the same order as in the circuit.
+
+    Return:
+        DAGCircuit: the DAG representing the input circuit.
+
+    Raises:
+        ValueError: if the ``qubit_order`` or ``clbit_order`` parameters do not match the bits in
+            the circuit.
+
+    Example:
+        .. code-block::
+
+            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.dagcircuit import DAGCircuit
+            from qiskit.converters import circuit_to_dag
+
+            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)
+    """
+    dagcircuit = DAGCircuit()
+    dagcircuit.name = circuit.name
+    dagcircuit.global_phase = circuit.global_phase
+    dagcircuit.calibrations = circuit.calibrations
+    dagcircuit.metadata = circuit.metadata
+
+    if qubit_order is None:
+        qubits = circuit.qubits
+    elif len(qubit_order) != circuit.num_qubits or set(qubit_order) != set(circuit.qubits):
+        raise ValueError("'qubit_order' does not contain exactly the same qubits as the circuit")
+    else:
+        qubits = qubit_order
+
+    if clbit_order is None:
+        clbits = circuit.clbits
+    elif len(clbit_order) != circuit.num_clbits or set(clbit_order) != set(circuit.clbits):
+        raise ValueError("'clbit_order' does not contain exactly the same clbits as the circuit")
+    else:
+        clbits = clbit_order
+
+    dagcircuit.add_qubits(qubits)
+    dagcircuit.add_clbits(clbits)
+
+    for register in circuit.qregs:
+        dagcircuit.add_qreg(register)
+
+    for register in circuit.cregs:
+        dagcircuit.add_creg(register)
+
+    for instruction in circuit.data:
+        op = instruction.operation
+        if copy_operations:
+            op = copy.deepcopy(op)
+        dagcircuit.apply_operation_back(op, instruction.qubits, instruction.clbits, check=False)
+
+    dagcircuit.duration = circuit.duration
+    dagcircuit.unit = circuit.unit
+    return dagcircuit

qiskit/converters/circuit_to_dagdependency.py

@@ -0,0 +1,51 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a circuit to a dag dependency"""
+
+from qiskit.dagcircuit.dagdependency import DAGDependency
+
+
+def circuit_to_dagdependency(circuit, create_preds_and_succs=True):
+    """Build a ``DAGDependency`` object from a :class:`~.QuantumCircuit`.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        create_preds_and_succs (bool): whether to construct lists of
+            predecessors and successors for every node.
+
+    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)
+
+    if create_preds_and_succs:
+        dagdependency._add_predecessors()
+        dagdependency._add_successors()
+
+    dagdependency.calibrations = circuit.calibrations
+
+    return dagdependency

qiskit/converters/circuit_to_gate.py

@@ -0,0 +1,109 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+
+"""Helper function for converting a circuit to a gate"""
+from qiskit.circuit.annotated_operation import AnnotatedOperation
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.exceptions import QiskitError
+
+
+def _check_is_gate(op):
+    """Checks whether op can be converted to Gate."""
+    if isinstance(op, Gate):
+        return True
+    elif isinstance(op, AnnotatedOperation):
+        return _check_is_gate(op.base_op)
+    return False
+
+
+def circuit_to_gate(circuit, parameter_map=None, equivalence_library=None, label=None):
+    """Build a :class:`.Gate` object from a :class:`.QuantumCircuit`.
+
+    The gate is anonymous (not tied to a named quantum register),
+    and so can be inserted into another circuit. The gate will
+    have the same string name as the circuit.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        parameter_map (dict): For parameterized circuits, a mapping from
+           parameters in the circuit to parameters to be used in the gate.
+           If None, existing circuit parameters will also parameterize the
+           Gate.
+        equivalence_library (EquivalenceLibrary): Optional equivalence library
+           where the converted gate will be registered.
+        label (str): Optional gate label.
+
+    Raises:
+        QiskitError: if circuit is non-unitary or if
+            parameter_map is not compatible with circuit
+
+    Return:
+        Gate: a Gate equivalent to the action of the
+        input circuit. Upon decomposition, this gate will
+        yield the components comprising the original circuit.
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+    if circuit.clbits:
+        raise QiskitError("Circuit with classical bits cannot be converted to gate.")
+
+    for instruction in circuit.data:
+        if not _check_is_gate(instruction.operation):
+            raise QiskitError(
+                (
+                    "One or more instructions cannot be converted to"
+                    ' a gate. "{}" is not a gate instruction'
+                ).format(instruction.operation.name)
+            )
+
+    if parameter_map is None:
+        parameter_dict = {p: p for p in circuit.parameters}
+    else:
+        parameter_dict = circuit._unroll_param_dict(parameter_map)
+
+    if parameter_dict.keys() != circuit.parameters:
+        raise QiskitError(
+            (
+                "parameter_map should map all circuit parameters. "
+                "Circuit parameters: {}, parameter_map: {}"
+            ).format(circuit.parameters, parameter_dict)
+        )
+
+    gate = Gate(
+        name=circuit.name,
+        num_qubits=circuit.num_qubits,
+        params=[*parameter_dict.values()],
+        label=label,
+    )
+    gate.condition = None
+
+    target = circuit.assign_parameters(parameter_dict, inplace=False)
+
+    if equivalence_library is not None:
+        equivalence_library.add_equivalence(gate, target)
+
+    qc = QuantumCircuit(name=gate.name, global_phase=target.global_phase)
+    if gate.num_qubits > 0:
+        q = QuantumRegister(gate.num_qubits, "q")
+        qc.add_register(q)
+    qubit_map = {bit: q[idx] for idx, bit in enumerate(circuit.qubits)}
+
+    # The 3rd parameter in the output tuple) is hard coded to [] because
+    # Gate objects do not have cregs set and we've verified that all
+    # instructions are gates
+    for instruction in target.data:
+        qc._append(instruction.replace(qubits=tuple(qubit_map[y] for y in instruction.qubits)))
+    gate.definition = qc
+    return gate

qiskit/converters/circuit_to_instruction.py

@@ -0,0 +1,131 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a circuit to an instruction."""
+
+from qiskit.exceptions import QiskitError
+from qiskit.circuit.instruction import Instruction
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.classicalregister import ClassicalRegister, Clbit
+
+
+def circuit_to_instruction(circuit, parameter_map=None, equivalence_library=None, label=None):
+    """Build an :class:`~.circuit.Instruction` object from a :class:`.QuantumCircuit`.
+
+    The instruction is anonymous (not tied to a named quantum register),
+    and so can be inserted into another circuit. The instruction will
+    have the same string name as the circuit.
+
+    Args:
+        circuit (QuantumCircuit): the input circuit.
+        parameter_map (dict): For parameterized circuits, a mapping from
+           parameters in the circuit to parameters to be used in the instruction.
+           If None, existing circuit parameters will also parameterize the
+           instruction.
+        equivalence_library (EquivalenceLibrary): Optional equivalence library
+           where the converted instruction will be registered.
+        label (str): Optional instruction label.
+
+    Raises:
+        QiskitError: if parameter_map is not compatible with circuit
+
+    Return:
+        qiskit.circuit.Instruction: an instruction equivalent to the action of the
+        input circuit. Upon decomposition, this instruction will
+        yield the components comprising the original circuit.
+
+    Example:
+        .. code-block::
+
+            from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+            from qiskit.converters import circuit_to_instruction
+
+            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)
+            circuit_to_instruction(circ)
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+    if parameter_map is None:
+        parameter_dict = {p: p for p in circuit.parameters}
+    else:
+        parameter_dict = circuit._unroll_param_dict(parameter_map)
+
+    if parameter_dict.keys() != circuit.parameters:
+        raise QiskitError(
+            (
+                "parameter_map should map all circuit parameters. "
+                "Circuit parameters: {}, parameter_map: {}"
+            ).format(circuit.parameters, parameter_dict)
+        )
+
+    out_instruction = Instruction(
+        name=circuit.name,
+        num_qubits=circuit.num_qubits,
+        num_clbits=circuit.num_clbits,
+        params=[*parameter_dict.values()],
+        label=label,
+    )
+    out_instruction._condition = None
+
+    target = circuit.assign_parameters(parameter_dict, inplace=False)
+
+    if equivalence_library is not None:
+        equivalence_library.add_equivalence(out_instruction, target)
+
+    regs = []
+    if out_instruction.num_qubits > 0:
+        q = QuantumRegister(out_instruction.num_qubits, "q")
+        regs.append(q)
+
+    if out_instruction.num_clbits > 0:
+        c = ClassicalRegister(out_instruction.num_clbits, "c")
+        regs.append(c)
+
+    qubit_map = {bit: q[idx] for idx, bit in enumerate(circuit.qubits)}
+    clbit_map = {bit: c[idx] for idx, bit in enumerate(circuit.clbits)}
+
+    qc = QuantumCircuit(*regs, name=out_instruction.name)
+    qc._data.reserve(len(target.data))
+    for instruction in target._data:
+        rule = instruction.replace(
+            qubits=[qubit_map[y] for y in instruction.qubits],
+            clbits=[clbit_map[y] for y in instruction.clbits],
+        )
+
+        # fix condition
+        condition = getattr(rule.operation, "condition", None)
+        if condition:
+            reg, val = condition
+            if isinstance(reg, Clbit):
+                rule = rule.replace(operation=rule.operation.c_if(clbit_map[reg], val))
+            elif reg.size == c.size:
+                rule = rule.replace(operation=rule.operation.c_if(c, val))
+            else:
+                raise QiskitError(
+                    "Cannot convert condition in circuit with "
+                    "multiple classical registers to instruction"
+                )
+        qc._append(rule)
+
+    if circuit.global_phase:
+        qc.global_phase = circuit.global_phase
+
+    out_instruction.definition = qc
+
+    return out_instruction

qiskit/converters/dag_to_circuit.py

@@ -0,0 +1,77 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2018.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a dag to a circuit."""
+import copy
+
+from qiskit.circuit import QuantumCircuit, CircuitInstruction
+
+
+def dag_to_circuit(dag, copy_operations=True):
+    """Build a ``QuantumCircuit`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
+        copy_operations (bool): Deep copy the operation objects
+            in the :class:`~.DAGCircuit` for the output :class:`~.QuantumCircuit`.
+            This should only be set to ``False`` if the input :class:`~.DAGCircuit`
+            will not be used anymore as the operations in the output
+            :class:`~.QuantumCircuit` will be shared instances and
+            modifications to operations in the :class:`~.DAGCircuit` will
+            be reflected in the :class:`~.QuantumCircuit` (and vice versa).
+
+    Return:
+        QuantumCircuit: the circuit representing the input dag.
+
+    Example:
+        .. plot::
+           :include-source:
+
+           from qiskit import QuantumRegister, ClassicalRegister, QuantumCircuit
+           from qiskit.dagcircuit import DAGCircuit
+           from qiskit.converters import circuit_to_dag
+           from qiskit.circuit.library.standard_gates import CHGate, U2Gate, CXGate
+           from qiskit.converters import dag_to_circuit
+
+           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)
+           circuit = dag_to_circuit(dag)
+           circuit.draw('mpl')
+    """
+
+    name = dag.name or None
+    circuit = QuantumCircuit(
+        dag.qubits,
+        dag.clbits,
+        *dag.qregs.values(),
+        *dag.cregs.values(),
+        name=name,
+        global_phase=dag.global_phase,
+    )
+    circuit.metadata = dag.metadata
+    circuit.calibrations = dag.calibrations
+
+    for node in dag.topological_op_nodes():
+        op = node.op
+        if copy_operations:
+            op = copy.deepcopy(op)
+        circuit._append(CircuitInstruction(op, node.qargs, node.cargs))
+
+    circuit.duration = dag.duration
+    circuit.unit = dag.unit
+    return circuit

qiskit/converters/dag_to_dagdependency.py

@@ -0,0 +1,55 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a dag circuit to a dag dependency"""
+from qiskit.dagcircuit.dagdependency import DAGDependency
+
+
+def dag_to_dagdependency(dag, create_preds_and_succs=True):
+    """Build a ``DAGDependency`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
+        create_preds_and_succs (bool): whether to construct lists of
+            predecessors and successors for every node.
+
+    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)
+
+    if create_preds_and_succs:
+        dagdependency._add_predecessors()
+        dagdependency._add_successors()
+
+    # copy metadata
+    dagdependency.global_phase = dag.global_phase
+    dagdependency.calibrations = dag.calibrations
+
+    return dagdependency

qiskit/converters/dagdependency_to_circuit.py

@@ -0,0 +1,42 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a dag dependency to a circuit"""
+from qiskit.circuit import QuantumCircuit, CircuitInstruction
+
+
+def dagdependency_to_circuit(dagdependency):
+    """Build a ``QuantumCircuit`` object from a ``DAGDependency``.
+
+    Args:
+        dagdependency (DAGDependency): the input dag.
+
+    Return:
+        QuantumCircuit: the circuit representing the input dag dependency.
+    """
+
+    name = dagdependency.name or None
+    circuit = QuantumCircuit(
+        dagdependency.qubits,
+        dagdependency.clbits,
+        *dagdependency.qregs.values(),
+        *dagdependency.cregs.values(),
+        name=name,
+    )
+    circuit.metadata = dagdependency.metadata
+
+    circuit.calibrations = dagdependency.calibrations
+
+    for node in dagdependency.topological_nodes():
+        circuit._append(CircuitInstruction(node.op.copy(), node.qargs, node.cargs))
+
+    return circuit

qiskit/converters/dagdependency_to_dag.py

@@ -0,0 +1,49 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2020.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""Helper function for converting a dag dependency to a dag circuit"""
+from qiskit.dagcircuit.dagcircuit import 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.topological_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

qiskit/dagcircuit/__init__.py

@@ -0,0 +1,44 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 2021.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+=======================================
+DAG Circuits (:mod:`qiskit.dagcircuit`)
+=======================================
+
+.. currentmodule:: qiskit.dagcircuit
+
+Circuits as Directed Acyclic Graphs
+===================================
+
+.. autosummary::
+   :toctree: ../stubs/
+
+   DAGCircuit
+   DAGNode
+   DAGOpNode
+   DAGInNode
+   DAGOutNode
+   DAGDepNode
+   DAGDependency
+
+Exceptions
+==========
+
+.. autoexception:: DAGCircuitError
+.. autoexception:: DAGDependencyError
+"""
+from .dagcircuit import DAGCircuit
+from .dagnode import DAGNode, DAGOpNode, DAGInNode, DAGOutNode
+from .dagdepnode import DAGDepNode
+from .exceptions import DAGCircuitError, DAGDependencyError
+from .dagdependency import DAGDependency