C贸digo fuente para qiskit.circuit.library.pauli_evolution

# This code is part of Qiskit.
# (C) Copyright IBM 2021, 2023.
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
# Any modifications or derivative works of this code must retain this
# copyright notice, and modified files need to carry a notice indicating
# that they have been altered from the originals.

"""A gate to implement time-evolution of operators."""

from __future__ import annotations

from typing import Union, Optional
import numpy as np

from qiskit.circuit.gate import Gate
from qiskit.circuit.parameterexpression import ParameterExpression
from qiskit.synthesis import EvolutionSynthesis, LieTrotter
from qiskit.quantum_info import Pauli, SparsePauliOp

[documentos]class PauliEvolutionGate(Gate): r"""Time-evolution of an operator consisting of Paulis. For an operator :math:`H` consisting of Pauli terms and (real) evolution time :math:`t` this gate implements .. math:: U(t) = e^{-itH}. This gate serves as a high-level definition of the evolution and can be synthesized into a circuit using different algorithms. The evolution gates are related to the Pauli rotation gates by a factor of 2. For example the time evolution of the Pauli :math:`X` operator is connected to the Pauli :math:`X` rotation :math:`R_X` by .. math:: U(t) = e^{-itX} = R_X(2t). **Examples:** .. code-block:: python from qiskit.circuit import QuantumCircuit from qiskit.circuit.library import PauliEvolutionGate from qiskit.opflow import I, Z, X # build the evolution gate operator = (Z ^ Z) - 0.1 * (X ^ I) evo = PauliEvolutionGate(operator, time=0.2) # plug it into a circuit circuit = QuantumCircuit(2) circuit.append(evo, range(2)) print(circuit.draw()) The above will print (note that the ``-0.1`` coefficient is not printed!):: 鈹屸攢鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹 q_0: 鈹0 鈹 鈹 exp(-it (ZZ + XI))(0.2) 鈹 q_1: 鈹1 鈹 鈹斺攢鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹鈹 **References:** [1] G. Li et al. Paulihedral: A Generalized Block-Wise Compiler Optimization Framework For Quantum Simulation Kernels (2021). [`arXiv:2109.03371 <https://arxiv.org/abs/2109.03371>`_] """ def __init__( self, operator, time: Union[int, float, ParameterExpression] = 1.0, label: Optional[str] = None, synthesis: Optional[EvolutionSynthesis] = None, ) -> None: """ Args: operator (Pauli | PauliOp | SparsePauliOp | PauliSumOp | list): The operator to evolve. Can also be provided as list of non-commuting operators where the elements are sums of commuting operators. For example: ``[XY + YX, ZZ + ZI + IZ, YY]``. time: The evolution time. label: A label for the gate to display in visualizations. Per default, the label is set to ``exp(-it <operators>)`` where ``<operators>`` is the sum of the Paulis. Note that the label does not include any coefficients of the Paulis. See the class docstring for an example. synthesis: A synthesis strategy. If None, the default synthesis is the Lie-Trotter product formula with a single repetition. """ if isinstance(operator, list): operator = [_to_sparse_pauli_op(op) for op in operator] else: operator = _to_sparse_pauli_op(operator) if synthesis is None: synthesis = LieTrotter() if label is None: label = _get_default_label(operator) num_qubits = operator[0].num_qubits if isinstance(operator, list) else operator.num_qubits super().__init__(name="PauliEvolution", num_qubits=num_qubits, params=[time], label=label) self.operator = operator self.synthesis = synthesis @property def time(self) -> Union[float, ParameterExpression]: """Return the evolution time as stored in the gate parameters. Returns: The evolution time. """ return self.params[0] @time.setter def time(self, time: Union[float, ParameterExpression]) -> None: """Set the evolution time. Args: time: The evolution time. """ self.params = [time] def _define(self): """Unroll, where the default synthesis is matrix based.""" self.definition = self.synthesis.synthesize(self)
[documentos] def validate_parameter( self, parameter: Union[int, float, ParameterExpression] ) -> Union[float, ParameterExpression]: """Gate parameters should be int, float, or ParameterExpression""" if isinstance(parameter, int): parameter = float(parameter) return super().validate_parameter(parameter)
def _to_sparse_pauli_op(operator): """Cast the operator to a SparsePauliOp. For Opflow objects, return a global coefficient that must be multiplied to the evolution time. Since this coefficient might contain unbound parameters it cannot be absorbed into the coefficients of the SparsePauliOp. """ # pylint: disable=cyclic-import from qiskit.opflow import PauliSumOp, PauliOp if isinstance(operator, PauliSumOp): sparse_pauli = operator.primitive sparse_pauli._coeffs *= operator.coeff elif isinstance(operator, PauliOp): sparse_pauli = SparsePauliOp(operator.primitive) sparse_pauli._coeffs *= operator.coeff elif isinstance(operator, Pauli): sparse_pauli = SparsePauliOp(operator) elif isinstance(operator, SparsePauliOp): sparse_pauli = operator else: raise ValueError(f"Unsupported operator type for evolution: {type(operator)}.") if any(np.iscomplex(sparse_pauli.coeffs)): raise ValueError("Operator contains complex coefficients, which are not supported.") if any(isinstance(coeff, ParameterExpression) for coeff in sparse_pauli.coeffs): raise ValueError("Operator contains ParameterExpression, which are not supported.") return sparse_pauli def _get_default_label(operator): if isinstance(operator, list): label = f"exp(-it ({[' + '.join(op.paulis.to_labels()) for op in operator]}))" else: if len(operator.paulis) == 1: label = f"exp(-it {operator.paulis.to_labels()[0]})" # for just a single Pauli don't add brackets around the sum else: label = f"exp(-it ({' + '.join(operator.paulis.to_labels())}))" return label