qiskit 1.0.0b1__cp38-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl

qiskit/circuit/library/grover_operator.py

@@ -0,0 +1,311 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""The Grover operator."""
+
+from __future__ import annotations
+from typing import List, Optional, Union
+import numpy
+
+from qiskit.circuit import QuantumCircuit, QuantumRegister, AncillaRegister
+from qiskit.exceptions import QiskitError
+from qiskit.quantum_info import Statevector, Operator, DensityMatrix
+from .standard_gates import MCXGate
+
+
+class GroverOperator(QuantumCircuit):
+    r"""The Grover operator.
+
+    Grover's search algorithm [1, 2] consists of repeated applications of the so-called
+    Grover operator used to amplify the amplitudes of the desired output states.
+    This operator, :math:`\mathcal{Q}`, consists of the phase oracle, :math:`\mathcal{S}_f`,
+    zero phase-shift or zero reflection, :math:`\mathcal{S}_0`, and an
+    input state preparation :math:`\mathcal{A}`:
+
+    .. math::
+        \mathcal{Q} = \mathcal{A} \mathcal{S}_0 \mathcal{A}^\dagger \mathcal{S}_f
+
+    In the standard Grover search we have :math:`\mathcal{A} = H^{\otimes n}`:
+
+    .. math::
+        \mathcal{Q} = H^{\otimes n} \mathcal{S}_0 H^{\otimes n} \mathcal{S}_f
+                    = D \mathcal{S_f}
+
+    The operation :math:`D = H^{\otimes n} \mathcal{S}_0 H^{\otimes n}` is also referred to as
+    diffusion operator. In this formulation we can see that Grover's operator consists of two
+    steps: first, the phase oracle multiplies the good states by -1 (with :math:`\mathcal{S}_f`)
+    and then the whole state is reflected around the mean (with :math:`D`).
+
+    This class allows setting a different state preparation, as in quantum amplitude
+    amplification (a generalization of Grover's algorithm), :math:`\mathcal{A}` might not be
+    a layer of Hardamard gates [3].
+
+    The action of the phase oracle :math:`\mathcal{S}_f` is defined as
+
+    .. math::
+        \mathcal{S}_f: |x\rangle \mapsto (-1)^{f(x)}|x\rangle
+
+    where :math:`f(x) = 1` if :math:`x` is a good state and 0 otherwise. To highlight the fact
+    that this oracle flips the phase of the good states and does not flip the state of a result
+    qubit, we call :math:`\mathcal{S}_f` a phase oracle.
+
+    Note that you can easily construct a phase oracle from a bitflip oracle by sandwiching the
+    controlled X gate on the result qubit by a X and H gate. For instance
+
+    .. parsed-literal::
+
+        Bitflip oracle     Phaseflip oracle
+        q_0: ──■──         q_0: ────────────■────────────
+             ┌─┴─┐              ┌───┐┌───┐┌─┴─┐┌───┐┌───┐
+        out: ┤ X ├         out: ┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├
+             └───┘              └───┘└───┘└───┘└───┘└───┘
+
+    There is some flexibility in defining the oracle and :math:`\mathcal{A}` operator. Before the
+    Grover operator is applied in Grover's algorithm, the qubits are first prepared with one
+    application of the :math:`\mathcal{A}` operator (or Hadamard gates in the standard formulation).
+    Thus, we always have operation of the form
+    :math:`\mathcal{A} \mathcal{S}_f \mathcal{A}^\dagger`. Therefore it is possible to move
+    bitflip logic into :math:`\mathcal{A}` and leaving the oracle only to do phaseflips via Z gates
+    based on the bitflips. One possible use-case for this are oracles that do not uncompute the
+    state qubits.
+
+    The zero reflection :math:`\mathcal{S}_0` is usually defined as
+
+    .. math::
+        \mathcal{S}_0 = 2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n
+
+    where :math:`\mathbb{I}_n` is the identity on :math:`n` qubits.
+    By default, this class implements the negative version
+    :math:`2 |0\rangle^{\otimes n} \langle 0|^{\otimes n} - \mathbb{I}_n`, since this can simply
+    be implemented with a multi-controlled Z sandwiched by X gates on the target qubit and the
+    introduced global phase does not matter for Grover's algorithm.
+
+    Examples:
+        >>> from qiskit.circuit import QuantumCircuit
+        >>> from qiskit.circuit.library import GroverOperator
+        >>> oracle = QuantumCircuit(2)
+        >>> oracle.z(0)  # good state = first qubit is |1>
+        >>> grover_op = GroverOperator(oracle, insert_barriers=True)
+        >>> grover_op.decompose().draw()
+                 ┌───┐ ░ ┌───┐ ░ ┌───┐          ┌───┐      ░ ┌───┐
+        state_0: ┤ Z ├─░─┤ H ├─░─┤ X ├───────■──┤ X ├──────░─┤ H ├
+                 └───┘ ░ ├───┤ ░ ├───┤┌───┐┌─┴─┐├───┤┌───┐ ░ ├───┤
+        state_1: ──────░─┤ H ├─░─┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├─░─┤ H ├
+                       ░ └───┘ ░ └───┘└───┘└───┘└───┘└───┘ ░ └───┘
+
+        >>> oracle = QuantumCircuit(1)
+        >>> oracle.z(0)  # the qubit state |1> is the good state
+        >>> state_preparation = QuantumCircuit(1)
+        >>> state_preparation.ry(0.2, 0)  # non-uniform state preparation
+        >>> grover_op = GroverOperator(oracle, state_preparation)
+        >>> grover_op.decompose().draw()
+                 ┌───┐┌──────────┐┌───┐┌───┐┌───┐┌─────────┐
+        state_0: ┤ Z ├┤ RY(-0.2) ├┤ X ├┤ Z ├┤ X ├┤ RY(0.2) ├
+                 └───┘└──────────┘└───┘└───┘└───┘└─────────┘
+
+        >>> oracle = QuantumCircuit(4)
+        >>> oracle.z(3)
+        >>> reflection_qubits = [0, 3]
+        >>> state_preparation = QuantumCircuit(4)
+        >>> state_preparation.cry(0.1, 0, 3)
+        >>> state_preparation.ry(0.5, 3)
+        >>> grover_op = GroverOperator(oracle, state_preparation,
+        ... reflection_qubits=reflection_qubits)
+        >>> grover_op.decompose().draw()
+                                              ┌───┐          ┌───┐
+        state_0: ──────────────────────■──────┤ X ├───────■──┤ X ├──────────■────────────────
+                                       │      └───┘       │  └───┘          │
+        state_1: ──────────────────────┼──────────────────┼─────────────────┼────────────────
+                                       │                  │                 │
+        state_2: ──────────────────────┼──────────────────┼─────────────────┼────────────────
+                 ┌───┐┌──────────┐┌────┴─────┐┌───┐┌───┐┌─┴─┐┌───┐┌───┐┌────┴────┐┌─────────┐
+        state_3: ┤ Z ├┤ RY(-0.5) ├┤ RY(-0.1) ├┤ X ├┤ H ├┤ X ├┤ H ├┤ X ├┤ RY(0.1) ├┤ RY(0.5) ├
+                 └───┘└──────────┘└──────────┘└───┘└───┘└───┘└───┘└───┘└─────────┘└─────────┘
+
+        >>> mark_state = Statevector.from_label('011')
+        >>> diffuse_operator = 2 * DensityMatrix.from_label('000') - Operator.from_label('III')
+        >>> grover_op = GroverOperator(oracle=mark_state, zero_reflection=diffuse_operator)
+        >>> grover_op.decompose().draw(fold=70)
+                 ┌─────────────────┐      ┌───┐                          »
+        state_0: ┤0                ├──────┤ H ├──────────────────────────»
+                 │                 │┌─────┴───┴─────┐     ┌───┐          »
+        state_1: ┤1 UCRZ(0,pi,0,0) ├┤0              ├─────┤ H ├──────────»
+                 │                 ││  UCRZ(pi/2,0) │┌────┴───┴────┐┌───┐»
+        state_2: ┤2                ├┤1              ├┤ UCRZ(-pi/4) ├┤ H ├»
+                 └─────────────────┘└───────────────┘└─────────────┘└───┘»
+        «         ┌─────────────────┐      ┌───┐
+        «state_0: ┤0                ├──────┤ H ├─────────────────────────
+        «         │                 │┌─────┴───┴─────┐    ┌───┐
+        «state_1: ┤1 UCRZ(pi,0,0,0) ├┤0              ├────┤ H ├──────────
+        «         │                 ││  UCRZ(pi/2,0) │┌───┴───┴────┐┌───┐
+        «state_2: ┤2                ├┤1              ├┤ UCRZ(pi/4) ├┤ H ├
+        «         └─────────────────┘└───────────────┘└────────────┘└───┘
+
+    References:
+        [1]: L. K. Grover (1996), A fast quantum mechanical algorithm for database search,
+            `arXiv:quant-ph/9605043 <https://arxiv.org/abs/quant-ph/9605043>`_.
+        [2]: I. Chuang & M. Nielsen, Quantum Computation and Quantum Information,
+            Cambridge: Cambridge University Press, 2000. Chapter 6.1.2.
+        [3]: Brassard, G., Hoyer, P., Mosca, M., & Tapp, A. (2000).
+            Quantum Amplitude Amplification and Estimation.
+            `arXiv:quant-ph/0005055 <http://arxiv.org/abs/quant-ph/0005055>`_.
+    """
+
+    def __init__(
+        self,
+        oracle: Union[QuantumCircuit, Statevector],
+        state_preparation: Optional[QuantumCircuit] = None,
+        zero_reflection: Optional[Union[QuantumCircuit, DensityMatrix, Operator]] = None,
+        reflection_qubits: Optional[List[int]] = None,
+        insert_barriers: bool = False,
+        mcx_mode: str = "noancilla",
+        name: str = "Q",
+    ) -> None:
+        r"""
+        Args:
+            oracle: The phase oracle implementing a reflection about the bad state. Note that this
+                is not a bitflip oracle, see the docstring for more information.
+            state_preparation: The operator preparing the good and bad state.
+                For Grover's algorithm, this is a n-qubit Hadamard gate and for amplitude
+                amplification or estimation the operator :math:`\mathcal{A}`.
+            zero_reflection: The reflection about the zero state, :math:`\mathcal{S}_0`.
+            reflection_qubits: Qubits on which the zero reflection acts on.
+            insert_barriers: Whether barriers should be inserted between the reflections and A.
+            mcx_mode: The mode to use for building the default zero reflection.
+            name: The name of the circuit.
+        """
+        super().__init__(name=name)
+
+        # store inputs
+        if isinstance(oracle, Statevector):
+            from qiskit.circuit.library import Diagonal  # pylint: disable=cyclic-import
+
+            oracle = Diagonal((-1) ** oracle.data)
+        self._oracle = oracle
+
+        if isinstance(zero_reflection, (Operator, DensityMatrix)):
+            from qiskit.circuit.library import Diagonal  # pylint: disable=cyclic-import
+
+            zero_reflection = Diagonal(zero_reflection.data.diagonal())
+        self._zero_reflection = zero_reflection
+
+        self._reflection_qubits = reflection_qubits
+        self._state_preparation = state_preparation
+        self._insert_barriers = insert_barriers
+        self._mcx_mode = mcx_mode
+
+        # build circuit
+        self._build()
+
+    @property
+    def reflection_qubits(self):
+        """Reflection qubits, on which S0 is applied (if S0 is not user-specified)."""
+        if self._reflection_qubits is not None:
+            return self._reflection_qubits
+
+        num_state_qubits = self.oracle.num_qubits - self.oracle.num_ancillas
+        return list(range(num_state_qubits))
+
+    @property
+    def zero_reflection(self) -> QuantumCircuit:
+        """The subcircuit implementing the reflection about 0."""
+        if self._zero_reflection is not None:
+            return self._zero_reflection
+
+        num_state_qubits = self.oracle.num_qubits - self.oracle.num_ancillas
+        return _zero_reflection(num_state_qubits, self.reflection_qubits, self._mcx_mode)
+
+    @property
+    def state_preparation(self) -> QuantumCircuit:
+        """The subcircuit implementing the A operator or Hadamards."""
+        if self._state_preparation is not None:
+            return self._state_preparation
+
+        num_state_qubits = self.oracle.num_qubits - self.oracle.num_ancillas
+        hadamards = QuantumCircuit(num_state_qubits, name="H")
+        # apply Hadamards only on reflection qubits, rest will cancel out
+        hadamards.h(self.reflection_qubits)
+        return hadamards
+
+    @property
+    def oracle(self):
+        """The oracle implementing a reflection about the bad state."""
+        return self._oracle
+
+    def _build(self):
+        num_state_qubits = self.oracle.num_qubits - self.oracle.num_ancillas
+        circuit = QuantumCircuit(QuantumRegister(num_state_qubits, name="state"), name="Q")
+        num_ancillas = numpy.max(
+            [
+                self.oracle.num_ancillas,
+                self.zero_reflection.num_ancillas,
+                self.state_preparation.num_ancillas,
+            ]
+        )
+        if num_ancillas > 0:
+            circuit.add_register(AncillaRegister(num_ancillas, name="ancilla"))
+
+        circuit.compose(self.oracle, list(range(self.oracle.num_qubits)), inplace=True)
+        if self._insert_barriers:
+            circuit.barrier()
+        circuit.compose(
+            self.state_preparation.inverse(),
+            list(range(self.state_preparation.num_qubits)),
+            inplace=True,
+        )
+        if self._insert_barriers:
+            circuit.barrier()
+        circuit.compose(
+            self.zero_reflection, list(range(self.zero_reflection.num_qubits)), inplace=True
+        )
+        if self._insert_barriers:
+            circuit.barrier()
+        circuit.compose(
+            self.state_preparation, list(range(self.state_preparation.num_qubits)), inplace=True
+        )
+
+        # minus sign
+        circuit.global_phase = numpy.pi
+
+        self.add_register(*circuit.qregs)
+        try:
+            circuit_wrapped = circuit.to_gate()
+        except QiskitError:
+            circuit_wrapped = circuit.to_instruction()
+
+        self.compose(circuit_wrapped, qubits=self.qubits, inplace=True)
+
+
+# TODO use the oracle compiler or the bit string oracle
+def _zero_reflection(
+    num_state_qubits: int, qubits: List[int], mcx_mode: Optional[str] = None
+) -> QuantumCircuit:
+    qr_state = QuantumRegister(num_state_qubits, "state")
+    reflection = QuantumCircuit(qr_state, name="S_0")
+
+    num_ancillas = MCXGate.get_num_ancilla_qubits(len(qubits) - 1, mcx_mode)
+    if num_ancillas > 0:
+        qr_ancilla = AncillaRegister(num_ancillas, "ancilla")
+        reflection.add_register(qr_ancilla)
+    else:
+        qr_ancilla = AncillaRegister(0)
+
+    reflection.x(qubits)
+    if len(qubits) == 1:
+        reflection.z(0)  # MCX does not allow 0 control qubits, therefore this is separate
+    else:
+        reflection.h(qubits[-1])
+        reflection.mcx(qubits[:-1], qubits[-1], qr_ancilla[:], mode=mcx_mode)
+        reflection.h(qubits[-1])
+    reflection.x(qubits)
+
+    return reflection

qiskit/circuit/library/hamiltonian_gate.py

@@ -0,0 +1,146 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""
+Gate described by the time evolution of a Hermitian Hamiltonian operator.
+"""
+
+from __future__ import annotations
+import typing
+
+from numbers import Number
+import numpy as np
+
+from qiskit.circuit.gate import Gate
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.parameterexpression import ParameterExpression
+from qiskit.circuit.exceptions import CircuitError
+from qiskit.quantum_info.operators.predicates import matrix_equal
+from qiskit.quantum_info.operators.predicates import is_hermitian_matrix
+from qiskit.utils.deprecation import deprecate_func
+
+from .generalized_gates.unitary import UnitaryGate
+
+if typing.TYPE_CHECKING:
+    from qiskit.quantum_info.operators.base_operator import BaseOperator
+
+
+class HamiltonianGate(Gate):
+    r"""Class for representing evolution by a Hamiltonian operator as a gate.
+
+    This gate resolves to a :class:`~.library.UnitaryGate` as :math:`U(t) = \exp(-i t H)`,
+    which can be decomposed into basis gates if it is 2 qubits or less, or
+    simulated directly in Aer for more qubits.
+    """
+
+    def __init__(
+        self,
+        data: np.ndarray | Gate | BaseOperator,
+        time: float | ParameterExpression,
+        label: str | None = None,
+    ) -> None:
+        """
+        Args:
+            data: A hermitian operator.
+            time: Time evolution parameter.
+            label: Unitary name for backend [Default: None].
+
+        Raises:
+            ValueError: if input data is not an N-qubit unitary operator.
+        """
+        if hasattr(data, "to_matrix"):
+            # If input is Gate subclass or some other class object that has
+            # a to_matrix method this will call that method.
+            data = data.to_matrix()
+        elif hasattr(data, "to_operator"):
+            # If input is a BaseOperator subclass this attempts to convert
+            # the object to an Operator so that we can extract the underlying
+            # numpy matrix from `Operator.data`.
+            data = data.to_operator().data
+        # Convert to np array in case not already an array
+        data = np.array(data, dtype=complex)
+        # Check input is unitary
+        if not is_hermitian_matrix(data):
+            raise ValueError("Input matrix is not Hermitian.")
+        if isinstance(time, Number) and time != np.real(time):
+            raise ValueError("Evolution time is not real.")
+        # Check input is N-qubit matrix
+        input_dim, output_dim = data.shape
+        num_qubits = int(np.log2(input_dim))
+        if input_dim != output_dim or 2**num_qubits != input_dim:
+            raise ValueError("Input matrix is not an N-qubit operator.")
+
+        # Store instruction params
+        super().__init__("hamiltonian", num_qubits, [data, time], label=label)
+
+    def __eq__(self, other):
+        if not isinstance(other, HamiltonianGate):
+            return False
+        if self.label != other.label:
+            return False
+        operators_eq = matrix_equal(self.params[0], other.params[0], ignore_phase=False)
+        times_eq = self.params[1] == other.params[1]
+        return operators_eq and times_eq
+
+    def __array__(self, dtype=None):
+        """Return matrix for the unitary."""
+        # pylint: disable=unused-argument
+        import scipy.linalg
+
+        try:
+            return scipy.linalg.expm(-1j * self.params[0] * float(self.params[1]))
+        except TypeError as ex:
+            raise TypeError(
+                "Unable to generate Unitary matrix for "
+                "unbound t parameter {}".format(self.params[1])
+            ) from ex
+
+    def inverse(self):
+        """Return the adjoint of the unitary."""
+        return self.adjoint()
+
+    def conjugate(self):
+        """Return the conjugate of the Hamiltonian."""
+        return HamiltonianGate(np.conj(self.params[0]), -self.params[1])
+
+    def adjoint(self):
+        """Return the adjoint of the unitary."""
+        return HamiltonianGate(self.params[0], -self.params[1])
+
+    def transpose(self):
+        """Return the transpose of the Hamiltonian."""
+        return HamiltonianGate(np.transpose(self.params[0]), self.params[1])
+
+    def _define(self):
+        """Calculate a subcircuit that implements this unitary."""
+        q = QuantumRegister(self.num_qubits, "q")
+        qc = QuantumCircuit(q, name=self.name)
+        qc._append(UnitaryGate(self.to_matrix()), q[:], [])
+        self.definition = qc
+
+    @deprecate_func(
+        since="0.25.0",
+        package_name="qiskit-terra",
+    )
+    def qasm(self):
+        """Raise an error, as QASM is not defined for the HamiltonianGate."""
+        raise CircuitError("HamiltonianGate has no OpenQASM 2 definition.")
+
+    def validate_parameter(self, parameter):
+        """Hamiltonian parameter has to be an ndarray, operator or float."""
+        if isinstance(parameter, (float, int, np.ndarray)):
+            return parameter
+        elif isinstance(parameter, ParameterExpression) and len(parameter.parameters) == 0:
+            return float(parameter)
+        else:
+            raise CircuitError(f"invalid param type {type(parameter)} for gate {self.name}")

qiskit/circuit/library/hidden_linear_function.py

@@ -0,0 +1,98 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Hidden Linear Function circuit."""
+
+from typing import Union, List
+
+import numpy as np
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+
+class HiddenLinearFunction(QuantumCircuit):
+    r"""Circuit to solve the hidden linear function problem.
+
+    The 2D Hidden Linear Function problem is determined by a 2D adjacency
+    matrix A, where only elements that are nearest-neighbor on a grid have
+    non-zero entries. Each row/column corresponds to one binary variable
+    :math:`x_i`.
+
+    The hidden linear function problem is as follows:
+
+    Consider the quadratic form
+
+    .. math::
+
+        q(x) = \sum_{i,j=1}^{n}{x_i x_j} ~(\mathrm{mod}~ 4)
+
+    and restrict :math:`q(x)` onto the nullspace of A. This results in a linear
+    function.
+
+    .. math::
+
+        2 \sum_{i=1}^{n}{z_i x_i} ~(\mathrm{mod}~ 4)  \forall  x \in \mathrm{Ker}(A)
+
+    and the goal is to recover this linear function (equivalently a vector
+    :math:`[z_0, ..., z_{n-1}]`). There can be multiple solutions.
+
+    In [1] it is shown that the present circuit solves this problem
+    on a quantum computer in constant depth, whereas any corresponding
+    solution on a classical computer would require circuits that grow
+    logarithmically with :math:`n`. Thus this circuit is an example
+    of quantum advantage with shallow circuits.
+
+    **Reference Circuit:**
+
+        .. plot::
+
+           from qiskit.circuit.library import HiddenLinearFunction
+           from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+           A = [[1, 1, 0], [1, 0, 1], [0, 1, 1]]
+           circuit = HiddenLinearFunction(A)
+           _generate_circuit_library_visualization(circuit)
+
+    **Reference:**
+
+    [1] S. Bravyi, D. Gosset, R. Koenig, Quantum Advantage with Shallow Circuits, 2017.
+    `arXiv:1704.00690 <https://arxiv.org/abs/1704.00690>`_
+    """
+
+    def __init__(self, adjacency_matrix: Union[List[List[int]], np.ndarray]) -> None:
+        """Create new HLF circuit.
+
+        Args:
+            adjacency_matrix: a symmetric n-by-n list of 0-1 lists.
+                n will be the number of qubits.
+
+        Raises:
+            CircuitError: If A is not symmetric.
+        """
+        adjacency_matrix = np.asarray(adjacency_matrix)
+        if not np.allclose(adjacency_matrix, adjacency_matrix.transpose()):
+            raise CircuitError("The adjacency matrix must be symmetric.")
+
+        num_qubits = len(adjacency_matrix)
+        circuit = QuantumCircuit(num_qubits, name="hlf: %s" % adjacency_matrix)
+
+        circuit.h(range(num_qubits))
+        for i in range(num_qubits):
+            for j in range(i + 1, num_qubits):
+                if adjacency_matrix[i][j]:
+                    circuit.cz(i, j)
+        for i in range(num_qubits):
+            if adjacency_matrix[i][i]:
+                circuit.s(i)
+        circuit.h(range(num_qubits))
+
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/iqp.py

@@ -0,0 +1,96 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""Instantaneous quantum polynomial circuit."""
+
+from __future__ import annotations
+
+import numpy as np
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.exceptions import CircuitError
+
+
+class IQP(QuantumCircuit):
+    r"""Instantaneous quantum polynomial (IQP) circuit.
+
+    The circuit consists of a column of Hadamard gates,
+    a column of powers of T gates,
+    a sequence of powers of CS gates (up to
+    :math:`\frac{n^2-n}{2}` of them),
+    and a final column of Hadamard gates, as introduced in [1].
+
+    The circuit is parameterized by an n x n interactions matrix.
+    The powers of each T gate are given by the diagonal elements
+    of the interactions matrix. The powers of the CS gates are
+    given by the upper triangle of the interactions matrix.
+
+    **Reference Circuit:**
+
+    .. plot::
+
+       from qiskit.circuit.library import IQP
+       A = [[6, 5, 3], [5, 4, 5], [3, 5, 1]]
+       circuit = IQP(A)
+       circuit.draw('mpl')
+
+    **Expanded Circuit:**
+
+        .. plot::
+
+           from qiskit.circuit.library import IQP
+           from qiskit.tools.jupyter.library import _generate_circuit_library_visualization
+           A = [[6, 5, 3], [5, 4, 5], [3, 5, 1]]
+           circuit = IQP(A)
+           _generate_circuit_library_visualization(circuit.decompose())
+
+    **References:**
+
+    [1] M. J. Bremner et al. Average-case complexity versus approximate
+    simulation of commuting quantum computations,
+    Phys. Rev. Lett. 117, 080501 (2016).
+    `arXiv:1504.07999 <https://arxiv.org/abs/1504.07999>`_
+    """
+
+    def __init__(self, interactions: list | np.ndarray) -> None:
+        """Create IQP circuit.
+
+        Args:
+            interactions: input n-by-n symmetric matrix.
+
+        Raises:
+            CircuitError: if the inputs is not as symmetric matrix.
+        """
+        num_qubits = len(interactions)
+        interactions = np.array(interactions)
+        if not np.allclose(interactions, interactions.transpose()):
+            raise CircuitError("The interactions matrix is not symmetric")
+
+        a_str = np.array_str(interactions)
+        a_str.replace("\n", ";")
+        name = "iqp:" + a_str.replace("\n", ";")
+
+        circuit = QuantumCircuit(num_qubits, name=name)
+
+        circuit.h(range(num_qubits))
+        for i in range(num_qubits):
+            for j in range(i + 1, num_qubits):
+                if interactions[i][j] % 4 != 0:
+                    circuit.cp(interactions[i][j] * np.pi / 2, i, j)
+
+        for i in range(num_qubits):
+            if interactions[i][i] % 8 != 0:
+                circuit.p(interactions[i][i] * np.pi / 8, i)
+
+        circuit.h(range(num_qubits))
+
+        super().__init__(*circuit.qregs, name=circuit.name)
+        self.compose(circuit.to_gate(), qubits=self.qubits, inplace=True)

qiskit/circuit/library/n_local/__init__.py

@@ -0,0 +1,31 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2017, 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.
+
+"""The circuit library module containing N-local circuits."""
+
+from .n_local import NLocal
+from .two_local import TwoLocal
+from .pauli_two_design import PauliTwoDesign
+from .real_amplitudes import RealAmplitudes
+from .efficient_su2 import EfficientSU2
+from .excitation_preserving import ExcitationPreserving
+from .qaoa_ansatz import QAOAAnsatz
+
+__all__ = [
+    "NLocal",
+    "TwoLocal",
+    "RealAmplitudes",
+    "PauliTwoDesign",
+    "EfficientSU2",
+    "ExcitationPreserving",
+    "QAOAAnsatz",
+]