qiskit 1.3.0b1__cp39-abi3-macosx_10_9_x86_64.whl

qiskit/circuit/library/n_local/evolved_operator_ansatz.py

@@ -0,0 +1,256 @@
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2021, 2024.
+#
+# 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 evolved operator ansatz."""
+
+from __future__ import annotations
+from collections.abc import Sequence
+
+import numpy as np
+
+from qiskit.circuit.library.pauli_evolution import PauliEvolutionGate
+from qiskit.circuit.parameter import Parameter
+from qiskit.circuit.quantumregister import QuantumRegister
+from qiskit.circuit.quantumcircuit import QuantumCircuit
+from qiskit.quantum_info import Operator, Pauli, SparsePauliOp
+
+from .n_local import NLocal
+
+
+class EvolvedOperatorAnsatz(NLocal):
+    """The evolved operator ansatz."""
+
+    def __init__(
+        self,
+        operators=None,
+        reps: int = 1,
+        evolution=None,
+        insert_barriers: bool = False,
+        name: str = "EvolvedOps",
+        parameter_prefix: str | Sequence[str] = "t",
+        initial_state: QuantumCircuit | None = None,
+        flatten: bool | None = None,
+    ):
+        """
+        Args:
+            operators (BaseOperator | QuantumCircuit | list | None): The operators
+                to evolve. If a circuit is passed, we assume it implements an already evolved
+                operator and thus the circuit is not evolved again. Can be a single operator
+                (circuit) or a list of operators (and circuits).
+            reps: The number of times to repeat the evolved operators.
+            evolution (EvolutionBase | EvolutionSynthesis | None):
+                A specification of which evolution synthesis to use for the
+                :class:`.PauliEvolutionGate`.
+                Defaults to first order Trotterization.
+            insert_barriers: Whether to insert barriers in between each evolution.
+            name: The name of the circuit.
+            parameter_prefix: Set the names of the circuit parameters. If a string, the same prefix
+                will be used for each parameters. Can also be a list to specify a prefix per
+                operator.
+            initial_state: A :class:`.QuantumCircuit` object to prepend to the circuit.
+            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__(
+            initial_state=initial_state,
+            parameter_prefix=parameter_prefix,
+            reps=reps,
+            insert_barriers=insert_barriers,
+            name=name,
+            flatten=flatten,
+        )
+        self._operators = None
+
+        if operators is not None:
+            self.operators = operators
+
+        self._evolution = evolution
+
+        # a list of which operators are parameterized, used for internal settings
+        self._ops_are_parameterized = None
+
+    def _check_configuration(self, raise_on_failure: bool = True) -> bool:
+        """Check if the current configuration is valid."""
+        if not super()._check_configuration(raise_on_failure):
+            return False
+
+        if self.operators is None:
+            if raise_on_failure:
+                raise ValueError("The operators are not set.")
+            return False
+
+        return True
+
+    @property
+    def num_qubits(self) -> int:
+        """Returns the number of qubits in this circuit.
+
+        Returns:
+            The number of qubits.
+        """
+        if self.operators is None:
+            return 0
+
+        if isinstance(self.operators, list):
+            if len(self.operators) == 0:
+                return 0
+            return self.operators[0].num_qubits
+
+        return self.operators.num_qubits
+
+    @property
+    def evolution(self):
+        """The evolution converter used to compute the evolution.
+
+        Returns:
+            EvolutionSynthesis: The evolution converter used to compute the evolution.
+        """
+
+        return self._evolution
+
+    @evolution.setter
+    def evolution(self, evol) -> None:
+        """Sets the evolution converter used to compute the evolution.
+
+        Args:
+            evol (EvolutionSynthesis): An evolution synthesis object
+        """
+        self._invalidate()
+        self._evolution = evol
+
+    @property
+    def operators(self):
+        """The operators that are evolved in this circuit.
+
+        Returns:
+            list: The operators to be evolved (and circuits) contained in this ansatz.
+        """
+        return self._operators
+
+    @operators.setter
+    def operators(self, operators=None) -> None:
+        """Set the operators to be evolved.
+
+        operators (Optional[Union[QuantumCircuit, list]]): The operators to evolve.
+            If a circuit is passed, we assume it implements an already evolved operator and thus
+            the circuit is not evolved again. Can be a single operator (circuit) or a list of
+            operators (and circuits).
+        """
+        operators = _validate_operators(operators)
+        self._invalidate()
+        self._operators = operators
+        if self.num_qubits == 0:
+            self.qregs = []
+        else:
+            self.qregs = [QuantumRegister(self.num_qubits, name="q")]
+
+    # TODO: the `preferred_init_points`-implementation can (and should!) be improved!
+    @property
+    def preferred_init_points(self):
+        """Getter of preferred initial points based on the given initial state."""
+        if self._initial_state is None:
+            return None
+        else:
+            # If an initial state was set by the user, then we want to make sure that the VQE does
+            # not start from a random point. Thus, we return an all-zero initial point for the
+            # optimizer which is used (unless it gets overwritten by a higher-priority setting at
+            # runtime of the VQE).
+            # However, in order to determine the correct length, we must build the QuantumCircuit
+            # first, because otherwise the operators may not be set yet.
+            self._build()
+            return np.zeros(self.reps * len(self.operators), dtype=float)
+
+    def _evolve_operator(self, operator, time):
+
+        # pylint: disable=cyclic-import
+        from qiskit.circuit.library.hamiltonian_gate import HamiltonianGate
+
+        # if the operator is specified as matrix use exact matrix exponentiation
+        if isinstance(operator, Operator):
+            gate = HamiltonianGate(operator, time)
+        # otherwise, use the PauliEvolutionGate
+        else:
+            from qiskit.synthesis.evolution import LieTrotter
+
+            evolution = LieTrotter() if self._evolution is None else self._evolution
+            gate = PauliEvolutionGate(operator, time, synthesis=evolution)
+
+        evolved = QuantumCircuit(operator.num_qubits)
+        if not self.flatten:
+            evolved.append(gate, evolved.qubits)
+        else:
+            evolved.compose(gate.definition, evolved.qubits, inplace=True)
+        return evolved
+
+    def _build(self):
+        if self._is_built:
+            return
+
+        # need to check configuration here to ensure the operators are not None
+        self._check_configuration()
+
+        coeff = Parameter("c")
+        circuits = []
+
+        for op in self.operators:
+            # if the operator is already the evolved circuit just append it
+            if isinstance(op, QuantumCircuit):
+                circuits.append(op)
+            else:
+                # check if the operator is just the identity, if yes, skip it
+                if _is_pauli_identity(op):
+                    continue
+
+                evolved = self._evolve_operator(op, coeff)
+                circuits.append(evolved)
+
+        self.rotation_blocks = []
+        self.entanglement_blocks = circuits
+
+        super()._build()
+
+
+def _validate_operators(operators):
+    if not isinstance(operators, list):
+        operators = [operators]
+
+    if len(operators) > 1:
+        num_qubits = operators[0].num_qubits
+        if any(operators[i].num_qubits != num_qubits for i in range(1, len(operators))):
+            raise ValueError("All operators must act on the same number of qubits.")
+
+    return operators
+
+
+def _validate_prefix(parameter_prefix, operators):
+    if isinstance(parameter_prefix, str):
+        return len(operators) * [parameter_prefix]
+    if len(parameter_prefix) != len(operators):
+        raise ValueError("The number of parameter prefixes must match the operators.")
+
+    return parameter_prefix
+
+
+def _is_pauli_identity(operator):
+    if isinstance(operator, SparsePauliOp):
+        if len(operator.paulis) == 1:
+            operator = operator.paulis[0]  # check if the single Pauli is identity below
+        else:
+            return False
+    if isinstance(operator, Pauli):
+        return not np.any(np.logical_or(operator.x, operator.z))
+    return False

qiskit/circuit/library/n_local/excitation_preserving.py

@@ -0,0 +1,173 @@
+# 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 ExcitationPreserving 2-local circuit."""
+
+from __future__ import annotations
+from collections.abc import Callable
+from numpy import pi
+
+from qiskit.circuit import QuantumCircuit, Parameter
+from qiskit.circuit.library.standard_gates import RZGate
+from .two_local import TwoLocal
+
+
+class ExcitationPreserving(TwoLocal):
+    r"""The heuristic excitation-preserving wave function ansatz.
+
+    The ``ExcitationPreserving`` circuit preserves the ratio of :math:`|00\rangle`,
+    :math:`|01\rangle + |10\rangle` and :math:`|11\rangle` states. To this end, this circuit
+    uses two-qubit interactions of the form
+
+    .. math::
+
+        \newcommand{\rotationangle}{\theta/2}
+
+        \begin{pmatrix}
+        1 & 0 & 0 & 0 \\
+        0 & \cos\left(\rotationangle\right) & -i\sin\left(\rotationangle\right) & 0 \\
+        0 & -i\sin\left(\rotationangle\right) & \cos\left(\rotationangle\right) & 0 \\
+        0 & 0 & 0 & e^{-i\phi}
+        \end{pmatrix}
+
+    for the mode ``'fsim'`` or with :math:`e^{-i\phi} = 1` for the mode ``'iswap'``.
+
+    Note that other wave functions, such as UCC-ansatzes, are also excitation preserving.
+    However these can become complex quickly, while this heuristically motivated circuit follows
+    a simpler pattern.
+
+    This trial wave function consists of layers of :math:`Z` rotations with 2-qubit entanglements.
+    The entangling is creating using :math:`XX+YY` rotations and optionally a controlled-phase
+    gate for the mode ``'fsim'``.
+
+    See :class:`~qiskit.circuit.library.RealAmplitudes` for more detail on the possible arguments
+    and options such as skipping unentanglement qubits, which apply here too.
+
+    The rotations of the ExcitationPreserving ansatz can be written as
+
+    Examples:
+
+        >>> ansatz = ExcitationPreserving(3, reps=1, insert_barriers=True, entanglement='linear')
+        >>> print(ansatz)  # show the circuit
+             ┌──────────┐ ░ ┌────────────┐┌────────────┐                             ░ ┌──────────┐
+        q_0: ┤ RZ(θ[0]) ├─░─┤0           ├┤0           ├─────────────────────────────░─┤ RZ(θ[5]) ├
+             ├──────────┤ ░ │  RXX(θ[3]) ││  RYY(θ[3]) │┌────────────┐┌────────────┐ ░ ├──────────┤
+        q_1: ┤ RZ(θ[1]) ├─░─┤1           ├┤1           ├┤0           ├┤0           ├─░─┤ RZ(θ[6]) ├
+             ├──────────┤ ░ └────────────┘└────────────┘│  RXX(θ[4]) ││  RYY(θ[4]) │ ░ ├──────────┤
+        q_2: ┤ RZ(θ[2]) ├─░─────────────────────────────┤1           ├┤1           ├─░─┤ RZ(θ[7]) ├
+             └──────────┘ ░                             └────────────┘└────────────┘ ░ └──────────┘
+
+        >>> ansatz = ExcitationPreserving(2, reps=1)
+        >>> qc = QuantumCircuit(2)  # create a circuit and append the RY variational form
+        >>> qc.cry(0.2, 0, 1)  # do some previous operation
+        >>> qc.compose(ansatz, inplace=True)  # add the swaprz
+        >>> qc.draw()
+                        ┌──────────┐┌────────────┐┌────────────┐┌──────────┐
+        q_0: ─────■─────┤ RZ(θ[0]) ├┤0           ├┤0           ├┤ RZ(θ[3]) ├
+             ┌────┴────┐├──────────┤│  RXX(θ[2]) ││  RYY(θ[2]) │├──────────┤
+        q_1: ┤ RY(0.2) ├┤ RZ(θ[1]) ├┤1           ├┤1           ├┤ RZ(θ[4]) ├
+             └─────────┘└──────────┘└────────────┘└────────────┘└──────────┘
+
+        >>> ansatz = ExcitationPreserving(3, reps=1, mode='fsim', entanglement=[[0,2]],
+        ... insert_barriers=True)
+        >>> print(ansatz)
+             ┌──────────┐ ░ ┌────────────┐┌────────────┐        ░ ┌──────────┐
+        q_0: ┤ RZ(θ[0]) ├─░─┤0           ├┤0           ├─■──────░─┤ RZ(θ[5]) ├
+             ├──────────┤ ░ │            ││            │ │      ░ ├──────────┤
+        q_1: ┤ RZ(θ[1]) ├─░─┤  RXX(θ[3]) ├┤  RYY(θ[3]) ├─┼──────░─┤ RZ(θ[6]) ├
+             ├──────────┤ ░ │            ││            │ │θ[4]  ░ ├──────────┤
+        q_2: ┤ RZ(θ[2]) ├─░─┤1           ├┤1           ├─■──────░─┤ RZ(θ[7]) ├
+             └──────────┘ ░ └────────────┘└────────────┘        ░ └──────────┘
+    """
+
+    def __init__(
+        self,
+        num_qubits: int | None = None,
+        mode: str = "iswap",
+        entanglement: str | list[list[int]] | Callable[[int], list[int]] = "full",
+        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 = "ExcitationPreserving",
+        flatten: bool | None = None,
+    ) -> None:
+        """
+        Args:
+            num_qubits: The number of qubits of the ExcitationPreserving circuit.
+            mode: Choose the entangler mode, can be `'iswap'` or `'fsim'`.
+            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'
+                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.
+                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 True, a rotation layer is added at the end of the
+                ansatz. If False, no rotation layer is added. Defaults to True.
+            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.
+
+        Raises:
+            ValueError: If the selected mode is not supported.
+        """
+        supported_modes = ["iswap", "fsim"]
+        if mode not in supported_modes:
+            raise ValueError(f"Unsupported mode {mode}, choose one of {supported_modes}")
+
+        theta = Parameter("θ")
+        swap = QuantumCircuit(2, name="Interaction")
+        swap.rxx(theta, 0, 1)
+        swap.ryy(theta, 0, 1)
+        if mode == "fsim":
+            phi = Parameter("φ")
+            swap.cp(phi, 0, 1)
+
+        super().__init__(
+            num_qubits=num_qubits,
+            rotation_blocks=RZGate,
+            entanglement_blocks=swap,
+            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)]