qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/_utils.py

@@ -0,0 +1,170 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+"""
+This module contains utility functions for circuits.
+"""
+
+import numpy
+from qiskit.exceptions import QiskitError
+from qiskit.circuit.exceptions import CircuitError
+from .parametervector import ParameterVectorElement
+
+
+def sort_parameters(parameters):
+    """Sort an iterable of :class:`.Parameter` instances into a canonical order, respecting the
+    ordering relationships between elements of :class:`.ParameterVector`\\ s."""
+
+    def key(parameter):
+        if isinstance(parameter, ParameterVectorElement):
+            return (parameter.vector.name, parameter.index)
+        return (parameter.name,)
+
+    return sorted(parameters, key=key)
+
+
+def _compute_control_matrix(base_mat, num_ctrl_qubits, ctrl_state=None):
+    r"""
+    Compute the controlled version of the input matrix with qiskit ordering.
+    This function computes the controlled unitary with :math:`n` control qubits
+    and :math:`m` target qubits,
+
+    .. math::
+
+        V_n^j(U_{2^m}) = (U_{2^m} \otimes |j\rangle\!\langle j|) +
+                         (I_{2^m} \otimes (I_{2^n} - |j\rangle\!\langle j|)).
+
+    where :math:`|j\rangle \in \mathcal{H}^{2^n}` is the control state.
+
+    Args:
+        base_mat (ndarray): unitary to be controlled
+        num_ctrl_qubits (int): number of controls for new unitary
+        ctrl_state (int or str or None): The control state in decimal or as
+            a bitstring (e.g. '111'). If None, use 2**num_ctrl_qubits-1.
+
+    Returns:
+        ndarray: controlled version of base matrix.
+
+    Raises:
+        QiskitError: unrecognized mode or invalid ctrl_state
+    """
+    num_target = int(numpy.log2(base_mat.shape[0]))
+    ctrl_dim = 2**num_ctrl_qubits
+    ctrl_grnd = numpy.repeat([[1], [0]], [1, ctrl_dim - 1])
+    if ctrl_state is None:
+        ctrl_state = ctrl_dim - 1
+    elif isinstance(ctrl_state, str):
+        ctrl_state = int(ctrl_state, 2)
+    if isinstance(ctrl_state, int):
+        if not 0 <= ctrl_state < ctrl_dim:
+            raise QiskitError("Invalid control state value specified.")
+    else:
+        raise QiskitError("Invalid control state type specified.")
+    ctrl_proj = numpy.diag(numpy.roll(ctrl_grnd, ctrl_state))
+    full_mat = numpy.kron(numpy.eye(2**num_target), numpy.eye(ctrl_dim) - ctrl_proj) + numpy.kron(
+        base_mat, ctrl_proj
+    )
+    return full_mat
+
+
+def _ctrl_state_to_int(ctrl_state, num_ctrl_qubits):
+    """Convert ctrl_state to int.
+
+    Args:
+        ctrl_state (None, str, int): ctrl_state. If None, set to 2**num_ctrl_qubits-1.
+            If str, convert to int. If int, pass.
+        num_ctrl_qubits (int): The number of control qubits.
+
+    Return:
+        int: ctrl_state
+
+    Raises:
+        CircuitError: invalid ctrl_state
+    """
+    ctrl_state_std = None
+    if isinstance(ctrl_state, str):
+        try:
+            assert len(ctrl_state) == num_ctrl_qubits
+            ctrl_state = int(ctrl_state, 2)
+        except ValueError as ex:
+            raise CircuitError("invalid control bit string: " + ctrl_state) from ex
+        except AssertionError as ex:
+            raise CircuitError("invalid control bit string: length != num_ctrl_qubits") from ex
+    if isinstance(ctrl_state, int):
+        if 0 <= ctrl_state < 2**num_ctrl_qubits:
+            ctrl_state_std = ctrl_state
+        else:
+            raise CircuitError("invalid control state specification")
+    elif ctrl_state is None:
+        ctrl_state_std = 2**num_ctrl_qubits - 1
+    else:
+        raise CircuitError(f"invalid control state specification: {repr(ctrl_state)}")
+    return ctrl_state_std
+
+
+def with_gate_array(base_array):
+    """Class decorator that adds an ``__array__`` method to a :class:`.Gate` instance that returns a
+    singleton nonwritable view onto the complex matrix described by ``base_array``."""
+    nonwritable = numpy.array(base_array, dtype=numpy.complex128)
+    nonwritable.setflags(write=False)
+
+    def __array__(_self, dtype=None):
+        return numpy.asarray(nonwritable, dtype=dtype)
+
+    def decorator(cls):
+        if hasattr(cls, "__array__"):
+            raise RuntimeError("Refusing to decorate a class that already has '__array__' defined.")
+        cls.__array__ = __array__
+        return cls
+
+    return decorator
+
+
+def with_controlled_gate_array(base_array, num_ctrl_qubits, cached_states=None):
+    """Class decorator that adds an ``__array__`` method to a :class:`.ControlledGate` instance that
+    returns singleton nonwritable views onto a relevant precomputed complex matrix for the given
+    control state.
+
+    If ``cached_states`` is not given, then all possible control states are precomputed.  If it is
+    given, it should be an iterable of integers, and only these control states will be cached."""
+    base = numpy.asarray(base_array, dtype=numpy.complex128)
+
+    def matrix_for_control_state(state):
+        out = numpy.asarray(
+            _compute_control_matrix(base, num_ctrl_qubits, state),
+            dtype=numpy.complex128,
+        )
+        out.setflags(write=False)
+        return out
+
+    if cached_states is None:
+        nonwritables = [matrix_for_control_state(state) for state in range(2**num_ctrl_qubits)]
+
+        def __array__(self, dtype=None):
+            return numpy.asarray(nonwritables[self.ctrl_state], dtype=dtype)
+
+    else:
+        nonwritables = {state: matrix_for_control_state(state) for state in cached_states}
+
+        def __array__(self, dtype=None):
+            if (out := nonwritables.get(self.ctrl_state)) is not None:
+                return numpy.asarray(out, dtype=dtype)
+            return numpy.asarray(
+                _compute_control_matrix(base, num_ctrl_qubits, self.ctrl_state), dtype=dtype
+            )
+
+    def decorator(cls):
+        if hasattr(cls, "__array__"):
+            raise RuntimeError("Refusing to decorate a class that already has '__array__' defined.")
+        cls.__array__ = __array__
+        return cls
+
+    return decorator

qiskit/circuit/add_control.py

@@ -0,0 +1,274 @@
+# 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.
+
+"""Add control to operation if supported."""
+from __future__ import annotations
+
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.circuit.library import UnitaryGate
+from qiskit.transpiler import PassManager
+from qiskit.transpiler.passes.basis import BasisTranslator, UnrollCustomDefinitions
+from qiskit.circuit.equivalence_library import SessionEquivalenceLibrary as sel
+
+from . import ControlledGate, Gate, QuantumRegister, QuantumCircuit
+from ._utils import _ctrl_state_to_int
+
+
+def add_control(
+    operation: Gate | ControlledGate,
+    num_ctrl_qubits: int,
+    label: str | None,
+    ctrl_state: str | int | None,
+) -> ControlledGate:
+    """For standard gates, if the controlled version already exists in the
+    library, it will be returned (e.g. XGate.control() = CnotGate().
+
+    For more generic gates, this method implements the controlled
+    version by first decomposing into the ['u1', 'u3', 'cx'] basis, then
+    controlling each gate in the decomposition.
+
+    Open controls are implemented by conjugating the control line with
+    X gates. Adds num_ctrl_qubits controls to operation.
+
+    This function is meant to be called from the
+    :method:`qiskit.circuit.gate.Gate.control()` method.
+
+    Args:
+        operation: The operation to be controlled.
+        num_ctrl_qubits: The number of controls to add to gate.
+        label: An optional gate label.
+        ctrl_state: The control state in decimal or as a bitstring
+            (e.g. '111'). If specified as a bitstring the length
+            must equal num_ctrl_qubits, MSB on left. If None, use
+            2**num_ctrl_qubits-1.
+
+    Returns:
+        Controlled version of gate.
+
+    """
+    if isinstance(operation, UnitaryGate):
+        # attempt decomposition
+        operation._define()
+    cgate = control(operation, num_ctrl_qubits=num_ctrl_qubits, label=label, ctrl_state=ctrl_state)
+    if operation.label is not None:
+        cgate.base_gate = cgate.base_gate.to_mutable()
+        cgate.base_gate.label = operation.label
+    return cgate
+
+
+def control(
+    operation: Gate | ControlledGate,
+    num_ctrl_qubits: int | None = 1,
+    label: str | None = None,
+    ctrl_state: str | int | None = None,
+) -> ControlledGate:
+    """Return controlled version of gate using controlled rotations. This function
+    first checks the name of the operation to see if it knows of a method from which
+    to generate a controlled version. Currently these are `x`, `rx`, `ry`, and `rz`.
+    If a method is not directly known, it calls the unroller to convert to `u1`, `u3`,
+    and `cx` gates.
+
+    Args:
+        operation: The gate used to create the ControlledGate.
+        num_ctrl_qubits: The number of controls to add to gate (default=1).
+        label: An optional gate label.
+        ctrl_state: The control state in decimal or as
+            a bitstring (e.g. '111'). If specified as a bitstring the length
+            must equal num_ctrl_qubits, MSB on left. If None, use
+            2**num_ctrl_qubits-1.
+
+    Returns:
+        Controlled version of gate.
+
+    Raises:
+        CircuitError: gate contains non-gate in definition
+    """
+    from math import pi
+
+    # pylint: disable=cyclic-import
+    from qiskit.circuit import controlledgate
+
+    ctrl_state = _ctrl_state_to_int(ctrl_state, num_ctrl_qubits)
+
+    q_control = QuantumRegister(num_ctrl_qubits, name="control")
+    q_target = QuantumRegister(operation.num_qubits, name="target")
+    q_ancillae = None  # TODO: add
+    controlled_circ = QuantumCircuit(q_control, q_target, name=f"c_{operation.name}")
+    if isinstance(operation, controlledgate.ControlledGate):
+        original_ctrl_state = operation.ctrl_state
+    global_phase = 0
+    if operation.name == "x" or (
+        isinstance(operation, controlledgate.ControlledGate) and operation.base_gate.name == "x"
+    ):
+        controlled_circ.mcx(q_control[:] + q_target[:-1], q_target[-1], q_ancillae)
+        if operation.definition is not None and operation.definition.global_phase:
+            global_phase += operation.definition.global_phase
+    else:
+        basis = ["p", "u", "x", "z", "rx", "ry", "rz", "cx"]
+        if isinstance(operation, controlledgate.ControlledGate):
+            operation = operation.to_mutable()
+            operation.ctrl_state = None
+        unrolled_gate = _unroll_gate(operation, basis_gates=basis)
+        if unrolled_gate.definition.global_phase:
+            global_phase += unrolled_gate.definition.global_phase
+
+        definition = unrolled_gate.definition
+        bit_indices = {
+            bit: index
+            for bits in [definition.qubits, definition.clbits]
+            for index, bit in enumerate(bits)
+        }
+
+        for instruction in definition.data:
+            gate, qargs = instruction.operation, instruction.qubits
+            if gate.name == "x":
+                controlled_circ.mcx(q_control, q_target[bit_indices[qargs[0]]], q_ancillae)
+            elif gate.name == "rx":
+                controlled_circ.mcrx(
+                    gate.definition.data[0].operation.params[0],
+                    q_control,
+                    q_target[bit_indices[qargs[0]]],
+                    use_basis_gates=True,
+                )
+            elif gate.name == "ry":
+                controlled_circ.mcry(
+                    gate.definition.data[0].operation.params[0],
+                    q_control,
+                    q_target[bit_indices[qargs[0]]],
+                    q_ancillae,
+                    mode="noancilla",
+                    use_basis_gates=True,
+                )
+            elif gate.name == "rz":
+                controlled_circ.mcrz(
+                    gate.definition.data[0].operation.params[0],
+                    q_control,
+                    q_target[bit_indices[qargs[0]]],
+                    use_basis_gates=True,
+                )
+                continue
+            elif gate.name == "p":
+                from qiskit.circuit.library import MCPhaseGate
+
+                controlled_circ.append(
+                    MCPhaseGate(gate.params[0], num_ctrl_qubits),
+                    q_control[:] + [q_target[bit_indices[qargs[0]]]],
+                )
+            elif gate.name == "cx":
+                controlled_circ.mcx(
+                    q_control[:] + [q_target[bit_indices[qargs[0]]]],
+                    q_target[bit_indices[qargs[1]]],
+                    q_ancillae,
+                )
+            elif gate.name == "u":
+                theta, phi, lamb = gate.params
+                if num_ctrl_qubits == 1:
+                    if theta == 0 and phi == 0:
+                        controlled_circ.cp(lamb, q_control[0], q_target[bit_indices[qargs[0]]])
+                    else:
+                        controlled_circ.cu(
+                            theta, phi, lamb, 0, q_control[0], q_target[bit_indices[qargs[0]]]
+                        )
+                else:
+                    if phi == -pi / 2 and lamb == pi / 2:
+                        controlled_circ.mcrx(
+                            theta, q_control, q_target[bit_indices[qargs[0]]], use_basis_gates=True
+                        )
+                    elif phi == 0 and lamb == 0:
+                        controlled_circ.mcry(
+                            theta,
+                            q_control,
+                            q_target[bit_indices[qargs[0]]],
+                            q_ancillae,
+                            use_basis_gates=True,
+                        )
+                    elif theta == 0 and phi == 0:
+                        controlled_circ.mcp(lamb, q_control, q_target[bit_indices[qargs[0]]])
+                    else:
+                        controlled_circ.mcp(lamb, q_control, q_target[bit_indices[qargs[0]]])
+                        controlled_circ.mcry(
+                            theta,
+                            q_control,
+                            q_target[bit_indices[qargs[0]]],
+                            q_ancillae,
+                            use_basis_gates=True,
+                        )
+                        controlled_circ.mcp(phi, q_control, q_target[bit_indices[qargs[0]]])
+            elif gate.name == "z":
+                controlled_circ.h(q_target[bit_indices[qargs[0]]])
+                controlled_circ.mcx(q_control, q_target[bit_indices[qargs[0]]], q_ancillae)
+                controlled_circ.h(q_target[bit_indices[qargs[0]]])
+            else:
+                raise CircuitError(f"gate contains non-controllable instructions: {gate.name}")
+            if gate.definition is not None and gate.definition.global_phase:
+                global_phase += gate.definition.global_phase
+    # apply controlled global phase
+    if global_phase:
+        if len(q_control) < 2:
+            controlled_circ.p(global_phase, q_control)
+        else:
+            controlled_circ.mcp(global_phase, q_control[:-1], q_control[-1])
+    if isinstance(operation, controlledgate.ControlledGate):
+        operation.ctrl_state = original_ctrl_state
+        new_num_ctrl_qubits = num_ctrl_qubits + operation.num_ctrl_qubits
+        new_ctrl_state = operation.ctrl_state << num_ctrl_qubits | ctrl_state
+        base_name = operation.base_gate.name
+        base_gate = operation.base_gate
+    else:
+        new_num_ctrl_qubits = num_ctrl_qubits
+        new_ctrl_state = ctrl_state
+        base_name = operation.name
+        base_gate = operation
+    # In order to maintain some backward compatibility with gate names this
+    # uses a naming convention where if the number of controls is <=2 the gate
+    # is named like "cc<base_gate.name>", else it is named like
+    # "c<num_ctrl_qubits><base_name>".
+    if new_num_ctrl_qubits > 2:
+        ctrl_substr = f"c{new_num_ctrl_qubits:d}"
+    else:
+        ctrl_substr = ("{0}" * new_num_ctrl_qubits).format("c")
+    new_name = f"{ctrl_substr}{base_name}"
+    cgate = controlledgate.ControlledGate(
+        new_name,
+        controlled_circ.num_qubits,
+        operation.params,
+        label=label,
+        num_ctrl_qubits=new_num_ctrl_qubits,
+        definition=controlled_circ,
+        ctrl_state=new_ctrl_state,
+        base_gate=base_gate,
+    )
+    return cgate
+
+
+def _gate_to_circuit(operation):
+    """Converts a gate instance to a QuantumCircuit"""
+    if hasattr(operation, "definition") and operation.definition is not None:
+        return operation.definition
+    else:
+        qr = QuantumRegister(operation.num_qubits)
+        qc = QuantumCircuit(qr, name=operation.name)
+        qc.append(operation, qr)
+        return qc
+
+
+def _unroll_gate(operation, basis_gates):
+    """Unrolls a gate, possibly composite, to the target basis"""
+    circ = _gate_to_circuit(operation)
+    pm = PassManager(
+        [
+            UnrollCustomDefinitions(sel, basis_gates=basis_gates),
+            BasisTranslator(sel, target_basis=basis_gates),
+        ]
+    )
+    opqc = pm.run(circ)
+    return opqc.to_gate()

qiskit/circuit/annotated_operation.py

@@ -0,0 +1,188 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2023.
+#
+# 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.
+
+"""Annotated Operations."""
+
+import dataclasses
+from typing import Union, List
+
+from qiskit.circuit.operation import Operation
+from qiskit.circuit._utils import _compute_control_matrix, _ctrl_state_to_int
+from qiskit.circuit.exceptions import CircuitError
+
+
+class Modifier:
+    """The base class that all modifiers of :class:`~.AnnotatedOperation` should
+    inherit from."""
+
+    pass
+
+
+@dataclasses.dataclass
+class InverseModifier(Modifier):
+    """Inverse modifier: specifies that the operation is inverted."""
+
+    pass
+
+
+@dataclasses.dataclass
+class ControlModifier(Modifier):
+    """Control modifier: specifies that the operation is controlled by ``num_ctrl_qubits``
+    and has control state ``ctrl_state``."""
+
+    num_ctrl_qubits: int = 0
+    ctrl_state: Union[int, str, None] = None
+
+    def __init__(self, num_ctrl_qubits: int = 0, ctrl_state: Union[int, str, None] = None):
+        self.num_ctrl_qubits = num_ctrl_qubits
+        self.ctrl_state = _ctrl_state_to_int(ctrl_state, num_ctrl_qubits)
+
+
+@dataclasses.dataclass
+class PowerModifier(Modifier):
+    """Power modifier: specifies that the operation is raised to the power ``power``."""
+
+    power: float
+
+
+class AnnotatedOperation(Operation):
+    """Annotated operation."""
+
+    def __init__(self, base_op: Operation, modifiers: Union[Modifier, List[Modifier]]):
+        """
+        Create a new AnnotatedOperation.
+
+        An "annotated operation" allows to add a list of modifiers to the
+        "base" operation. For now, the only supported modifiers are of
+        types :class:`~.InverseModifier`, :class:`~.ControlModifier` and
+        :class:`~.PowerModifier`.
+
+        An annotated operation can be viewed as an extension of
+        :class:`~.ControlledGate` (which also allows adding control to the
+        base operation). However, an important difference is that the
+        circuit definition of an annotated operation is not constructed when
+        the operation is declared, and instead happens during transpilation,
+        specifically during the :class:`~.HighLevelSynthesis` transpiler pass.
+
+        An annotated operation can be also viewed as a "higher-level"
+        or "more abstract" object that can be added to a quantum circuit.
+        This enables writing transpiler optimization passes that make use of
+        this higher-level representation, for instance removing a gate
+        that is immediately followed by its inverse.
+
+        Args:
+            base_op: base operation being modified
+            modifiers: ordered list of modifiers. Supported modifiers include
+                ``InverseModifier``, ``ControlModifier`` and ``PowerModifier``.
+
+        Examples::
+
+            op1 = AnnotatedOperation(SGate(), [InverseModifier(), ControlModifier(2)])
+
+            op2_inner = AnnotatedGate(SGate(), InverseModifier())
+            op2 = AnnotatedGate(op2_inner, ControlModifier(2))
+
+        Both op1 and op2 are semantically equivalent to an ``SGate()`` which is first
+        inverted and then controlled by 2 qubits.
+        """
+        self.base_op = base_op
+        self.modifiers = modifiers if isinstance(modifiers, List) else [modifiers]
+
+    @property
+    def name(self):
+        """Unique string identifier for operation type."""
+        return "annotated"
+
+    @property
+    def num_qubits(self):
+        """Number of qubits."""
+        num_ctrl_qubits = 0
+        for modifier in self.modifiers:
+            if isinstance(modifier, ControlModifier):
+                num_ctrl_qubits += modifier.num_ctrl_qubits
+
+        return num_ctrl_qubits + self.base_op.num_qubits
+
+    @property
+    def num_clbits(self):
+        """Number of classical bits."""
+        return self.base_op.num_clbits
+
+    def __eq__(self, other) -> bool:
+        """Checks if two AnnotatedOperations are equal."""
+        return (
+            isinstance(other, AnnotatedOperation)
+            and self.modifiers == other.modifiers
+            and self.base_op == other.base_op
+        )
+
+    def copy(self) -> "AnnotatedOperation":
+        """Return a copy of the :class:`~.AnnotatedOperation`."""
+        return AnnotatedOperation(base_op=self.base_op, modifiers=self.modifiers.copy())
+
+    def to_matrix(self):
+        """Return a matrix representation (allowing to construct Operator)."""
+        from qiskit.quantum_info.operators import Operator  # pylint: disable=cyclic-import
+
+        operator = Operator(self.base_op)
+
+        for modifier in self.modifiers:
+            if isinstance(modifier, InverseModifier):
+                operator = operator.power(-1)
+            elif isinstance(modifier, ControlModifier):
+                operator = Operator(
+                    _compute_control_matrix(
+                        operator.data, modifier.num_ctrl_qubits, modifier.ctrl_state
+                    )
+                )
+            elif isinstance(modifier, PowerModifier):
+                operator = operator.power(modifier.power)
+            else:
+                raise CircuitError(f"Unknown modifier {modifier}.")
+        return operator
+
+
+def _canonicalize_modifiers(modifiers):
+    """
+    Returns the canonical representative of the modifier list. This is possible
+    since all the modifiers commute; also note that InverseModifier is a special
+    case of PowerModifier. The current solution is to compute the total number
+    of control qubits / control state and the total power. The InverseModifier
+    will be present if total power is negative, whereas the power modifier will
+    be present only with positive powers different from 1.
+    """
+    power = 1
+    num_ctrl_qubits = 0
+    ctrl_state = 0
+
+    for modifier in modifiers:
+        if isinstance(modifier, InverseModifier):
+            power *= -1
+        elif isinstance(modifier, ControlModifier):
+            num_ctrl_qubits += modifier.num_ctrl_qubits
+            ctrl_state = (ctrl_state << modifier.num_ctrl_qubits) | modifier.ctrl_state
+        elif isinstance(modifier, PowerModifier):
+            power *= modifier.power
+        else:
+            raise CircuitError(f"Unknown modifier {modifier}.")
+
+    canonical_modifiers = []
+    if power < 0:
+        canonical_modifiers.append(InverseModifier())
+        power *= -1
+
+    if power != 1:
+        canonical_modifiers.append(PowerModifier(power))
+    if num_ctrl_qubits > 0:
+        canonical_modifiers.append(ControlModifier(num_ctrl_qubits, ctrl_state))
+
+    return canonical_modifiers

qiskit/circuit/barrier.py

@@ -0,0 +1,51 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017.
+#
+# 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.
+
+"""Barrier instruction.
+
+Can be applied to a :class:`~qiskit.circuit.QuantumCircuit`
+with the :meth:`~qiskit.circuit.QuantumCircuit.barrier` method.
+"""
+
+from qiskit.exceptions import QiskitError
+from .instruction import Instruction
+
+
+class Barrier(Instruction):
+    """Barrier instruction.
+
+    A barrier is a visual indicator of the grouping of a circuit section.
+    It also acts as a directive for circuit compilation to separate pieces
+    of a circuit so that any optimizations or re-writes are constrained
+    to only act between barriers."""
+
+    _directive = True
+
+    def __init__(self, num_qubits, label=None):
+        """Create new barrier instruction.
+
+        Args:
+            num_qubits (int): the number of qubits for the barrier type [Default: 0].
+            label (str): the barrier label
+
+        Raises:
+            TypeError: if barrier label is invalid.
+        """
+        self._label = label
+        super().__init__("barrier", num_qubits, 0, [], label=label)
+
+    def inverse(self):
+        """Special case. Return self."""
+        return Barrier(self.num_qubits)
+
+    def c_if(self, classical, val):
+        raise QiskitError("Barriers are compiler directives and cannot be conditional.")