qiskit-aer 0.17.2__cp314-cp314-win_amd64.whl

qiskit_aer/library/save_instructions/save_statevector.py

@@ -0,0 +1,120 @@
+# 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 statevector.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveSingleData
+from ..default_qubits import default_qubits
+
+
+class SaveStatevector(SaveSingleData):
+    """Save statevector"""
+
+    def __init__(self, num_qubits, label="statevector", pershot=False, conditional=False):
+        """Create new instruction to save the simulator statevector.
+
+        Args:
+            num_qubits (int): the number of qubits
+            label (str): the key for retrieving saved data from results.
+            pershot (bool): if True save a list of statevectors 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_statevector", num_qubits, label, pershot=pershot, conditional=conditional
+        )
+
+
+class SaveStatevectorDict(SaveSingleData):
+    """Save statevector as ket-form dictionary."""
+
+    def __init__(self, num_qubits, label="statevector_dict", pershot=False, conditional=False):
+        """Create new instruction to save the simulator statevector as a dict.
+
+        Args:
+            num_qubits (int): the number of qubits
+            label (str): the key for retrieving saved data from results.
+            pershot (bool): if True save a list of statevectors 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_statevector_dict", num_qubits, label, pershot=pershot, conditional=conditional
+        )
+
+
+def save_statevector(self, label="statevector", pershot=False, conditional=False):
+    """Save the current simulator quantum state as a statevector.
+
+    Args:
+        pershot (bool): if True save a list of statevectors for each
+                        shot of the simulation [Default: False].
+        label (str): the key for retrieving saved data from results.
+        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 = SaveStatevector(len(qubits), label=label, pershot=pershot, conditional=conditional)
+    return self.append(instr, qubits)
+
+
+def save_statevector_dict(self, label="statevector", pershot=False, conditional=False):
+    """Save the current simulator quantum state as a statevector as a dict.
+
+    Args:
+        label (str): the key for retrieving saved data from results.
+        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 = SaveStatevectorDict(len(qubits), label=label, pershot=pershot, conditional=conditional)
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_statevector = save_statevector
+QuantumCircuit.save_statevector_dict = save_statevector_dict

qiskit_aer/library/save_instructions/save_superop.py

@@ -0,0 +1,62 @@
+# 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 a SuperOp matrix.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveSingleData
+from ..default_qubits import default_qubits
+
+
+class SaveSuperOp(SaveSingleData):
+    """Save a SuperOp matrix."""
+
+    def __init__(self, num_qubits, label="superop", pershot=False):
+        """Create new instruction to save the superop simulator state.
+
+        Args:
+            num_qubits (int): the number of qubits for the save instruction.
+            label (str): the key for retrieving saved data from results.
+            pershot (bool): if True save a list of SuperOp matrices for each shot
+                            of the simulation [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_superop", num_qubits, label, pershot=pershot)
+
+
+def save_superop(self, label="superop", pershot=False):
+    """Save the current state of the superop simulator.
+
+    Args:
+        label (str): the key for retrieving saved data from results.
+        pershot (bool): if True save a list of SuperOp matrices for each shot
+                        of the  simulation [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    .. note::
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    instr = SaveSuperOp(len(qubits), label=label, pershot=pershot)
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_superop = save_superop

qiskit_aer/library/save_instructions/save_unitary.py

@@ -0,0 +1,63 @@
+# 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 unitary matrix.
+"""
+
+from qiskit.circuit import QuantumCircuit
+from .save_data import SaveSingleData
+from ..default_qubits import default_qubits
+
+
+class SaveUnitary(SaveSingleData):
+    """Save Unitary"""
+
+    def __init__(self, num_qubits, label="unitary", pershot=False):
+        """Create new instruction to save the unitary simulator state.
+
+        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 unitaries for each
+                            shot of the simulation rather than a single
+                            statevector [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_unitary", num_qubits, label, pershot=pershot)
+
+
+def save_unitary(self, label="unitary", pershot=False):
+    """Save the current state of the unitary simulator.
+
+    Args:
+        label (str): the key for retrieving saved data from results.
+        pershot (bool): if True save a list of unitaries for each
+                        shot of the simulation [Default: False].
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    .. note::
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    instr = SaveUnitary(len(qubits), label=label, pershot=pershot)
+    return self.append(instr, qubits)
+
+
+QuantumCircuit.save_unitary = save_unitary

qiskit_aer/library/set_instructions/__init__.py

@@ -0,0 +1,19 @@
+# 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.
+"""Set state directive instructions for the Aer simulator"""
+
+from .set_statevector import SetStatevector, set_statevector
+from .set_density_matrix import SetDensityMatrix, set_density_matrix
+from .set_unitary import SetUnitary, set_unitary
+from .set_stabilizer import SetStabilizer, set_stabilizer
+from .set_superop import SetSuperOp, set_superop
+from .set_matrix_product_state import SetMatrixProductState, set_matrix_product_state

qiskit_aer/library/set_instructions/set_density_matrix.py

@@ -0,0 +1,78 @@
+# 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.
+"""
+Instruction to set the density matrix simulator state to a matrix.
+"""
+
+from qiskit.circuit import QuantumCircuit, Instruction
+from qiskit.quantum_info import DensityMatrix
+from ..default_qubits import default_qubits
+
+
+class SetDensityMatrix(Instruction):
+    """Set density matrix state of the simulator"""
+
+    _directive = True
+
+    def __init__(self, state):
+        """Create new instruction to set the density matrix state of the simulator.
+
+        Args:
+            state (DensityMatrix): a density matrix.
+
+        Raises:
+            ValueError: if the input density matrix is not valid.
+
+        .. note::
+
+            This set instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        if not isinstance(state, DensityMatrix):
+            state = DensityMatrix(state)
+        if not state.num_qubits or not state.is_valid():
+            raise ValueError("The input state is not valid")
+        super().__init__("set_density_matrix", state.num_qubits, 0, [state.data])
+
+
+def set_density_matrix(self, state):
+    """Set the density matrix state of the simulator.
+
+    Args:
+        state (DensityMatrix): a density matrix.
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: If the density matrix is the incorrect size for the
+            current circuit.
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    if not isinstance(state, DensityMatrix):
+        state = DensityMatrix(state)
+    if not state.num_qubits or state.num_qubits != len(qubits):
+        raise ValueError(
+            "The size of the density matrix for the set state"
+            " instruction must be equal to the number of qubits"
+            f" in the circuit (state.num_qubits ({state.num_qubits})"
+            f" != QuantumCircuit.num_qubits ({self.num_qubits}))."
+        )
+    return self.append(SetDensityMatrix(state), qubits)
+
+
+QuantumCircuit.set_density_matrix = set_density_matrix

qiskit_aer/library/set_instructions/set_matrix_product_state.py

@@ -0,0 +1,83 @@
+# 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.
+"""
+Instruction to set the state simulator state to a matrix.
+"""
+
+from qiskit.circuit import QuantumCircuit, Instruction
+from ..default_qubits import default_qubits
+
+
+class SetMatrixProductState(Instruction):
+    """Set the matrix product state of the simulator"""
+
+    _directive = True
+
+    def __init__(self, state):
+        """Create new instruction to set the matrix product state of the simulator.
+
+        Args:
+            state (Tuple[List[Tuple[np.array[complex_t]]]], List[List[float]]):
+                  A matrix_product_state.
+
+        .. note::
+
+            This set instruction must always be performed on the full width of
+            qubits in a circuit.
+            The matrix_product_state consists of a pair of vectors. The first is a
+            vector of pairs of matrices of complex numbers. The second is a vector of
+            vectors of double.
+        """
+        super().__init__("set_matrix_product_state", len(state[0]), 0, [state])
+
+
+def set_matrix_product_state(self, state):
+    """Set the matrix product state of the simulator.
+
+    Args:
+        state (Tuple[List[Tuple[np.array[complex_t]]]], List[List[float]]):
+              A matrix_product_state.
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: If the structure of the state is incorrect
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    if not isinstance(state, tuple) or len(state) != 2:
+        raise ValueError(
+            "The input matrix product state is not valid.  Should be a list of 2 elements"
+        )
+    if not isinstance(state[0], list) or not isinstance(state[1], list):
+        raise ValueError(
+            "The first element of the input matrix product state is not valid. Should be a list."
+        )
+    if len(state[0]) != len(state[1]) + 1:
+        raise ValueError(
+            "The input matrix product state is not valid. "
+            "Length of q_reg vector should be 1 more than length of lambda_reg"
+        )
+    for elem in state[0]:
+        if not isinstance(elem, tuple) or len(elem) != 2:
+            raise ValueError(
+                "The input matrix product state is not valid."
+                "The first element should be a list of length 2"
+            )
+    return self.append(SetMatrixProductState(state), qubits)
+
+
+QuantumCircuit.set_matrix_product_state = set_matrix_product_state

qiskit_aer/library/set_instructions/set_stabilizer.py

@@ -0,0 +1,77 @@
+# 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.
+"""
+Instruction to set the simulator state to a stabilizer state.
+"""
+
+from qiskit.circuit import QuantumCircuit, Instruction
+from qiskit.quantum_info import StabilizerState, Clifford
+from ..default_qubits import default_qubits
+
+
+class SetStabilizer(Instruction):
+    """Set the Clifford stabilizer state of the simulator"""
+
+    _directive = True
+
+    def __init__(self, state):
+        """Create new instruction to set the Clifford stabilizer state of the simulator.
+
+        Args:
+            state (StabilizerState or Clifford): A clifford operator.
+
+        .. note::
+
+            This set instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        if isinstance(state, StabilizerState):
+            state = state.clifford
+        elif not isinstance(state, Clifford):
+            state = Clifford(state)
+        super().__init__("set_stabilizer", state.num_qubits, 0, [state.to_dict()])
+
+
+def set_stabilizer(self, state):
+    """Set the Clifford stabilizer state of the simulator.
+
+    Args:
+        state (Clifford): A clifford operator.
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: If the state is the incorrect size for the
+            current circuit.
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    if isinstance(state, StabilizerState):
+        state = state.clifford
+    if not isinstance(state, Clifford):
+        state = Clifford(state)
+    if state.num_qubits != len(qubits):
+        raise ValueError(
+            "The size of the Clifford for the set_stabilizer"
+            " instruction must be equal to the number of qubits"
+            f" in the circuit (state.num_qubits ({state.num_qubits})"
+            f" != QuantumCircuit.num_qubits ({self.num_qubits}))."
+        )
+    return self.append(SetStabilizer(state), qubits)
+
+
+QuantumCircuit.set_stabilizer = set_stabilizer

qiskit_aer/library/set_instructions/set_statevector.py

@@ -0,0 +1,78 @@
+# 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.
+"""
+Instruction to set the state simulator state to a matrix.
+"""
+
+from qiskit.circuit import QuantumCircuit, Instruction
+from qiskit.quantum_info import Statevector
+from ..default_qubits import default_qubits
+
+
+class SetStatevector(Instruction):
+    """Set the statevector state of the simulator"""
+
+    _directive = True
+
+    def __init__(self, state):
+        """Create new instruction to set the statevector state of the simulator.
+
+        Args:
+            state (Statevector): a statevector.
+
+        Raises:
+            ValueError: if the input is not a valid state.
+
+        .. note::
+
+            This set instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        if not isinstance(state, Statevector):
+            state = Statevector(state)
+        if not state.num_qubits or not state.is_valid():
+            raise ValueError("The input statevector is not valid")
+        super().__init__("set_statevector", state.num_qubits, 0, [state.data])
+
+
+def set_statevector(self, state):
+    """Set the statevector state of the simulator.
+
+    Args:
+        state (Statevector): A state matrix.
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: If the state is the incorrect size for the
+            current circuit.
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    if not isinstance(state, Statevector):
+        state = Statevector(state)
+    if not state.num_qubits or state.num_qubits != len(qubits):
+        raise ValueError(
+            "The size of the statevector for the set_statevector"
+            " instruction must be equal to the number of qubits"
+            f" in the circuit (state.num_qubits ({state.num_qubits})"
+            f" != QuantumCircuit.num_qubits ({self.num_qubits}))."
+        )
+    return self.append(SetStatevector(state), qubits)
+
+
+QuantumCircuit.set_statevector = set_statevector

qiskit_aer/library/set_instructions/set_superop.py

@@ -0,0 +1,78 @@
+# 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.
+"""
+Instruction to set the state simulator state to a superop matrix.
+"""
+
+from qiskit.circuit import QuantumCircuit, Instruction
+from qiskit.quantum_info import SuperOp
+from ..default_qubits import default_qubits
+
+
+class SetSuperOp(Instruction):
+    """Set superop state of the simulator"""
+
+    _directive = True
+
+    def __init__(self, state):
+        """Create new instruction to set the superop simulator state.
+
+        Args:
+            state (QuantumChannel): A CPTP quantum channel.
+
+        Raises:
+            ValueError: if the input QuantumChannel is not CPTP.
+
+        .. note::
+
+            This set instruction must always be performed on the full width of
+            qubits in a circuit, otherwise an exception will be raised during
+            simulation.
+        """
+        if not isinstance(state, SuperOp):
+            state = SuperOp(state)
+        if not state.num_qubits or not state.is_cptp():
+            raise ValueError("The input quantum channel is not CPTP")
+        super().__init__("set_superop", state.num_qubits, 0, [state.data])
+
+
+def set_superop(self, state):
+    """Set the superop state of the simulator.
+
+    Args:
+        state (QuantumChannel): A CPTP quantum channel.
+
+    Returns:
+        QuantumCircuit: with attached instruction.
+
+    Raises:
+        ValueError: If the state is the incorrect size for the current circuit.
+        ValueError: if the input QuantumChannel is not CPTP.
+
+    .. note:
+
+        This instruction is always defined across all qubits in a circuit.
+    """
+    qubits = default_qubits(self)
+    if not isinstance(state, SuperOp):
+        state = SuperOp(state)
+    if not state.num_qubits or state.num_qubits != len(qubits):
+        raise ValueError(
+            "The size of the quantum channel for the set_superop"
+            " instruction must be equal to the number of qubits"
+            f" in the circuit (state.num_qubits ({state.num_qubits})"
+            f" != QuantumCircuit.num_qubits ({self.num_qubits}))."
+        )
+    return self.append(SetSuperOp(state), qubits)
+
+
+QuantumCircuit.set_superop = set_superop