qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/circuit/library/hamiltonian_gate.py

@@ -0,0 +1,142 @@
+# 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 math
+import typing
+
+from numbers import Number
+import numpy as np
+
+from qiskit import _numpy_compat
+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 .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.asarray(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(math.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, copy=None):
+        """Return matrix for the unitary."""
+        import scipy.linalg
+
+        if copy is False:
+            raise ValueError("unable to avoid copy while creating an array as requested")
+        try:
+            time = float(self.params[1])
+        except TypeError as ex:
+            raise TypeError(
+                f"Unable to generate Unitary matrix for unbound t parameter {self.params[1]}"
+            ) from ex
+        arr = scipy.linalg.expm(-1j * self.params[0] * time)
+        dtype = complex if dtype is None else dtype
+        return np.array(arr, dtype=dtype, copy=_numpy_compat.COPY_ONLY_IF_NEEDED)
+
+    def inverse(self, annotated: bool = False):
+        """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
+
+    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.visualization.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=f"hlf: {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.visualization.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,33 @@
+# 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 .evolved_operator_ansatz import EvolvedOperatorAnsatz
+from .excitation_preserving import ExcitationPreserving
+from .qaoa_ansatz import QAOAAnsatz
+
+__all__ = [
+    "NLocal",
+    "TwoLocal",
+    "RealAmplitudes",
+    "PauliTwoDesign",
+    "EfficientSU2",
+    "EvolvedOperatorAnsatz",
+    "ExcitationPreserving",
+    "QAOAAnsatz",
+]

qiskit/circuit/library/n_local/efficient_su2.py

@@ -0,0 +1,164 @@
+# 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 EfficientSU2 2-local circuit."""
+
+from __future__ import annotations
+import typing
+from collections.abc import Callable
+
+from numpy import pi
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.library.standard_gates import RYGate, RZGate, CXGate
+from .two_local import TwoLocal
+
+if typing.TYPE_CHECKING:
+    import qiskit  # pylint: disable=cyclic-import
+
+
+class EfficientSU2(TwoLocal):
+    r"""The hardware efficient SU(2) 2-local circuit.
+
+    The ``EfficientSU2`` circuit consists of layers of single qubit operations spanned by SU(2)
+    and :math:`CX` entanglements. This is a heuristic pattern that can be used to prepare trial wave
+    functions for variational quantum algorithms or classification circuit for machine learning.
+
+    SU(2) stands for special unitary group of degree 2, its elements are :math:`2 \times 2`
+    unitary matrices with determinant 1, such as the Pauli rotation gates.
+
+    On 3 qubits and using the Pauli :math:`Y` and :math:`Z` su2_gates as single qubit gates, the
+    hardware efficient SU(2) circuit is represented by:
+
+    .. parsed-literal::
+
+        ┌──────────┐┌──────────┐ ░            ░       ░ ┌───────────┐┌───────────┐
+        ┤ RY(θ[0]) ├┤ RZ(θ[3]) ├─░────────■───░─ ... ─░─┤ RY(θ[12]) ├┤ RZ(θ[15]) ├
+        ├──────────┤├──────────┤ ░      ┌─┴─┐ ░       ░ ├───────────┤├───────────┤
+        ┤ RY(θ[1]) ├┤ RZ(θ[4]) ├─░───■──┤ X ├─░─ ... ─░─┤ RY(θ[13]) ├┤ RZ(θ[16]) ├
+        ├──────────┤├──────────┤ ░ ┌─┴─┐└───┘ ░       ░ ├───────────┤├───────────┤
+        ┤ RY(θ[2]) ├┤ RZ(θ[5]) ├─░─┤ X ├──────░─ ... ─░─┤ RY(θ[14]) ├┤ RZ(θ[17]) ├
+        └──────────┘└──────────┘ ░ └───┘      ░       ░ └───────────┘└───────────┘
+
+    See :class:`~qiskit.circuit.library.RealAmplitudes` for more detail on the possible arguments
+    and options such as skipping unentanglement qubits, which apply here too.
+
+    Examples:
+
+        >>> circuit = EfficientSU2(3, reps=1)
+        >>> print(circuit)
+             ┌──────────┐┌──────────┐          ┌──────────┐┌──────────┐
+        q_0: ┤ RY(θ[0]) ├┤ RZ(θ[3]) ├──■────■──┤ RY(θ[6]) ├┤ RZ(θ[9]) ├─────────────
+             ├──────────┤├──────────┤┌─┴─┐  │  └──────────┘├──────────┤┌───────────┐
+        q_1: ┤ RY(θ[1]) ├┤ RZ(θ[4]) ├┤ X ├──┼───────■──────┤ RY(θ[7]) ├┤ RZ(θ[10]) ├
+             ├──────────┤├──────────┤└───┘┌─┴─┐   ┌─┴─┐    ├──────────┤├───────────┤
+        q_2: ┤ RY(θ[2]) ├┤ RZ(θ[5]) ├─────┤ X ├───┤ X ├────┤ RY(θ[8]) ├┤ RZ(θ[11]) ├
+             └──────────┘└──────────┘     └───┘   └───┘    └──────────┘└───────────┘
+
+        >>> ansatz = EfficientSU2(4, su2_gates=['rx', 'y'], entanglement='circular', reps=1)
+        >>> qc = QuantumCircuit(4)  # create a circuit and append the RY variational form
+        >>> qc.compose(ansatz, inplace=True)
+        >>> qc.draw()
+             ┌──────────┐┌───┐┌───┐     ┌──────────┐   ┌───┐
+        q_0: ┤ RX(θ[0]) ├┤ Y ├┤ X ├──■──┤ RX(θ[4]) ├───┤ Y ├─────────────────────
+             ├──────────┤├───┤└─┬─┘┌─┴─┐└──────────┘┌──┴───┴───┐   ┌───┐
+        q_1: ┤ RX(θ[1]) ├┤ Y ├──┼──┤ X ├─────■──────┤ RX(θ[5]) ├───┤ Y ├─────────
+             ├──────────┤├───┤  │  └───┘   ┌─┴─┐    └──────────┘┌──┴───┴───┐┌───┐
+        q_2: ┤ RX(θ[2]) ├┤ Y ├──┼──────────┤ X ├─────────■──────┤ RX(θ[6]) ├┤ Y ├
+             ├──────────┤├───┤  │          └───┘       ┌─┴─┐    ├──────────┤├───┤
+        q_3: ┤ RX(θ[3]) ├┤ Y ├──■──────────────────────┤ X ├────┤ RX(θ[7]) ├┤ Y ├
+             └──────────┘└───┘                         └───┘    └──────────┘└───┘
+
+    """
+
+    def __init__(
+        self,
+        num_qubits: int | None = None,
+        su2_gates: (
+            str
+            | type
+            | qiskit.circuit.Instruction
+            | QuantumCircuit
+            | list[str | type | qiskit.circuit.Instruction | QuantumCircuit]
+            | None
+        ) = None,
+        entanglement: str | list[list[int]] | Callable[[int], list[int]] = "reverse_linear",
+        reps: int = 3,
+        skip_unentangled_qubits: bool = False,
+        skip_final_rotation_layer: bool = False,
+        parameter_prefix: str = "θ",
+        insert_barriers: bool = False,
+        initial_state: QuantumCircuit | None = None,
+        name: str = "EfficientSU2",
+        flatten: bool | None = None,
+    ) -> None:
+        """
+        Args:
+            num_qubits: The number of qubits of the EfficientSU2 circuit.
+            reps: Specifies how often the structure of a rotation layer followed by an entanglement
+                layer is repeated.
+            su2_gates: The SU(2) single qubit gates to apply in single qubit gate layers.
+                If only one gate is provided, the same gate is applied to each qubit.
+                If a list of gates is provided, all gates are applied to each qubit in the provided
+                order.
+            entanglement: Specifies the entanglement structure. Can be a string
+                ('full', 'linear', 'reverse_linear', 'pairwise', 'circular', or 'sca'),
+                a list of integer-pairs specifying the indices of qubits entangled with one another,
+                or a callable returning such a list provided with the index of the entanglement layer.
+                Defaults to 'reverse_linear' entanglement.
+                Note that 'reverse_linear' entanglement provides the same unitary as 'full'
+                with fewer entangling gates.
+                See the Examples section of :class:`~qiskit.circuit.library.TwoLocal` for more
+                detail.
+            initial_state: A `QuantumCircuit` object to prepend to the circuit.
+            skip_unentangled_qubits: If True, the single qubit gates are only applied to qubits
+                that are entangled with another qubit. If False, the single qubit gates are applied
+                to each qubit in the Ansatz. Defaults to False.
+            skip_final_rotation_layer: If False, a rotation layer is added at the end of the
+                ansatz. If True, no rotation layer is added.
+            parameter_prefix: The parameterized gates require a parameter to be defined, for which
+                we use :class:`~qiskit.circuit.ParameterVector`.
+            insert_barriers: If True, barriers are inserted in between each layer. If False,
+                no barriers are inserted.
+            flatten: Set this to ``True`` to output a flat circuit instead of nesting it inside multiple
+                layers of gate objects. By default currently the contents of
+                the output circuit will be wrapped in nested objects for
+                cleaner visualization. However, if you're using this circuit
+                for anything besides visualization its **strongly** recommended
+                to set this flag to ``True`` to avoid a large performance
+                overhead for parameter binding.
+        """
+        if su2_gates is None:
+            su2_gates = [RYGate, RZGate]
+        super().__init__(
+            num_qubits=num_qubits,
+            rotation_blocks=su2_gates,
+            entanglement_blocks=CXGate,
+            entanglement=entanglement,
+            reps=reps,
+            skip_unentangled_qubits=skip_unentangled_qubits,
+            skip_final_rotation_layer=skip_final_rotation_layer,
+            parameter_prefix=parameter_prefix,
+            insert_barriers=insert_barriers,
+            initial_state=initial_state,
+            name=name,
+            flatten=flatten,
+        )
+
+    @property
+    def parameter_bounds(self) -> list[tuple[float, float]]:
+        """Return the parameter bounds.
+
+        Returns:
+            The parameter bounds.
+        """
+        return self.num_parameters * [(-pi, pi)]