qiskit-aer 0.17.2__cp314-cp314-win_amd64.whl

qiskit_aer/library/save_instructions/save_expectation_value.py

@@ -0,0 +1,257 @@
+# 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.
+"""
+Simulator instruction to save exact operator expectation value.
+"""
+
+from numpy import allclose
+from qiskit.quantum_info import Pauli, SparsePauliOp, Operator
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveAverageData
+
+
+class SaveExpectationValue(SaveAverageData):
+    """Save expectation value of an operator."""
+
+    def __init__(
+        self,
+        operator,
+        label="expectation_value",
+        unnormalized=False,
+        pershot=False,
+        conditional=False,
+    ):
+        r"""Instruction to save the expectation value of a Hermitian operator.
+
+        The expectation value of a Hermitian operator :math:`H` for a simulator
+        in quantum state :math`\rho`is given by
+        :math:`\langle H\rangle = \mbox{Tr}[H.\rho]`.
+
+        Args:
+            operator (Pauli or SparsePauliOp or Operator): a Hermitian operator.
+            label (str): the key for retrieving saved data from results.
+            unnormalized (bool): If True return save the unnormalized accumulated
+                                 or conditional accumulated expectation value
+                                 over all shot [Default: False].
+            pershot (bool): if True save a list of expectation values for each shot
+                            of the simulation rather than the average over
+                            all shots [Default: False].
+            conditional (bool): if True save the average or pershot data
+                                conditional on the current classical register
+                                values [Default: False].
+
+        Raises:
+            ValueError: if the input operator is not Hermitian.
+            TypeError: if the input operator is of invalid type.
+
+        .. note::
+
+            This instruction can be directly appended to a circuit using the
+            :func:`save_expectation_value` circuit method.
+        """
+        # Convert O to SparsePauliOp representation
+        if isinstance(operator, Pauli):
+            operator = SparsePauliOp(operator)
+        elif not isinstance(operator, SparsePauliOp):
+            operator = SparsePauliOp.from_operator(Operator(operator))
+        if not allclose(operator.coeffs.imag, 0):
+            raise ValueError("Input operator is not Hermitian.")
+        params = _expval_params(operator, variance=False)
+        super().__init__(
+            "save_expval",
+            operator.num_qubits,
+            label,
+            unnormalized=unnormalized,
+            pershot=pershot,
+            conditional=conditional,
+            params=params,
+        )
+
+
+class SaveExpectationValueVariance(SaveAverageData):
+    """Save expectation value and variance of an operator."""
+
+    def __init__(
+        self,
+        operator,
+        label="expectation_value_variance",
+        unnormalized=False,
+        pershot=False,
+        conditional=False,
+    ):
+        r"""Instruction to save the expectation value and variance of a Hermitian operator.
+
+        The expectation value of a Hermitian operator :math:`H` for a
+        simulator in quantum state :math`\rho`is given by
+        :math:`\langle H\rangle = \mbox{Tr}[H.\rho]`. The variance is given by
+        :math:`\sigma^2 = \langle H^2 \rangle - \langle H \rangle>^2`.
+
+        Args:
+            operator (Pauli or SparsePauliOp or Operator): a Hermitian operator.
+            label (str): the key for retrieving saved data from results.
+            unnormalized (bool): If True return save the unnormalized accumulated
+                                 or conditional accumulated expectation value
+                                 over all shot [Default: False].
+            pershot (bool): if True save a list of expectation values for each shot
+                            of the simulation rather than the average over
+                            all shots [Default: False].
+            conditional (bool): if True save the average or pershot data
+                                conditional on the current classical register
+                                values [Default: False].
+
+        Raises:
+            ValueError: if the input operator is not Hermitian.
+            TypeError: if the input operator is of invalid type.
+
+        .. note::
+
+            This instruction can be directly appended to a circuit using
+            the :func:`save_expectation_value` circuit method.
+        """
+        # Convert O to SparsePauliOp representation
+        if isinstance(operator, Pauli):
+            operator = SparsePauliOp(operator)
+        elif not isinstance(operator, SparsePauliOp):
+            operator = SparsePauliOp.from_operator(Operator(operator))
+        if not allclose(operator.coeffs.imag, 0):
+            raise ValueError("Input operator is not Hermitian.")
+        params = _expval_params(operator, variance=True)
+        super().__init__(
+            "save_expval_var",
+            operator.num_qubits,
+            label,
+            unnormalized=unnormalized,
+            pershot=pershot,
+            conditional=conditional,
+            params=params,
+        )
+
+
+def _expval_params(operator, variance=False):
+    # Convert O to SparsePauliOp representation
+    if isinstance(operator, Pauli):
+        operator = SparsePauliOp(operator)
+    elif not isinstance(operator, SparsePauliOp):
+        operator = SparsePauliOp.from_operator(Operator(operator))
+    if not isinstance(operator, SparsePauliOp):
+        raise TypeError("Invalid input operator")
+
+    params = {}
+
+    # Add Pauli basis components of O
+    for pauli, coeff in operator.label_iter():
+        if pauli in params:
+            coeff1 = params[pauli][0]
+            params[pauli] = (coeff1 + coeff.real, 0)
+        else:
+            params[pauli] = (coeff.real, 0)
+
+    # Add Pauli basis components of O^2
+    if variance:
+        for pauli, coeff in operator.dot(operator).label_iter():
+            if pauli in params:
+                coeff1, coeff2 = params[pauli]
+                params[pauli] = (coeff1, coeff2 + coeff.real)
+            else:
+                params[pauli] = (0, coeff.real)
+
+    # Convert to list
+    return list(params.items())
+
+
+def save_expectation_value(
+    self,
+    operator,
+    qubits,
+    label="expectation_value",
+    unnormalized=False,
+    pershot=False,
+    conditional=False,
+):
+    r"""Save the expectation value of a Hermitian operator.
+
+    Args:
+        operator (Pauli or SparsePauliOp or Operator): a Hermitian operator.
+        qubits (list): circuit qubits to apply instruction.
+        label (str): the key for retrieving saved data from results.
+        unnormalized (bool): If True return save the unnormalized accumulated
+                             or conditional accumulated expectation value
+                             over all shot [Default: False].
+        pershot (bool): if True save a list of expectation values for each
+                        shot of the simulation rather than the average over
+                        all shots [Default: False].
+        conditional (bool): if True save the average or pershot data
+                            conditional on the current classical register
+                            values [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: if the input operator is not Hermitian.
+        TypeError: if the input operator is of invalid type.
+
+    .. note::
+
+        This method appends a :class:`SaveExpectationValue` instruction to
+        the quantum circuit.
+    """
+    instr = SaveExpectationValue(
+        operator, label=label, unnormalized=unnormalized, pershot=pershot, conditional=conditional
+    )
+    return self.append(instr, qubits)
+
+
+def save_expectation_value_variance(
+    self,
+    operator,
+    qubits,
+    label="expectation_value_variance",
+    unnormalized=False,
+    pershot=False,
+    conditional=False,
+):
+    r"""Save the expectation value of a Hermitian operator.
+
+    Args:
+        operator (Pauli or SparsePauliOp or Operator): a Hermitian operator.
+        qubits (list): circuit qubits to apply instruction.
+        label (str): the key for retrieving saved data from results.
+        unnormalized (bool): If True return save the unnormalized accumulated
+                             or conditional accumulated expectation value
+                             and variance over all shot [Default: False].
+        pershot (bool): if True save a list of expectation values and
+                        variances for each shot of the simulation rather than
+                        the average over all shots [Default: False].
+        conditional (bool): if True save the data conditional on the current
+                            classical register values [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: if the input operator is not Hermitian.
+        TypeError: if the input operator is of invalid type.
+
+    .. note::
+
+        This method appends a :class:`SaveExpectationValueVariance`
+        instruction to the quantum circuit.
+    """
+    instr = SaveExpectationValueVariance(
+        operator, label=label, unnormalized=unnormalized, pershot=pershot, conditional=conditional
+    )
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_expectation_value = save_expectation_value
+QuantumCircuit.save_expectation_value_variance = save_expectation_value_variance

qiskit_aer/library/save_instructions/save_matrix_product_state.py

@@ -0,0 +1,71 @@
+# 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.
+"""
+Simulator instruction to save matrix product state.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveSingleData
+from ..default_qubits import default_qubits
+
+
+class SaveMatrixProductState(SaveSingleData):
+    """Save matrix product state instruction"""
+
+    def __init__(self, num_qubits, label="matrix_product_state", pershot=False, conditional=False):
+        """Create new instruction to save the matrix product state.
+
+        Args:
+            num_qubits (int): the number of qubits
+            label (str): the key for retrieving saved data from results.
+            pershot (bool): if True save the mps for each
+                            shot of the simulation [Default: False].
+            conditional (bool): if True save data conditional on the current
+                                classical register values [Default: False].
+
+        .. note::
+
+            This save instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        super().__init__(
+            "save_matrix_product_state", num_qubits, label, pershot=pershot, conditional=conditional
+        )
+
+
+def save_matrix_product_state(self, label="matrix_product_state", pershot=False, conditional=False):
+    """Save the current simulator quantum state as a matrix product state.
+
+    Args:
+        label (str): the key for retrieving saved data from results.
+        pershot (bool): if True save the mps for each
+                        shot of the simulation [Default: False].
+        conditional (bool): if True save pershot data conditional on the
+                            current classical register values
+                            [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    instr = SaveMatrixProductState(
+        len(qubits), label=label, pershot=pershot, conditional=conditional
+    )
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_matrix_product_state = save_matrix_product_state

qiskit_aer/library/save_instructions/save_probabilities.py

@@ -0,0 +1,156 @@
+# 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.
+"""
+Simulator instruction to save measurement outcome probabilities.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveAverageData
+from ..default_qubits import default_qubits
+
+
+class SaveProbabilities(SaveAverageData):
+    """Save measurement outcome probabilities vector."""
+
+    def __init__(
+        self,
+        num_qubits,
+        label="probabilities",
+        unnormalized=False,
+        pershot=False,
+        conditional=False,
+    ):
+        """Instruction to save measurement probabilities vector.
+
+        Args:
+            num_qubits (int): the number of qubits for the snapshot type.
+            label (str): the key for retrieving saved data from results.
+            unnormalized (bool): If True return save the unnormalized accumulated
+                                 probabilities over all shots [Default: False].
+            pershot (bool): if True save a list of probabilities for each shot
+                            of the simulation rather than the average over
+                            all shots [Default: False].
+            conditional (bool): if True save the probabilities data conditional
+                                on the current classical register values
+                                [Default: False].
+        """
+        super().__init__(
+            "save_probabilities",
+            num_qubits,
+            label,
+            conditional=conditional,
+            pershot=pershot,
+            unnormalized=unnormalized,
+        )
+
+
+class SaveProbabilitiesDict(SaveAverageData):
+    """Save measurement outcome probabilities dict."""
+
+    def __init__(
+        self,
+        num_qubits,
+        label="probabilities_dict",
+        unnormalized=False,
+        pershot=False,
+        conditional=False,
+    ):
+        """Instruction to save measurement probabilities dict.
+
+        Args:
+            num_qubits (int): the number of qubits for the snapshot type.
+            label (str): the key for retrieving saved data from results.
+            unnormalized (bool): If True return save the unnormalized accumulated
+                                 probabilities over all shots [Default: False].
+            pershot (bool): if True save a list of probabilities for each shot
+                            of the simulation rather than the average over
+                            all shots [Default: False].
+            conditional (bool): if True save the probabilities data conditional
+                                on the current classical register values
+                                [Default: False].
+        """
+        super().__init__(
+            "save_probabilities_dict",
+            num_qubits,
+            label,
+            unnormalized=unnormalized,
+            pershot=pershot,
+            conditional=conditional,
+        )
+
+
+def save_probabilities(
+    self, qubits=None, label="probabilities", unnormalized=False, pershot=False, conditional=False
+):
+    """Save measurement outcome probabilities vector.
+
+    Args:
+        qubits (list or None): the qubits to apply snapshot to. If None all
+                               qubits will be snapshot [Default: None].
+        label (str): the key for retrieving saved data from results.
+        unnormalized (bool): If True return save the unnormalized accumulated
+                             probabilities over all shots [Default: False].
+        pershot (bool): if True save a list of probabilities for each shot
+                        of the simulation rather than the average over
+                        all shots [Default: False].
+        conditional (bool): if True save the probabilities data conditional
+                            on the current classical register values
+                            [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+    """
+    qubits = default_qubits(self, qubits=qubits)
+    instr = SaveProbabilities(
+        len(qubits),
+        label=label,
+        unnormalized=unnormalized,
+        pershot=pershot,
+        conditional=conditional,
+    )
+    return self.append(instr, qubits)
+
+
+def save_probabilities_dict(
+    self, qubits=None, label="probabilities", unnormalized=False, pershot=False, conditional=False
+):
+    """Save measurement outcome probabilities vector.
+
+    Args:
+        qubits (list or None): the qubits to apply snapshot to. If None all
+                               qubits will be snapshot [Default: None].
+        label (str): the key for retrieving saved data from results.
+        unnormalized (bool): If True return save the unnormalized accumulated
+                             probabilities over all shots [Default: False].
+        pershot (bool): if True save a list of probabilities for each shot
+                        of the simulation rather than the average over
+                        all shots [Default: False].
+        conditional (bool): if True save the probabilities data conditional
+                            on the current classical register values
+                            [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+    """
+    qubits = default_qubits(self, qubits=qubits)
+    instr = SaveProbabilitiesDict(
+        len(qubits),
+        label=label,
+        unnormalized=unnormalized,
+        pershot=pershot,
+        conditional=conditional,
+    )
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_probabilities = save_probabilities
+QuantumCircuit.save_probabilities_dict = save_probabilities_dict

qiskit_aer/library/save_instructions/save_stabilizer.py

@@ -0,0 +1,70 @@
+# 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.
+"""
+Simulator instruction to save Clifford state.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveSingleData
+from ..default_qubits import default_qubits
+
+
+class SaveStabilizer(SaveSingleData):
+    """Save Stabilizer instruction"""
+
+    def __init__(self, num_qubits, label="stabilizer", pershot=False, conditional=False):
+        """Create new instruction to save the stabilizer simulator state as a StabilizerState.
+
+        Args:
+            num_qubits (int): the number of qubits of the
+            label (str): the key for retrieving saved data from results.
+            pershot (bool): if True save a list of StabilizerStates for each
+                            shot of the simulation rather than a single
+                            statevector [Default: False].
+            conditional (bool): if True save data conditional on the current
+                                classical register values [Default: False].
+
+        .. note::
+
+            This save instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        super().__init__(
+            "save_stabilizer", num_qubits, label, pershot=pershot, conditional=conditional
+        )
+
+
+def save_stabilizer(self, label="stabilizer", pershot=False, conditional=False):
+    """Save the current stabilizer simulator quantum state as a StabilizerState.
+
+    Args:
+        label (str): the key for retrieving saved data from results.
+        pershot (bool): if True save a list of StabilizerStates for each
+                        shot of the simulation [Default: False].
+        conditional (bool): if True save pershot data conditional on the
+                            current classical register values
+                            [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    .. note::
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    instr = SaveStabilizer(len(qubits), label=label, pershot=pershot, conditional=conditional)
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_stabilizer = save_stabilizer

qiskit_aer/library/save_instructions/save_state.py

@@ -0,0 +1,79 @@
+# 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.
+"""
+Simulator instruction to save simulator state.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveSingleData
+from ..default_qubits import default_qubits
+
+
+class SaveState(SaveSingleData):
+    """Save simulator state
+
+    The format of the saved state depends on the simulation method used.
+    """
+
+    def __init__(self, num_qubits, label=None, pershot=False, conditional=False):
+        """Create new instruction to save the simulator state.
+
+        The format of the saved state depends on the simulation method used.
+
+        Args:
+            num_qubits (int): the number of qubits of the
+            label (str or None): Optional, the key for retrieving saved data
+                                 from results. If None the key will be the
+                                 state type of the simulator.
+            pershot (bool): if True save a list of states for each
+                            shot of the simulation rather than a single
+                            state [Default: False].
+            conditional (bool): if True save data conditional on the current
+                                classical register values [Default: False].
+
+        .. note::
+
+            This save instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        if label is None:
+            label = "_method_"
+        super().__init__("save_state", num_qubits, label, pershot=pershot, conditional=conditional)
+
+
+def save_state(self, label=None, pershot=False, conditional=False):
+    """Save the current simulator quantum state.
+
+    Args:
+        label (str or None): Optional, the key for retrieving saved data
+                             from results. If None the key will be the
+                             state type of the simulator.
+        pershot (bool): if True save a list of statevectors for each
+                        shot of the simulation [Default: False].
+        conditional (bool): if True save pershot data conditional on the
+                            current classical register values
+                            [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    instr = SaveState(len(qubits), label=label, pershot=pershot, conditional=conditional)
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_state = save_state