qiskit 1.4.0__cp39-abi3-macosx_11_0_arm64.whl → 2.0.0rc1__cp39-abi3-macosx_11_0_arm64.whl

qiskit/pulse/instructions/phase.py

@@ -1,152 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 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 phase instructions update the modulation phase of pulses played on a channel.
-This includes ``SetPhase`` instructions which lock the modulation to a particular phase
-at that moment, and ``ShiftPhase`` instructions which increase the existing phase by a
-relative amount.
-"""
-from typing import Optional, Union, Tuple
-
-from qiskit.circuit import ParameterExpression
-from qiskit.pulse.channels import PulseChannel
-from qiskit.pulse.instructions.instruction import Instruction
-from qiskit.pulse.exceptions import PulseError
-from qiskit.utils.deprecate_pulse import deprecate_pulse_func
-
-
-class ShiftPhase(Instruction):
-    r"""The shift phase instruction updates the modulation phase of proceeding pulses played on the
-    same :py:class:`~qiskit.pulse.channels.Channel`. It is a relative increase in phase determined
-    by the ``phase`` operand.
-
-    In particular, a PulseChannel creates pulses of the form
-
-    .. math::
-        Re[\exp(i 2\pi f jdt + \phi) d_j].
-
-    The ``ShiftPhase`` instruction causes :math:`\phi` to be increased by the instruction's
-    ``phase`` operand. This will affect all pulses following on the same channel.
-
-    The qubit phase is tracked in software, enabling instantaneous, nearly error-free Z-rotations
-    by using a ShiftPhase to update the frame tracking the qubit state.
-    """
-
-    @deprecate_pulse_func
-    def __init__(
-        self,
-        phase: Union[complex, ParameterExpression],
-        channel: PulseChannel,
-        name: Optional[str] = None,
-    ):
-        """Instantiate a shift phase instruction, increasing the output signal phase on ``channel``
-        by ``phase`` [radians].
-
-        Args:
-            phase: The rotation angle in radians.
-            channel: The channel this instruction operates on.
-            name: Display name for this instruction.
-        """
-        super().__init__(operands=(phase, channel), name=name)
-
-    def _validate(self):
-        """Called after initialization to validate instruction data.
-
-        Raises:
-            PulseError: If the input ``channel`` is not type :class:`PulseChannel`.
-        """
-        if not isinstance(self.channel, PulseChannel):
-            raise PulseError(f"Expected a pulse channel, got {self.channel} instead.")
-
-    @property
-    def phase(self) -> Union[complex, ParameterExpression]:
-        """Return the rotation angle enacted by this instruction in radians."""
-        return self.operands[0]
-
-    @property
-    def channel(self) -> PulseChannel:
-        """Return the :py:class:`~qiskit.pulse.channels.Channel` that this instruction is
-        scheduled on.
-        """
-        return self.operands[1]
-
-    @property
-    def channels(self) -> Tuple[PulseChannel]:
-        """Returns the channels that this schedule uses."""
-        return (self.channel,)
-
-    @property
-    def duration(self) -> int:
-        """Duration of this instruction."""
-        return 0
-
-
-class SetPhase(Instruction):
-    r"""The set phase instruction sets the phase of the proceeding pulses on that channel
-    to ``phase`` radians.
-
-    In particular, a PulseChannel creates pulses of the form
-
-    .. math::
-
-        Re[\exp(i 2\pi f jdt + \phi) d_j]
-
-    The ``SetPhase`` instruction sets :math:`\phi` to the instruction's ``phase`` operand.
-    """
-
-    @deprecate_pulse_func
-    def __init__(
-        self,
-        phase: Union[complex, ParameterExpression],
-        channel: PulseChannel,
-        name: Optional[str] = None,
-    ):
-        """Instantiate a set phase instruction, setting the output signal phase on ``channel``
-        to ``phase`` [radians].
-
-        Args:
-            phase: The rotation angle in radians.
-            channel: The channel this instruction operates on.
-            name: Display name for this instruction.
-        """
-        super().__init__(operands=(phase, channel), name=name)
-
-    def _validate(self):
-        """Called after initialization to validate instruction data.
-
-        Raises:
-            PulseError: If the input ``channel`` is not type :class:`PulseChannel`.
-        """
-        if not isinstance(self.channel, PulseChannel):
-            raise PulseError(f"Expected a pulse channel, got {self.channel} instead.")
-
-    @property
-    def phase(self) -> Union[complex, ParameterExpression]:
-        """Return the rotation angle enacted by this instruction in radians."""
-        return self.operands[0]
-
-    @property
-    def channel(self) -> PulseChannel:
-        """Return the :py:class:`~qiskit.pulse.channels.Channel` that this instruction is
-        scheduled on.
-        """
-        return self.operands[1]
-
-    @property
-    def channels(self) -> Tuple[PulseChannel]:
-        """Returns the channels that this schedule uses."""
-        return (self.channel,)
-
-    @property
-    def duration(self) -> int:
-        """Duration of this instruction."""
-        return 0

qiskit/pulse/instructions/play.py

@@ -1,99 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 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.
-
-"""An instruction to transmit a given pulse on a ``PulseChannel`` (i.e., those which support
-transmitted pulses, such as ``DriveChannel``).
-"""
-from __future__ import annotations
-
-from qiskit.circuit import Parameter
-from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.pulse.channels import PulseChannel
-from qiskit.pulse.exceptions import PulseError
-from qiskit.pulse.instructions.instruction import Instruction
-from qiskit.pulse.library.pulse import Pulse
-from qiskit.utils.deprecate_pulse import deprecate_pulse_func
-
-
-class Play(Instruction):
-    """This instruction is responsible for applying a pulse on a channel.
-
-    The pulse specifies the exact time dynamics of the output signal envelope for a limited
-    time. The output is modulated by a phase and frequency which are controlled by separate
-    instructions. The pulse duration must be fixed, and is implicitly given in terms of the
-    cycle time, dt, of the backend.
-    """
-
-    @deprecate_pulse_func
-    def __init__(self, pulse: Pulse, channel: PulseChannel, name: str | None = None):
-        """Create a new pulse instruction.
-
-        Args:
-            pulse: A pulse waveform description, such as
-                   :py:class:`~qiskit.pulse.library.Waveform`.
-            channel: The channel to which the pulse is applied.
-            name: Name of the instruction for display purposes. Defaults to ``pulse.name``.
-        """
-        if name is None:
-            name = pulse.name
-        super().__init__(operands=(pulse, channel), name=name)
-
-    def _validate(self):
-        """Called after initialization to validate instruction data.
-
-        Raises:
-            PulseError: If pulse is not a Pulse type.
-            PulseError: If the input ``channel`` is not type :class:`PulseChannel`.
-        """
-        if not isinstance(self.pulse, Pulse):
-            raise PulseError("The `pulse` argument to `Play` must be of type `library.Pulse`.")
-
-        if not isinstance(self.channel, PulseChannel):
-            raise PulseError(f"Expected a pulse channel, got {self.channel} instead.")
-
-    @property
-    def pulse(self) -> Pulse:
-        """A description of the samples that will be played."""
-        return self.operands[0]
-
-    @property
-    def channel(self) -> PulseChannel:
-        """Return the :py:class:`~qiskit.pulse.channels.Channel` that this instruction is
-        scheduled on.
-        """
-        return self.operands[1]
-
-    @property
-    def channels(self) -> tuple[PulseChannel]:
-        """Returns the channels that this schedule uses."""
-        return (self.channel,)
-
-    @property
-    def duration(self) -> int | ParameterExpression:
-        """Duration of this instruction."""
-        return self.pulse.duration
-
-    @property
-    def parameters(self) -> set[Parameter]:
-        """Parameters which determine the instruction behavior."""
-        parameters: set[Parameter] = set()
-
-        # Note that Pulse.parameters returns dict rather than set for convention.
-        # We need special handling for Play instruction.
-        for pulse_param_expr in self.pulse.parameters.values():
-            if isinstance(pulse_param_expr, ParameterExpression):
-                parameters = parameters | pulse_param_expr.parameters
-
-        if self.channel.is_parameterized():
-            parameters = parameters | self.channel.parameters
-
-        return parameters

qiskit/pulse/instructions/reference.py

@@ -1,100 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2022.
-#
-# 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.
-
-"""Reference instruction that is a placeholder for subroutine."""
-from __future__ import annotations
-
-from qiskit.circuit.parameterexpression import ParameterExpression
-from qiskit.pulse.channels import Channel
-from qiskit.pulse.exceptions import PulseError, UnassignedReferenceError
-from qiskit.pulse.instructions import instruction
-from qiskit.utils.deprecate_pulse import deprecate_pulse_func
-
-
-class Reference(instruction.Instruction):
-    """Pulse compiler directive that refers to a subroutine.
-
-    If a pulse program uses the same subset of instructions multiple times, then
-    using the :class:`~.Reference` class may significantly reduce the memory footprint of
-    the program. This instruction only stores the set of strings to identify the subroutine.
-
-    The actual pulse program can be stored in the :attr:`ScheduleBlock.references` of the
-    :class:`.ScheduleBlock` that this reference instruction belongs to.
-
-    You can later assign schedules with the :meth:`ScheduleBlock.assign_references` method.
-    This allows you to build the main program without knowing the actual subroutine,
-    that is supplied at a later time.
-    """
-
-    # Delimiter for representing nested scope.
-    scope_delimiter = "::"
-
-    # Delimiter for tuple keys.
-    key_delimiter = ","
-
-    @deprecate_pulse_func
-    def __init__(self, name: str, *extra_keys: str):
-        """Create new reference.
-
-        Args:
-            name: Name of subroutine.
-            extra_keys: Optional. A set of string keys that may be necessary to
-                refer to a particular subroutine. For example, when we use
-                "sx" as a name to refer to the subroutine of an sx pulse,
-                this name might be used among schedules for different qubits.
-                In this example, you may specify "q0" in the extra keys
-                to distinguish the sx schedule for qubit 0 from others.
-                The user can use an arbitrary number of extra string keys to
-                uniquely determine the subroutine.
-        """
-        # Run validation
-        ref_keys = (name,) + tuple(extra_keys)
-        super().__init__(operands=ref_keys, name=name)
-
-    def _validate(self):
-        """Called after initialization to validate instruction data.
-
-        Raises:
-            PulseError: When a key is not a string.
-            PulseError: When a key in ``ref_keys`` contains the scope delimiter.
-        """
-        for key in self.ref_keys:
-            if not isinstance(key, str):
-                raise PulseError(f"Keys must be strings. '{repr(key)}' is not a valid object.")
-            if self.scope_delimiter in key or self.key_delimiter in key:
-                raise PulseError(
-                    f"'{self.scope_delimiter}' and '{self.key_delimiter}' are reserved. "
-                    f"'{key}' is not a valid key string."
-                )
-
-    @property
-    def ref_keys(self) -> tuple[str, ...]:
-        """Returns unique key of the subroutine."""
-        return self.operands
-
-    @property
-    def duration(self) -> int | ParameterExpression:
-        """Duration of this instruction."""
-        raise UnassignedReferenceError(f"Subroutine is not assigned to {self.ref_keys}.")
-
-    @property
-    def channels(self) -> tuple[Channel, ...]:
-        """Returns the channels that this schedule uses."""
-        raise UnassignedReferenceError(f"Subroutine is not assigned to {self.ref_keys}.")
-
-    @property
-    def parameters(self) -> set:
-        """Parameters which determine the instruction behavior."""
-        return set()
-
-    def __repr__(self) -> str:
-        return f"{self.__class__.__name__}({self.key_delimiter.join(self.ref_keys)})"

qiskit/pulse/instructions/snapshot.py

@@ -1,82 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2019.
-#
-# 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 simulator instruction to capture output within a simulation. The types of snapshot
-instructions available are determined by the simulator being used.
-"""
-from typing import Optional, Tuple
-
-from qiskit.pulse.channels import SnapshotChannel
-from qiskit.pulse.exceptions import PulseError
-from qiskit.pulse.instructions.instruction import Instruction
-from qiskit.utils.deprecate_pulse import deprecate_pulse_func
-
-
-class Snapshot(Instruction):
-    """An instruction targeted for simulators, to capture a moment in the simulation."""
-
-    @deprecate_pulse_func
-    def __init__(self, label: str, snapshot_type: str = "statevector", name: Optional[str] = None):
-        """Create new snapshot.
-
-        Args:
-            label: Snapshot label which is used to identify the snapshot in the output.
-            snapshot_type: Type of snapshot, e.g., “state” (take a snapshot of the quantum state).
-                           The types of snapshots offered are defined by the simulator used.
-            name: Snapshot name which defaults to ``label``. This parameter is only for display
-                  purposes and is not taken into account during comparison.
-        """
-        self._channel = SnapshotChannel()
-
-        if name is None:
-            name = label
-        super().__init__(operands=(label, snapshot_type), name=name)
-
-    def _validate(self):
-        """Called after initialization to validate instruction data.
-
-        Raises:
-            PulseError: If snapshot label is invalid.
-        """
-        if not isinstance(self.label, str):
-            raise PulseError("Snapshot label must be a string.")
-
-    @property
-    def label(self) -> str:
-        """Label of snapshot."""
-        return self.operands[0]
-
-    @property
-    def type(self) -> str:
-        """Type of snapshot."""
-        return self.operands[1]
-
-    @property
-    def channel(self) -> SnapshotChannel:
-        """Return the :py:class:`~qiskit.pulse.channels.Channel` that this instruction is
-        scheduled on; trivially, a ``SnapshotChannel``.
-        """
-        return self._channel
-
-    @property
-    def channels(self) -> Tuple[SnapshotChannel]:
-        """Returns the channels that this schedule uses."""
-        return (self.channel,)
-
-    @property
-    def duration(self) -> int:
-        """Duration of this instruction."""
-        return 0
-
-    def is_parameterized(self) -> bool:
-        """Return True iff the instruction is parameterized."""
-        return False

qiskit/pulse/library/__init__.py

@@ -1,97 +0,0 @@
-# This code is part of Qiskit.
-#
-# (C) Copyright IBM 2017, 2019.
-#
-# 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.
-
-"""
-===========================================
-Pulse Library (:mod:`qiskit.pulse.library`)
-===========================================
-
-This library provides Pulse users with convenient methods to build Pulse waveforms.
-
-A pulse programmer can choose from one of several :ref:`pulse_models` such as
-:class:`~Waveform` and :class:`~SymbolicPulse` to create a pulse program.
-The :class:`~Waveform` model directly stores the waveform data points in each class instance.
-This model provides the most flexibility to express arbitrary waveforms and allows
-a rapid prototyping of new control techniques. However, this model is typically memory
-inefficient and might be hard to scale to large-size quantum processors.
-A user can directly instantiate the :class:`~Waveform` class with ``samples`` argument
-which is usually a complex numpy array or any kind of array-like data.
-
-In contrast, the :class:`~SymbolicPulse` model only stores the function and its parameters
-that generate the waveform in a class instance.
-It thus provides greater memory efficiency at the price of less flexibility in the waveform.
-This model also defines a small set of pulse subclasses in :ref:`symbolic_pulses`
-which are commonly used in superconducting quantum processors.
-An instance of these subclasses can be serialized in the :ref:`qpy_format`
-while keeping the memory-efficient parametric representation of waveforms.
-Note that :class:`~Waveform` object can be generated from an instance of
-a :class:`~SymbolicPulse` which will set values for the parameters and
-sample the parametric expression to create the :class:`~Waveform`.
-
-
-.. _pulse_models:
-
-Pulse Models
-============
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   Waveform
-   SymbolicPulse
-
-
-.. _symbolic_pulses:
-
-Parametric Pulse Representation
-===============================
-
-.. autosummary::
-   :toctree: ../stubs/
-
-   Constant
-   Drag
-   Gaussian
-   GaussianSquare
-   GaussianSquareDrag
-   gaussian_square_echo
-   GaussianDeriv
-   Sin
-   Cos
-   Sawtooth
-   Triangle
-   Square
-   Sech
-   SechDeriv
-
-"""
-
-from .symbolic_pulses import (
-    SymbolicPulse,
-    ScalableSymbolicPulse,
-    Gaussian,
-    GaussianSquare,
-    GaussianSquareDrag,
-    gaussian_square_echo,
-    GaussianDeriv,
-    Drag,
-    Constant,
-    Sin,
-    Cos,
-    Sawtooth,
-    Triangle,
-    Square,
-    Sech,
-    SechDeriv,
-)
-from .pulse import Pulse
-from .waveform import Waveform