qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/circuit/library/n_local/pauli_two_design.py

@@ -0,0 +1,141 @@
+# 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 Random Pauli circuit class."""
+
+from __future__ import annotations
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit
+
+
+from .two_local import TwoLocal
+
+
+class PauliTwoDesign(TwoLocal):
+    r"""The Pauli Two-Design ansatz.
+
+    This class implements a particular form of a 2-design circuit [1], which is frequently studied
+    in quantum machine learning literature, such as e.g. the investigating of Barren plateaus in
+    variational algorithms [2].
+
+    The circuit consists of alternating rotation and entanglement layers with
+    an initial layer of :math:`\sqrt{H} = RY(\pi/4)` gates.
+    The rotation layers contain single qubit Pauli rotations, where the axis is chosen uniformly
+    at random to be X, Y or Z. The entanglement layers is compromised of pairwise CZ gates
+    with a total depth of 2.
+
+    For instance, the circuit could look like this (but note that choosing a different seed
+    yields different Pauli rotations).
+
+    .. parsed-literal::
+
+             ┌─────────┐┌──────────┐       ░ ┌──────────┐       ░  ┌──────────┐
+        q_0: ┤ RY(π/4) ├┤ RZ(θ[0]) ├─■─────░─┤ RY(θ[4]) ├─■─────░──┤ RZ(θ[8]) ├
+             ├─────────┤├──────────┤ │     ░ ├──────────┤ │     ░  ├──────────┤
+        q_1: ┤ RY(π/4) ├┤ RZ(θ[1]) ├─■──■──░─┤ RY(θ[5]) ├─■──■──░──┤ RX(θ[9]) ├
+             ├─────────┤├──────────┤    │  ░ ├──────────┤    │  ░ ┌┴──────────┤
+        q_2: ┤ RY(π/4) ├┤ RX(θ[2]) ├─■──■──░─┤ RY(θ[6]) ├─■──■──░─┤ RX(θ[10]) ├
+             ├─────────┤├──────────┤ │     ░ ├──────────┤ │     ░ ├───────────┤
+        q_3: ┤ RY(π/4) ├┤ RZ(θ[3]) ├─■─────░─┤ RX(θ[7]) ├─■─────░─┤ RY(θ[11]) ├
+             └─────────┘└──────────┘       ░ └──────────┘       ░ └───────────┘
+
+    Examples:
+
+        .. plot::
+           :include-source:
+
+           from qiskit.circuit.library import PauliTwoDesign
+           circuit = PauliTwoDesign(4, reps=2, seed=5, insert_barriers=True)
+           circuit.draw('mpl')
+
+    References:
+
+        [1]: Nakata et al., Unitary 2-designs from random X- and Z-diagonal unitaries.
+            `arXiv:1502.07514 <https://arxiv.org/pdf/1502.07514.pdf>`_
+
+        [2]: McClean et al., Barren plateaus in quantum neural network training landscapes.
+             `arXiv:1803.11173 <https://arxiv.org/pdf/1803.11173.pdf>`_
+    """
+
+    def __init__(
+        self,
+        num_qubits: int | None = None,
+        reps: int = 3,
+        seed: int | None = None,
+        insert_barriers: bool = False,
+        name: str = "PauliTwoDesign",
+    ):
+        """
+        Args:
+            num_qubits: The number of qubits of the Pauli Two-Design circuit.
+            reps: Specifies how often a block consisting of a rotation layer and entanglement
+                layer is repeated.
+            seed: The seed for randomly choosing the axes of the Pauli rotations.
+            insert_barriers: If ``True``, barriers are inserted in between each layer. If ``False``,
+                no barriers are inserted. Defaults to ``False``.
+
+        """
+        from qiskit.circuit.library import RYGate  # pylint: disable=cyclic-import
+
+        # store a random number generator
+        self._seed = seed
+        self._rng = np.random.default_rng(seed)
+
+        # store a dict to keep track of the random gates
+        self._gates: dict[int, list[str]] = {}
+
+        super().__init__(
+            num_qubits,
+            reps=reps,
+            entanglement_blocks="cz",
+            entanglement="pairwise",
+            insert_barriers=insert_barriers,
+            name=name,
+        )
+
+        # set the initial layer
+        self._prepended_blocks = [RYGate(np.pi / 4)]
+        self._prepended_entanglement = ["linear"]
+
+    def _invalidate(self):
+        """Invalidate the circuit and reset the random number."""
+        self._rng = np.random.default_rng(self._seed)  # reset number generator
+        super()._invalidate()
+
+    def _build_rotation_layer(self, circuit, param_iter, i):
+        """Build a rotation layer."""
+        layer = QuantumCircuit(*self.qregs)
+        qubits = range(self.num_qubits)
+
+        # if no gates for this layer were generated, generate them
+        if i not in self._gates:
+            self._gates[i] = list(self._rng.choice(["rx", "ry", "rz"], self.num_qubits))
+        # if not enough gates exist, add more
+        elif len(self._gates[i]) < self.num_qubits:
+            num_missing = self.num_qubits - len(self._gates[i])
+            self._gates[i] += list(self._rng.choice(["rx", "ry", "rz"], num_missing))
+
+        for j in qubits:
+            getattr(layer, self._gates[i][j])(next(param_iter), j)
+
+        # add the layer to the circuit
+        circuit.compose(layer, inplace=True)
+
+    @property
+    def num_parameters_settable(self) -> int:
+        """Return the number of settable parameters.
+
+        Returns:
+            The number of possibly distinct parameters.
+        """
+        return (self.reps + 1) * self.num_qubits

qiskit/circuit/library/n_local/qaoa_ansatz.py

@@ -0,0 +1,287 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2018, 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.
+
+"""A generalized QAOA quantum circuit with a support of custom initial states and mixers."""
+
+# pylint: disable=cyclic-import
+from __future__ import annotations
+
+import numpy as np
+
+from qiskit.circuit.parametervector import ParameterVector
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.quantum_info import SparsePauliOp
+
+from .evolved_operator_ansatz import EvolvedOperatorAnsatz, _is_pauli_identity
+
+
+class QAOAAnsatz(EvolvedOperatorAnsatz):
+    """A generalized QAOA quantum circuit with a support of custom initial states and mixers.
+
+    References:
+
+        [1]: Farhi et al., A Quantum Approximate Optimization Algorithm.
+            `arXiv:1411.4028 <https://arxiv.org/pdf/1411.4028>`_
+    """
+
+    def __init__(
+        self,
+        cost_operator=None,
+        reps: int = 1,
+        initial_state: QuantumCircuit | None = None,
+        mixer_operator=None,
+        name: str = "QAOA",
+        flatten: bool | None = None,
+    ):
+        r"""
+        Args:
+            cost_operator (BaseOperator or OperatorBase, optional): The operator
+                representing the cost of the optimization problem, denoted as :math:`U(C, \gamma)`
+                in the original paper. Must be set either in the constructor or via property setter.
+            reps (int): The integer parameter p, which determines the depth of the circuit,
+                as specified in the original paper, default is 1.
+            initial_state (QuantumCircuit, optional): An optional initial state to use.
+                If `None` is passed then a set of Hadamard gates is applied as an initial state
+                to all qubits.
+            mixer_operator (BaseOperator or OperatorBase or QuantumCircuit, optional): An optional
+                custom mixer to use instead of the global X-rotations, denoted as :math:`U(B, \beta)`
+                in the original paper. Can be an operator or an optionally parameterized quantum
+                circuit.
+            name (str): A name of the circuit, default 'qaoa'
+            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.
+        """
+        super().__init__(reps=reps, name=name, flatten=flatten)
+
+        self._cost_operator = None
+        self._reps = reps
+        self._initial_state: QuantumCircuit | None = initial_state
+        self._mixer = mixer_operator
+
+        # set this circuit as a not-built circuit
+        self._bounds: list[tuple[float | None, float | None]] | None = None
+
+        # store cost operator and set the registers if the operator is not None
+        self.cost_operator = cost_operator
+
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration is valid."""
+        valid = True
+
+        if not super()._check_configuration(raise_on_failure):
+            return False
+
+        if self.cost_operator is None:
+            valid = False
+            if raise_on_failure:
+                raise ValueError(
+                    "The operator representing the cost of the optimization problem is not set"
+                )
+
+        if self.initial_state is not None and self.initial_state.num_qubits != self.num_qubits:
+            valid = False
+            if raise_on_failure:
+                raise ValueError(
+                    f"The number of qubits of the initial state {self.initial_state.num_qubits}"
+                    " does not match "
+                    f"the number of qubits of the cost operator {self.num_qubits}"
+                )
+
+        if self.mixer_operator is not None and self.mixer_operator.num_qubits != self.num_qubits:
+            valid = False
+            if raise_on_failure:
+                raise ValueError(
+                    f"The number of qubits of the mixer {self.mixer_operator.num_qubits}"
+                    f" does not match "
+                    f"the number of qubits of the cost operator {self.num_qubits}"
+                )
+
+        return valid
+
+    @property
+    def parameter_bounds(self) -> list[tuple[float | None, float | None]] | None:
+        """The parameter bounds for the unbound parameters in the circuit.
+
+        Returns:
+            A list of pairs indicating the bounds, as (lower, upper). None indicates an unbounded
+            parameter in the corresponding direction. If None is returned, problem is fully
+            unbounded.
+        """
+        if self._bounds is not None:
+            return self._bounds
+
+        # if the mixer is a circuit, we set no bounds
+        if isinstance(self.mixer_operator, QuantumCircuit):
+            return None
+
+        # default bounds: None for gamma (cost operator), [0, 2pi] for gamma (mixer operator)
+        beta_bounds = (0, 2 * np.pi)
+        gamma_bounds = (None, None)
+        bounds: list[tuple[float | None, float | None]] = []
+
+        if not _is_pauli_identity(self.mixer_operator):
+            bounds += self.reps * [beta_bounds]
+
+        if not _is_pauli_identity(self.cost_operator):
+            bounds += self.reps * [gamma_bounds]
+
+        return bounds
+
+    @parameter_bounds.setter
+    def parameter_bounds(self, bounds: list[tuple[float | None, float | None]] | None) -> None:
+        """Set the parameter bounds.
+
+        Args:
+            bounds: The new parameter bounds.
+        """
+        self._bounds = bounds
+
+    @property
+    def operators(self) -> list:
+        """The operators that are evolved in this circuit.
+
+        Returns:
+             List[Union[BaseOperator, OperatorBase, QuantumCircuit]]: The operators to be evolved
+                (and circuits) in this ansatz.
+        """
+        return [self.cost_operator, self.mixer_operator]
+
+    @property
+    def cost_operator(self):
+        """Returns an operator representing the cost of the optimization problem.
+
+        Returns:
+            BaseOperator or OperatorBase: cost operator.
+        """
+        return self._cost_operator
+
+    @cost_operator.setter
+    def cost_operator(self, cost_operator) -> None:
+        """Sets cost operator.
+
+        Args:
+            cost_operator (BaseOperator or OperatorBase, optional): cost operator to set.
+        """
+        self._cost_operator = cost_operator
+        self.qregs = [QuantumRegister(self.num_qubits, name="q")]
+        self._invalidate()
+
+    @property
+    def reps(self) -> int:
+        """Returns the `reps` parameter, which determines the depth of the circuit."""
+        return self._reps
+
+    @reps.setter
+    def reps(self, reps: int) -> None:
+        """Sets the `reps` parameter."""
+        self._reps = reps
+        self._invalidate()
+
+    @property
+    def initial_state(self) -> QuantumCircuit | None:
+        """Returns an optional initial state as a circuit"""
+        if self._initial_state is not None:
+            return self._initial_state
+
+        # if no initial state is passed and we know the number of qubits, then initialize it.
+        if self.num_qubits > 0:
+            initial_state = QuantumCircuit(self.num_qubits)
+            initial_state.h(range(self.num_qubits))
+            return initial_state
+
+        # otherwise we cannot provide a default
+        return None
+
+    @initial_state.setter
+    def initial_state(self, initial_state: QuantumCircuit | None) -> None:
+        """Sets initial state."""
+        self._initial_state = initial_state
+        self._invalidate()
+
+    # we can't directly specify OperatorBase as a return type, it causes a circular import
+    # and pylint objects if return type is not documented
+    @property
+    def mixer_operator(self):
+        """Returns an optional mixer operator expressed as an operator or a quantum circuit.
+
+        Returns:
+            BaseOperator or OperatorBase or QuantumCircuit, optional: mixer operator or circuit.
+        """
+        if self._mixer is not None:
+            return self._mixer
+
+        # if no mixer is passed and we know the number of qubits, then initialize it.
+        if self.cost_operator is not None:
+            # local imports to avoid circular imports
+            num_qubits = self.cost_operator.num_qubits
+
+            # Mixer is just a sum of single qubit X's on each qubit. Evolving by this operator
+            # will simply produce rx's on each qubit.
+            mixer_terms = [
+                ("I" * left + "X" + "I" * (num_qubits - left - 1), 1) for left in range(num_qubits)
+            ]
+            mixer = SparsePauliOp.from_list(mixer_terms)
+            return mixer
+
+        # otherwise we cannot provide a default
+        return None
+
+    @mixer_operator.setter
+    def mixer_operator(self, mixer_operator) -> None:
+        """Sets mixer operator.
+
+        Args:
+            mixer_operator (BaseOperator or OperatorBase or QuantumCircuit, optional): mixer
+                operator or circuit to set.
+        """
+        self._mixer = mixer_operator
+        self._invalidate()
+
+    @property
+    def num_qubits(self) -> int:
+        if self._cost_operator is None:
+            return 0
+        return self._cost_operator.num_qubits
+
+    def _build(self):
+        """If not already built, build the circuit."""
+        if self._is_built:
+            return
+
+        super()._build()
+
+        # keep old parameter order: first cost operator, then mixer operators
+        num_cost = 0 if _is_pauli_identity(self.cost_operator) else 1
+        if isinstance(self.mixer_operator, QuantumCircuit):
+            num_mixer = self.mixer_operator.num_parameters
+        else:
+            num_mixer = 0 if _is_pauli_identity(self.mixer_operator) else 1
+
+        betas = ParameterVector("β", self.reps * num_mixer)
+        gammas = ParameterVector("γ", self.reps * num_cost)
+
+        # Create a permutation to take us from (cost_1, mixer_1, cost_2, mixer_2, ...)
+        # to (cost_1, cost_2, ..., mixer_1, mixer_2, ...), or if the mixer is a circuit
+        # with more than 1 parameters, from (cost_1, mixer_1a, mixer_1b, cost_2, ...)
+        # to (cost_1, cost_2, ..., mixer_1a, mixer_1b, mixer_2a, mixer_2b, ...)
+        reordered = []
+        for rep in range(self.reps):
+            reordered.extend(gammas[rep * num_cost : (rep + 1) * num_cost])
+            reordered.extend(betas[rep * num_mixer : (rep + 1) * num_mixer])
+
+        self.assign_parameters(dict(zip(self.ordered_parameters, reordered)), inplace=True)

qiskit/circuit/library/n_local/real_amplitudes.py

@@ -0,0 +1,186 @@
+# 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 real-amplitudes 2-local circuit."""
+
+from __future__ import annotations
+from collections.abc import Callable
+
+import numpy as np
+
+from qiskit.circuit import QuantumCircuit
+from qiskit.circuit.library.standard_gates import RYGate, CXGate
+from .two_local import TwoLocal
+
+
+class RealAmplitudes(TwoLocal):
+    r"""The real-amplitudes 2-local circuit.
+
+    The ``RealAmplitudes`` circuit is a heuristic trial wave function used as Ansatz in chemistry
+    applications or classification circuits in machine learning. The circuit consists of
+    alternating layers of :math:`Y` rotations and :math:`CX` entanglements. The entanglement
+    pattern can be user-defined or selected from a predefined set.
+    It is called ``RealAmplitudes`` since the prepared quantum states will only have
+    real amplitudes, the complex part is always 0.
+
+    For example a ``RealAmplitudes`` circuit with 2 repetitions on 3 qubits with ``'reverse_linear'``
+    entanglement is
+
+    .. parsed-literal::
+         ┌──────────┐ ░            ░ ┌──────────┐ ░            ░ ┌──────────┐
+         ┤ Ry(θ[0]) ├─░────────■───░─┤ Ry(θ[3]) ├─░────────■───░─┤ Ry(θ[6]) ├
+         ├──────────┤ ░      ┌─┴─┐ ░ ├──────────┤ ░      ┌─┴─┐ ░ ├──────────┤
+         ┤ Ry(θ[1]) ├─░───■──┤ X ├─░─┤ Ry(θ[4]) ├─░───■──┤ X ├─░─┤ Ry(θ[7]) ├
+         ├──────────┤ ░ ┌─┴─┐└───┘ ░ ├──────────┤ ░ ┌─┴─┐└───┘ ░ ├──────────┤
+         ┤ Ry(θ[2]) ├─░─┤ X ├──────░─┤ Ry(θ[5]) ├─░─┤ X ├──────░─┤ Ry(θ[8]) ├
+         └──────────┘ ░ └───┘      ░ └──────────┘ ░ └───┘      ░ └──────────┘
+
+    The entanglement can be set using the ``entanglement`` keyword as string or a list of
+    index-pairs. See the documentation of :class:`~qiskit.circuit.library.TwoLocal` and
+    :class:`~qiskit.circuit.NLocal` for more detail. Additional options that can be set include the
+    number of repetitions, skipping rotation gates on qubits that are not entangled, leaving out
+    the final rotation layer and inserting barriers in between the rotation and entanglement
+    layers.
+
+    If some qubits are not entangled with other qubits it makes sense to not apply rotation gates
+    on these qubits, since a sequence of :math:`Y` rotations can be reduced to a single :math:`Y`
+    rotation with summed rotation angles.
+
+    Examples:
+
+        >>> ansatz = RealAmplitudes(3, reps=2)  # create the circuit on 3 qubits
+        >>> print(ansatz)
+             ┌──────────┐                 ┌──────────┐                 ┌──────────┐
+        q_0: ┤ Ry(θ[0]) ├──────────■──────┤ Ry(θ[3]) ├──────────■──────┤ Ry(θ[6]) ├
+             ├──────────┤        ┌─┴─┐    ├──────────┤        ┌─┴─┐    ├──────────┤
+        q_1: ┤ Ry(θ[1]) ├──■─────┤ X ├────┤ Ry(θ[4]) ├──■─────┤ X ├────┤ Ry(θ[7]) ├
+             ├──────────┤┌─┴─┐┌──┴───┴───┐└──────────┘┌─┴─┐┌──┴───┴───┐└──────────┘
+        q_2: ┤ Ry(θ[2]) ├┤ X ├┤ Ry(θ[5]) ├────────────┤ X ├┤ Ry(θ[8]) ├────────────
+             └──────────┘└───┘└──────────┘            └───┘└──────────┘
+
+        >>> ansatz = RealAmplitudes(3, entanglement='full', reps=2)  # it is the same unitary as above
+        >>> print(ansatz)
+             ┌──────────┐          ┌──────────┐                      ┌──────────┐
+        q_0: ┤ RY(θ[0]) ├──■────■──┤ RY(θ[3]) ├──────────────■────■──┤ RY(θ[6]) ├────────────
+             ├──────────┤┌─┴─┐  │  └──────────┘┌──────────┐┌─┴─┐  │  └──────────┘┌──────────┐
+        q_1: ┤ RY(θ[1]) ├┤ X ├──┼───────■──────┤ RY(θ[4]) ├┤ X ├──┼───────■──────┤ RY(θ[7]) ├
+             ├──────────┤└───┘┌─┴─┐   ┌─┴─┐    ├──────────┤└───┘┌─┴─┐   ┌─┴─┐    ├──────────┤
+        q_2: ┤ RY(θ[2]) ├─────┤ X ├───┤ X ├────┤ RY(θ[5]) ├─────┤ X ├───┤ X ├────┤ RY(θ[8]) ├
+             └──────────┘     └───┘   └───┘    └──────────┘     └───┘   └───┘    └──────────┘
+
+        >>> ansatz = RealAmplitudes(3, entanglement='linear', reps=2, insert_barriers=True)
+        >>> qc = QuantumCircuit(3)  # create a circuit and append the RY variational form
+        >>> qc.compose(ansatz, inplace=True)
+        >>> qc.draw()
+             ┌──────────┐ ░            ░ ┌──────────┐ ░            ░ ┌──────────┐
+        q_0: ┤ RY(θ[0]) ├─░───■────────░─┤ RY(θ[3]) ├─░───■────────░─┤ RY(θ[6]) ├
+             ├──────────┤ ░ ┌─┴─┐      ░ ├──────────┤ ░ ┌─┴─┐      ░ ├──────────┤
+        q_1: ┤ RY(θ[1]) ├─░─┤ X ├──■───░─┤ RY(θ[4]) ├─░─┤ X ├──■───░─┤ RY(θ[7]) ├
+             ├──────────┤ ░ └───┘┌─┴─┐ ░ ├──────────┤ ░ └───┘┌─┴─┐ ░ ├──────────┤
+        q_2: ┤ RY(θ[2]) ├─░──────┤ X ├─░─┤ RY(θ[5]) ├─░──────┤ X ├─░─┤ RY(θ[8]) ├
+             └──────────┘ ░      └───┘ ░ └──────────┘ ░      └───┘ ░ └──────────┘
+
+        >>> ansatz = RealAmplitudes(4, reps=1, entanglement='circular', insert_barriers=True)
+        >>> print(ansatz)
+             ┌──────────┐ ░ ┌───┐                ░ ┌──────────┐
+        q_0: ┤ RY(θ[0]) ├─░─┤ X ├──■─────────────░─┤ RY(θ[4]) ├
+             ├──────────┤ ░ └─┬─┘┌─┴─┐           ░ ├──────────┤
+        q_1: ┤ RY(θ[1]) ├─░───┼──┤ X ├──■────────░─┤ RY(θ[5]) ├
+             ├──────────┤ ░   │  └───┘┌─┴─┐      ░ ├──────────┤
+        q_2: ┤ RY(θ[2]) ├─░───┼───────┤ X ├──■───░─┤ RY(θ[6]) ├
+             ├──────────┤ ░   │       └───┘┌─┴─┐ ░ ├──────────┤
+        q_3: ┤ RY(θ[3]) ├─░───■────────────┤ X ├─░─┤ RY(θ[7]) ├
+             └──────────┘ ░                └───┘ ░ └──────────┘
+
+        >>> ansatz = RealAmplitudes(4, reps=2, entanglement=[[0,3], [0,2]],
+        ... skip_unentangled_qubits=True)
+        >>> print(ansatz)
+             ┌──────────┐                 ┌──────────┐                 ┌──────────┐
+        q_0: ┤ RY(θ[0]) ├──■───────■──────┤ RY(θ[3]) ├──■───────■──────┤ RY(θ[6]) ├
+             └──────────┘  │       │      └──────────┘  │       │      └──────────┘
+        q_1: ──────────────┼───────┼────────────────────┼───────┼──────────────────
+             ┌──────────┐  │     ┌─┴─┐    ┌──────────┐  │     ┌─┴─┐    ┌──────────┐
+        q_2: ┤ RY(θ[1]) ├──┼─────┤ X ├────┤ RY(θ[4]) ├──┼─────┤ X ├────┤ RY(θ[7]) ├
+             ├──────────┤┌─┴─┐┌──┴───┴───┐└──────────┘┌─┴─┐┌──┴───┴───┐└──────────┘
+        q_3: ┤ RY(θ[2]) ├┤ X ├┤ RY(θ[5]) ├────────────┤ X ├┤ RY(θ[8]) ├────────────
+             └──────────┘└───┘└──────────┘            └───┘└──────────┘
+
+    """
+
+    def __init__(
+        self,
+        num_qubits: int | 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 = "RealAmplitudes",
+        flatten: bool | None = None,
+    ) -> None:
+        """
+        Args:
+            num_qubits: The number of qubits of the RealAmplitudes circuit.
+            reps: Specifies how often the structure of a rotation layer followed by an entanglement
+                layer is repeated.
+            entanglement: Specifies the entanglement structure. Can be a string ('full', 'linear'
+                'reverse_linear, '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.
+                Default 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.
+        """
+        super().__init__(
+            num_qubits=num_qubits,
+            reps=reps,
+            rotation_blocks=RYGate,
+            entanglement_blocks=CXGate,
+            entanglement=entanglement,
+            initial_state=initial_state,
+            skip_unentangled_qubits=skip_unentangled_qubits,
+            skip_final_rotation_layer=skip_final_rotation_layer,
+            parameter_prefix=parameter_prefix,
+            insert_barriers=insert_barriers,
+            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 * [(-np.pi, np.pi)]