qiskit 2.1.0rc1__cp39-abi3-manylinux2014_aarch64.manylinux_2_17_aarch64.whl

qiskit/converters/circuit_to_gate.py

@@ -0,0 +1,107 @@
+# 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 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.")
+    if circuit.num_vars:
+        raise QiskitError("circuits with realtime classical variables cannot be converted to gates")
+
+    for instruction in circuit.data:
+        if not _check_is_gate(instruction.operation):
+            raise QiskitError(
+                "One or more instructions cannot be converted to"
+                f' a gate. "{instruction.operation.name}" is not a gate instruction'
+            )
+
+    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. "
+            f"Circuit parameters: {circuit.parameters}, parameter_map: {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,142 @@
+# 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 import QuantumRegister
+from qiskit.circuit import ClassicalRegister
+
+
+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:
+        .. plot::
+            :include-source:
+            :nofigs:
+
+            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])
+            circuit_to_instruction(circ)
+    """
+    # pylint: disable=cyclic-import
+    from qiskit.circuit.quantumcircuit import QuantumCircuit
+
+    if circuit.num_input_vars:
+        # This could be supported by moving the `input` variables to be parameters of the
+        # instruction, but we don't really have a good representation of that yet, so safer to
+        # forbid it.
+        raise QiskitError("Circuits with 'input' variables cannot yet be converted to instructions")
+    if circuit.num_captured_vars:
+        raise QiskitError("Circuits that capture variables cannot be converted to instructions")
+    if circuit.num_declared_vars:
+        # This could very easily be supported in representations, since the variables are allocated
+        # and freed within the instruction itself.  The reason to initially forbid it is to avoid
+        # needing to support unrolling such instructions within the transpiler; we would potentially
+        # need to remap variables to unique names in the larger context, and we don't yet have a way
+        # to return that information from the transpiler.  We have to catch that in the transpiler
+        # as well since a user could manually make an instruction with such a definition, but
+        # forbidding it here means users get a more meaningful error at the point that the
+        # instruction actually gets created (since users often aren't aware that
+        # `QuantumCircuit.append(QuantumCircuit)` implicitly converts to an instruction).
+        raise QiskitError(
+            "Circuits with internal variables cannot yet be converted to instructions."
+            " You may be able to use `QuantumCircuit.compose` to inline this circuit into another."
+        )
+
+    if circuit.has_control_flow_op():
+        raise QiskitError(
+            "Circuits with control flow operations cannot be converted to an instruction."
+        )
+
+    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. "
+            f"Circuit parameters: {circuit.parameters}, parameter_map: {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 = []
+    qreg, creg = None, None
+    if out_instruction.num_qubits > 0:
+        qreg = QuantumRegister(out_instruction.num_qubits, "q")
+        regs.append(qreg)
+
+    if out_instruction.num_clbits > 0:
+        creg = ClassicalRegister(out_instruction.num_clbits, "c")
+        regs.append(creg)
+
+    data = target._data.copy()
+    data.replace_bits(qubits=qreg, clbits=creg)
+
+    qc = QuantumCircuit(name=out_instruction.name)
+    qc._data = data
+
+    # Re-add the registers.
+    for reg in regs:
+        qc.add_register(reg)
+
+    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,79 @@
+# 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."""
+
+from qiskit.circuit import QuantumCircuit
+from qiskit._accelerate.converters import dag_to_circuit as dag_to_circuit_rs
+
+
+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::
+           :alt: Circuit diagram output by the previous code.
+           :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])
+           dag = circuit_to_dag(circ)
+           circuit = dag_to_circuit(dag)
+           circuit.draw('mpl')
+    """
+
+    name = dag.name or None
+
+    circuit_data = dag_to_circuit_rs(dag, copy_operations)
+    circuit = QuantumCircuit(
+        dag.qubits,
+        dag.clbits,
+        *dag.qregs.values(),
+        *dag.cregs.values(),
+        name=name,
+        global_phase=dag.global_phase,
+        inputs=dag.iter_input_vars(),
+        captures=dag.iter_captures(),
+    )
+    for var in dag.iter_declared_vars():
+        circuit.add_uninitialized_var(var)
+    for stretch in dag.iter_declared_stretches():
+        circuit.add_stretch(stretch)
+    circuit.metadata = dag.metadata or {}
+    circuit._data = circuit_data
+    circuit._duration = dag._duration
+    circuit._unit = dag._unit
+    return circuit

qiskit/converters/dag_to_dagdependency.py

@@ -0,0 +1,54 @@
+# 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
+
+    return dagdependency

qiskit/converters/dag_to_dagdependency_v2.py

@@ -0,0 +1,43 @@
+# 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_v2 import _DAGDependencyV2
+
+
+def _dag_to_dagdependency_v2(dag):
+    """Build a ``_DAGDependencyV2`` object from a ``DAGCircuit``.
+
+    Args:
+        dag (DAGCircuit): the input dag.
+
+    Return:
+        _DAGDependencyV2: the DAG representing the input circuit as a dag dependency.
+    """
+    dagdependency = _DAGDependencyV2()
+    dagdependency.name = dag.name
+    dagdependency.metadata = dag.metadata
+    dagdependency.global_phase = dag.global_phase
+
+    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():
+        dagdependency.apply_operation_back(node.op.copy(), node.qargs, node.cargs)
+
+    return dagdependency

qiskit/converters/dagdependency_to_circuit.py

@@ -0,0 +1,40 @@
+# 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
+
+    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,48 @@
+# 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
+
+    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