qiskit 1.3.0__cp39-abi3-win32.whl → 1.3.0b1__cp39-abi3-win32.whl

qiskit/qasm3/exporter.py

@@ -30,6 +30,7 @@ from qiskit.circuit import (
     Barrier,
     CircuitInstruction,
     Clbit,
+    ControlledGate,
     Gate,
     Measure,
     Parameter,
@@ -139,16 +140,9 @@ class Exporter:
     ):
         """
         Args:
-            includes: the filenames that should be emitted as includes.
-
-                .. note::
-
-                    At present, only the standard-library file ``stdgates.inc`` is properly
-                    understood by the exporter, in the sense that it knows the gates it defines.
-                    You can specify other includes, but you will need to pass the names of the gates
-                    they define in the ``basis_gates`` argument to avoid the exporter outputting a
-                    separate ``gate`` definition.
-
+            includes: the filenames that should be emitted as includes.  These files will be parsed
+                for gates, and any objects dumped from this exporter will use those definitions
+                where possible.
             basis_gates: the basic defined gate set of the backend.
             disable_constants: if ``True``, always emit floating-point constants for numeric
                 parameter values.  If ``False`` (the default), then values close to multiples of
@@ -208,60 +202,46 @@ class Exporter:
 # comparisons will work.
 _FIXED_PARAMETERS = (Parameter("p0"), Parameter("p1"), Parameter("p2"), Parameter("p3"))
 
-_CANONICAL_STANDARD_GATES = {
-    standard: standard.gate_class(*_FIXED_PARAMETERS[: standard.num_params])
-    for standard in StandardGate.all_gates()
-    if not standard.is_controlled_gate
-}
-_CANONICAL_CONTROLLED_STANDARD_GATES = {
-    standard: [
-        standard.gate_class(*_FIXED_PARAMETERS[: standard.num_params], ctrl_state=ctrl_state)
-        for ctrl_state in range(1 << standard.num_ctrl_qubits)
-    ]
-    for standard in StandardGate.all_gates()
-    if standard.is_controlled_gate
-}
-
 # Mapping of symbols defined by `stdgates.inc` to their gate definition source.
 _KNOWN_INCLUDES = {
     "stdgates.inc": {
-        "p": _CANONICAL_STANDARD_GATES[StandardGate.PhaseGate],
-        "x": _CANONICAL_STANDARD_GATES[StandardGate.XGate],
-        "y": _CANONICAL_STANDARD_GATES[StandardGate.YGate],
-        "z": _CANONICAL_STANDARD_GATES[StandardGate.ZGate],
-        "h": _CANONICAL_STANDARD_GATES[StandardGate.HGate],
-        "s": _CANONICAL_STANDARD_GATES[StandardGate.SGate],
-        "sdg": _CANONICAL_STANDARD_GATES[StandardGate.SdgGate],
-        "t": _CANONICAL_STANDARD_GATES[StandardGate.TGate],
-        "tdg": _CANONICAL_STANDARD_GATES[StandardGate.TdgGate],
-        "sx": _CANONICAL_STANDARD_GATES[StandardGate.SXGate],
-        "rx": _CANONICAL_STANDARD_GATES[StandardGate.RXGate],
-        "ry": _CANONICAL_STANDARD_GATES[StandardGate.RYGate],
-        "rz": _CANONICAL_STANDARD_GATES[StandardGate.RZGate],
-        "cx": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CXGate][1],
-        "cy": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CYGate][1],
-        "cz": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CZGate][1],
-        "cp": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CPhaseGate][1],
-        "crx": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CRXGate][1],
-        "cry": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CRYGate][1],
-        "crz": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CRZGate][1],
-        "ch": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CHGate][1],
-        "swap": _CANONICAL_STANDARD_GATES[StandardGate.SwapGate],
-        "ccx": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CCXGate][3],
-        "cswap": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CSwapGate][1],
-        "cu": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CUGate][1],
-        "CX": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CXGate][1],
-        "phase": _CANONICAL_STANDARD_GATES[StandardGate.PhaseGate],
-        "cphase": _CANONICAL_CONTROLLED_STANDARD_GATES[StandardGate.CPhaseGate][1],
-        "id": _CANONICAL_STANDARD_GATES[StandardGate.IGate],
-        "u1": _CANONICAL_STANDARD_GATES[StandardGate.U1Gate],
-        "u2": _CANONICAL_STANDARD_GATES[StandardGate.U2Gate],
-        "u3": _CANONICAL_STANDARD_GATES[StandardGate.U3Gate],
+        "p": library.PhaseGate(*_FIXED_PARAMETERS[:1]),
+        "x": library.XGate(),
+        "y": library.YGate(),
+        "z": library.ZGate(),
+        "h": library.HGate(),
+        "s": library.SGate(),
+        "sdg": library.SdgGate(),
+        "t": library.TGate(),
+        "tdg": library.TdgGate(),
+        "sx": library.SXGate(),
+        "rx": library.RXGate(*_FIXED_PARAMETERS[:1]),
+        "ry": library.RYGate(*_FIXED_PARAMETERS[:1]),
+        "rz": library.RZGate(*_FIXED_PARAMETERS[:1]),
+        "cx": library.CXGate(),
+        "cy": library.CYGate(),
+        "cz": library.CZGate(),
+        "cp": library.CPhaseGate(*_FIXED_PARAMETERS[:1]),
+        "crx": library.CRXGate(*_FIXED_PARAMETERS[:1]),
+        "cry": library.CRYGate(*_FIXED_PARAMETERS[:1]),
+        "crz": library.CRZGate(*_FIXED_PARAMETERS[:1]),
+        "ch": library.CHGate(),
+        "swap": library.SwapGate(),
+        "ccx": library.CCXGate(),
+        "cswap": library.CSwapGate(),
+        "cu": library.CUGate(*_FIXED_PARAMETERS[:4]),
+        "CX": library.CXGate(),
+        "phase": library.PhaseGate(*_FIXED_PARAMETERS[:1]),
+        "cphase": library.CPhaseGate(*_FIXED_PARAMETERS[:1]),
+        "id": library.IGate(),
+        "u1": library.U1Gate(*_FIXED_PARAMETERS[:1]),
+        "u2": library.U2Gate(*_FIXED_PARAMETERS[:2]),
+        "u3": library.U3Gate(*_FIXED_PARAMETERS[:3]),
     },
 }
 
 _BUILTIN_GATES = {
-    "U": _CANONICAL_STANDARD_GATES[StandardGate.UGate],
+    "U": library.UGate(*_FIXED_PARAMETERS[:3]),
 }
 
 
@@ -492,14 +472,9 @@ class SymbolTable:
     def get_gate(self, gate: Gate) -> ast.Identifier | None:
         """Lookup the identifier for a given `Gate`, if it exists."""
         canonical = _gate_canonical_form(gate)
+        # `our_defn.canonical is None` means a basis gate that we should assume is always valid.
         if (our_defn := self.gates.get(gate.name)) is not None and (
-            # We arrange things such that the known definitions for the vast majority of gates we
-            # will encounter are the exact same canonical instance, so an `is` check saves time.
-            our_defn.canonical is canonical
-            # `our_defn.canonical is None` means a basis gate that we should assume is always valid.
-            or our_defn.canonical is None
-            # The last catch, if the canonical form is some custom gate that compares equal to this.
-            or our_defn.canonical == canonical
+            our_defn.canonical is None or our_defn.canonical == canonical
         ):
             return ast.Identifier(gate.name)
         if canonical._standard_gate is not None:
@@ -524,14 +499,11 @@ def _gate_canonical_form(gate: Gate) -> Gate:
     # If a gate is part of the Qiskit standard-library gates, we know we can safely produce a
     # reparameterised gate by passing the parameters positionally to the standard-gate constructor
     # (and control state, if appropriate).
-    standard = gate._standard_gate
-    if standard is None:
-        return gate
-    return (
-        _CANONICAL_CONTROLLED_STANDARD_GATES[standard][gate.ctrl_state]
-        if standard.is_controlled_gate
-        else _CANONICAL_STANDARD_GATES[standard]
-    )
+    if gate._standard_gate and not isinstance(gate, ControlledGate):
+        return gate.base_class(*_FIXED_PARAMETERS[: len(gate.params)])
+    elif gate._standard_gate:
+        return gate.base_class(*_FIXED_PARAMETERS[: len(gate.params)], ctrl_state=gate.ctrl_state)
+    return gate
 
 
 @dataclasses.dataclass
@@ -618,10 +590,12 @@ class QASM3Builder:
         self.scope = old_scope
         self.symbols = old_symbols
 
-    def _lookup_bit(self, bit) -> ast.Identifier:
-        """Lookup a Qiskit bit within the current context, and return the name that should be
+    def _lookup_variable(self, variable) -> ast.Identifier:
+        """Lookup a Qiskit object within the current context, and return the name that should be
         used to represent it in OpenQASM 3 programmes."""
-        return self.symbols.get_variable(self.scope.bit_map[bit])
+        if isinstance(variable, Bit):
+            variable = self.scope.bit_map[variable]
+        return self.symbols.get_variable(variable)
 
     def build_program(self):
         """Builds a Program"""
@@ -701,9 +675,9 @@ class QASM3Builder:
     def build_includes(self):
         """Builds a list of included files."""
         for filename in self.includes:
-            # Note: unknown include files have a corresponding `include` statement generated, but do
-            # not actually define any gates; we rely on the user to pass those in `basis_gates`.
-            for name, gate in _KNOWN_INCLUDES.get(filename, {}).items():
+            if (definitions := _KNOWN_INCLUDES.get(filename)) is None:
+                raise QASM3ExporterError(f"Unknown OpenQASM 3 include file: '{filename}'")
+            for name, gate in definitions.items():
                 self.symbols.register_gate_without_definition(name, gate)
             yield ast.Include(filename)
 
@@ -928,7 +902,7 @@ class QASM3Builder:
         out = []
         for register in registers:
             name = self.symbols.register_variable(register.name, register, allow_rename=True)
-            elements = [self._lookup_bit(bit) for bit in register]
+            elements = [self._lookup_variable(bit) for bit in register]
             for i, bit in enumerate(register):
                 # This might shadow previous definitions, but that's not a problem.
                 self.symbols.set_object_ident(
@@ -975,17 +949,18 @@ class QASM3Builder:
             if isinstance(instruction.operation, Gate):
                 nodes = [self.build_gate_call(instruction)]
             elif isinstance(instruction.operation, Barrier):
-                operands = [self._lookup_bit(operand) for operand in instruction.qubits]
+                operands = [self._lookup_variable(operand) for operand in instruction.qubits]
                 nodes = [ast.QuantumBarrier(operands)]
             elif isinstance(instruction.operation, Measure):
                 measurement = ast.QuantumMeasurement(
-                    [self._lookup_bit(operand) for operand in instruction.qubits]
+                    [self._lookup_variable(operand) for operand in instruction.qubits]
                 )
-                qubit = self._lookup_bit(instruction.clbits[0])
+                qubit = self._lookup_variable(instruction.clbits[0])
                 nodes = [ast.QuantumMeasurementAssignment(qubit, measurement)]
             elif isinstance(instruction.operation, Reset):
                 nodes = [
-                    ast.QuantumReset(self._lookup_bit(operand)) for operand in instruction.qubits
+                    ast.QuantumReset(self._lookup_variable(operand))
+                    for operand in instruction.qubits
                 ]
             elif isinstance(instruction.operation, Delay):
                 nodes = [self.build_delay(instruction)]
@@ -1006,13 +981,13 @@ class QASM3Builder:
                     f" but received '{instruction.operation}'"
                 )
 
-            if instruction.operation._condition is None:
+            if instruction.operation.condition is None:
                 statements.extend(nodes)
             else:
                 body = ast.ProgramBlock(nodes)
                 statements.append(
                     ast.BranchingStatement(
-                        self.build_expression(_lift_condition(instruction.operation._condition)),
+                        self.build_expression(_lift_condition(instruction.operation.condition)),
                         body,
                     )
                 )
@@ -1119,14 +1094,9 @@ class QASM3Builder:
             body_ast = ast.ProgramBlock(self.build_current_scope())
         return ast.ForLoopStatement(indexset_ast, loop_parameter_ast, body_ast)
 
-    def _lookup_variable_for_expression(self, var):
-        if isinstance(var, Bit):
-            return self._lookup_bit(var)
-        return self.symbols.get_variable(var)
-
     def build_expression(self, node: expr.Expr) -> ast.Expression:
         """Build an expression."""
-        return node.accept(_ExprBuilder(self._lookup_variable_for_expression))
+        return node.accept(_ExprBuilder(self._lookup_variable))
 
     def build_delay(self, instruction: CircuitInstruction) -> ast.QuantumDelay:
         """Build a built-in delay statement."""
@@ -1146,7 +1116,9 @@ class QASM3Builder:
                 "dt": ast.DurationUnit.SAMPLE,
             }
             duration = ast.DurationLiteral(duration_value, unit_map[unit])
-        return ast.QuantumDelay(duration, [self._lookup_bit(qubit) for qubit in instruction.qubits])
+        return ast.QuantumDelay(
+            duration, [self._lookup_variable(qubit) for qubit in instruction.qubits]
+        )
 
     def build_integer(self, value) -> ast.IntegerLiteral:
         """Build an integer literal, raising a :obj:`.QASM3ExporterError` if the input is not
@@ -1166,11 +1138,9 @@ class QASM3Builder:
         # missing, pending a new system in Terra to replace it (2022-03-07).
         if not isinstance(expression, ParameterExpression):
             return expression
-        if isinstance(expression, Parameter):
-            return self.symbols.get_variable(expression).string
         return expression.subs(
             {
-                param: Parameter(self.symbols.get_variable(param).string, uuid=param.uuid)
+                param: Parameter(self._lookup_variable(param).string)
                 for param in expression.parameters
             }
         )
@@ -1183,14 +1153,18 @@ class QASM3Builder:
         ident = self.symbols.get_gate(instruction.operation)
         if ident is None:
             ident = self.define_gate(instruction.operation)
-        qubits = [self._lookup_bit(qubit) for qubit in instruction.qubits]
-        parameters = [
-            ast.StringifyAndPray(self._rebind_scoped_parameters(param))
-            for param in instruction.operation.params
-        ]
-        if not self.disable_constants:
-            for parameter in parameters:
-                parameter.obj = pi_check(parameter.obj, output="qasm")
+        qubits = [self._lookup_variable(qubit) for qubit in instruction.qubits]
+        if self.disable_constants:
+            parameters = [
+                ast.StringifyAndPray(self._rebind_scoped_parameters(param))
+                for param in instruction.operation.params
+            ]
+        else:
+            parameters = [
+                ast.StringifyAndPray(pi_check(self._rebind_scoped_parameters(param), output="qasm"))
+                for param in instruction.operation.params
+            ]
+
         return ast.QuantumGateCall(ident, qubits, parameters=parameters)
 
 

qiskit/qobj/converters/pulse_instruction.py

@@ -31,7 +31,6 @@ from qiskit.pulse.schedule import Schedule
 from qiskit.qobj import QobjMeasurementOption, PulseLibraryItem, PulseQobjInstruction
 from qiskit.qobj.utils import MeasLevel
 from qiskit.utils import deprecate_func
-from qiskit.utils.deprecate_pulse import deprecate_pulse_dependency
 
 
 class ParametricPulseShapes(Enum):
@@ -88,9 +87,9 @@ class InstructionToQobjConverter:
     This converter converts the Qiskit Pulse in-memory representation into
     the transfer layer format to submit the data from client to the server.
 
-    The transfer layer format must be the text representation that conforms to
+    The transfer layer format must be the text representation that coforms to
     the `OpenPulse specification<https://arxiv.org/abs/1809.03452>`__.
-    Extension to the OpenPulse can be achieved by subclassing this this with
+    Extention to the OpenPulse can be achieved by subclassing this this with
     extra methods corresponding to each augmented instruction. For example,
 
     .. code-block:: python
@@ -510,9 +509,9 @@ class QobjToInstructionConverter:
     This converter converts data from transfer layer into the in-memory representation of
     the front-end of Qiskit Pulse.
 
-    The transfer layer format must be the text representation that conforms to
+    The transfer layer format must be the text representation that coforms to
     the `OpenPulse specification<https://arxiv.org/abs/1809.03452>`__.
-    Extension to the OpenPulse can be achieved by subclassing this this with
+    Extention to the OpenPulse can be achieved by subclassing this this with
     extra methods corresponding to each augmented instruction. For example,
 
     .. code-block:: python
@@ -533,7 +532,6 @@ class QobjToInstructionConverter:
 
     __chan_regex__ = re.compile(r"([a-zA-Z]+)(\d+)")
 
-    @deprecate_pulse_dependency
     def __init__(
         self,
         pulse_library: Optional[List[PulseLibraryItem]] = None,

qiskit/qpy/__init__.py

@@ -97,8 +97,6 @@ Attributes:
         will be able to load all released format versions of QPY (up until
         ``QPY_VERSION``).
 
-.. _qpy_compatibility:
-
 QPY Compatibility
 =================
 
@@ -118,30 +116,6 @@ and how the feature will be internally handled.
 
 .. autoexception:: QPYLoadingDeprecatedFeatureWarning
 
-.. note::
-
-    With versions of Qiskit before 1.2.4, the ``use_symengine=True`` argument to :func:`.qpy.dump`
-    could cause problems with backwards compatibility if there were :class:`.ParameterExpression`
-    objects to serialize.  In particular:
-
-    * When the loading version of Qiskit is 1.2.4 or greater, QPY files generated with any version
-      of Qiskit >= 0.46.0 can be loaded.  If a version of Qiskit between 0.45.0 and 0.45.3 was used
-      to generate the files, and the non-default argument ``use_symengine=True`` was given to
-      :func:`.qpy.dump`, the file can only be read if the version of ``symengine`` used in the
-      generating environment was in the 0.11 or 0.13 series, but if the environment was created
-      during the support window of Qiskit 0.45, it is likely that ``symengine==0.9.2`` was used.
-
-    * When the loading version of Qiskit is between 0.46.0 and 1.2.2 inclusive, the file can only be
-      read if the installed version of ``symengine`` in the loading environment matches the version
-      used in the generating environment.
-
-    To recover a QPY file that fails with ``symengine`` version-related errors during a call to
-    :func:`.qpy.load`, first attempt to use Qiskit >= 1.2.4 to load the file.  If this still fails,
-    it is likely because Qiskit 0.45.x was used to generate the file with ``use_symengine=True``.
-    In this case, use Qiskit 0.45.3 with ``symengine==0.9.2`` to load the file, and then re-export
-    it to QPY setting ``use_symengine=False``.  The resulting file can then be loaded by any later
-    version of Qiskit.
-
 QPY format version history
 --------------------------
 
@@ -159,24 +133,6 @@ of QPY in qiskit-terra 0.18.0.
    * - Qiskit (qiskit-terra for < 1.0.0) version
      - :func:`.dump` format(s) output versions
      - :func:`.load` maximum supported version (older format versions can always be read)
-   * - 1.3.0
-     - 10, 11, 12, 13
-     - 13
-   * - 1.2.4
-     - 10, 11, 12
-     - 12
-   * - 1.2.3 (yanked)
-     - 10, 11, 12
-     - 12
-   * - 1.2.2
-     - 10, 11, 12
-     - 12
-   * - 1.2.1
-     - 10, 11, 12
-     - 12
-   * - 1.2.0
-     - 10, 11, 12
-     - 12
    * - 1.1.0
      - 10, 11, 12
      - 12
@@ -342,141 +298,6 @@ There is a circuit payload for each circuit (where the total number is dictated
 by ``num_circuits`` in the file header). There is no padding between the
 circuits in the data.
 
-.. _qpy_version_13:
-
-Version 13
-----------
-
-Version 13 added a native Qiskit serialization representation for :class:`.ParameterExpression`.
-Previous QPY versions relied on either ``sympy`` or ``symengine`` to serialize the underlying symbolic
-expression. Starting in Version 13, QPY now represents the sequence of API calls used to create the
-:class:`.ParameterExpression`.
-
-The main change in the serialization format is in the :ref:`qpy_param_expr_v3` payload.  The
-``expr_size`` bytes following the head now contain an array of ``PARAM_EXPR_ELEM_V13`` structs. The
-intent is for this array to be read one struct at a time, where each struct describes one of the
-calls to make to reconstruct the :class:`.ParameterExpression`.
-
-PARAM_EXPR_ELEM_V13
-~~~~~~~~~~~~~~~~~~~
-
-The struct format is defined as:
-
-.. code-block:: c
-
-    struct {
-        unsigned char op_code;
-        char lhs_type;
-        char lhs[16];
-        char rhs_type;
-        char rhs[16];
-    } PARAM_EXPR_ELEM_V13;
-
-The ``op_code`` field is used to define the operation added to the :class:`.ParameterExpression`.
-The value can be:
-
-.. list-table:: PARAM_EXPR_ELEM_V13 op code values
-   :header-rows: 1
-
-   * - ``op_code``
-     - :class:`.ParameterExpression` method
-   * - 0
-     - :meth:`~.ParameterExpression.__add__`
-   * - 1
-     - :meth:`~.ParameterExpression.__sub__`
-   * - 2
-     - :meth:`~.ParameterExpression.__mul__`
-   * - 3
-     - :meth:`~.ParameterExpression.__truediv__`
-   * - 4
-     - :meth:`~.ParameterExpression.__pow__`
-   * - 5
-     - :meth:`~.ParameterExpression.sin`
-   * - 6
-     - :meth:`~.ParameterExpression.cos`
-   * - 7
-     - :meth:`~.ParameterExpression.tan`
-   * - 8
-     - :meth:`~.ParameterExpression.arcsin`
-   * - 9
-     - :meth:`~.ParameterExpression.arccos`
-   * - 10
-     - :meth:`~.ParameterExpression.exp`
-   * - 11
-     - :meth:`~.ParameterExpression.log`
-   * - 12
-     - :meth:`~.ParameterExpression.sign`
-   * - 13
-     - :meth:`~.ParameterExpression.gradient`
-   * - 14
-     - :meth:`~.ParameterExpression.conjugate`
-   * - 15
-     - :meth:`~.ParameterExpression.subs`
-   * - 16
-     - :meth:`~.ParameterExpression.abs`
-   * - 17
-     - :meth:`~.ParameterExpression.arctan`
-   * - 255
-     - NULL
-
-The ``NULL`` value of 255 is only used to fill the op code field for
-entries that are not actual operations but indicate recursive definitions.
-Then the ``lhs_type`` and ``rhs_type`` fields are used to describe
-the operand types and can be one of the following UTF-8 encoded
-characters:
-
-.. list-table:: PARAM_EXPR_ELEM_V13 operand type values
-   :header-rows: 1
-
-   * - Value
-     - Type
-   * - ``n``
-     - ``None``
-   * - ``p``
-     - :class:`.Parameter`
-   * - ``f``
-     - ``float``
-   * - ``c``
-     - ``complex``
-   * - ``i``
-     - ``int``
-   * - ``s``
-     - Recursive :class:`.ParameterExpression` definition start
-   * - ``e``
-     - Recursive :class:`.ParameterExpression` definition stop
-   * - ``u``
-     - substitution
-
-If the type value is ``f`` ,``c`` or ``i``, the corresponding ``lhs`` or `rhs``
-field widths are 128 bits each. In the case of floats, the literal value is encoded as a double
-with 0 padding, while complex numbers are encoded as real part followed by imaginary part,
-taking up 64 bits each. For ``i`, the value is encoded as a 64 bit signed integer with 0 padding
-for the full 128 bit width. ``n`` is used to represent a ``None`` and typically isn't directly used
-as it indicates an argument that's not used. For ``p`` the data is the UUID for the
-:class:`.Parameter` which can be looked up in the symbol map described in the
-``map_elements`` outer :ref:`qpy_param_expr_v3` payload. If the type value is
-``s`` this marks the start of a a new recursive section for a nested
-:class:`.ParameterExpression`. For example, in the following snippet there is an inner ``expr``
-contained in ``final_expr``, constituting a nested expression::
-
-    from qiskit.circuit import Parameter
-
-    x = Parameter("x")
-    y = Parameter("y")
-    z = Parameter("z")
-
-    expr = (x + y) / 2
-    final_expr = z**2 + expr
-
-When ``s`` is encountered, this indicates that until an ``e` struct is reached, the next structs
-are used for a recursive definition. For both
-``s`` and ``e`` types, the data values are not used, and always set to 0. The type value
-of ``u`` is used to represent a substitution call. This is only used for ``lhs_type``
-and is always paired with an ``rhs_type`` of ``n``. The data value is the size in bytes of
-a :ref:`qpy_mapping` encoded mapping of :class:`.Parameter` names to their value for the
-:meth:`~.ParameterExpression.subs` call. The mapping data is immediately following the
-struct, and the next struct starts immediately after the mapping data.
-
 .. _qpy_version_12:
 
 Version 12
@@ -1800,8 +1621,6 @@ struct is used:
 
 this matches the internal C representation of Python's complex type. [#f3]_
 
-References
-==========
 
 .. [#f1] https://tools.ietf.org/html/rfc1700
 .. [#f2] https://numpy.org/doc/stable/reference/generated/numpy.lib.format.html

qiskit/qpy/binary_io/circuits.py

@@ -318,13 +318,6 @@ def _read_instruction(
             use_symengine,
             standalone_vars,
         )
-        if condition is not None:
-            warnings.warn(
-                f"The .condition attribute on {gate_name} will be loaded as an IfElseOp "
-                "starting in Qiskit 2.0",
-                FutureWarning,
-                stacklevel=3,
-            )
         inst_obj.condition = condition
         if instruction.label_size > 0:
             inst_obj.label = label
@@ -421,12 +414,6 @@ def _read_instruction(
                 gate = gate_class(*params)
         if condition:
             if not isinstance(gate, ControlFlowOp):
-                warnings.warn(
-                    f"The .condition attribute on {gate} will be loaded as an "
-                    "IfElseOp starting in Qiskit 2.0",
-                    FutureWarning,
-                    stacklevel=3,
-                )
                 gate = gate.c_if(*condition)
             else:
                 gate.condition = condition
@@ -774,13 +761,13 @@ def _write_instruction(
     condition_type = type_keys.Condition.NONE
     condition_register = b""
     condition_value = 0
-    if (op_condition := getattr(instruction.operation, "_condition", None)) is not None:
+    if (op_condition := getattr(instruction.operation, "condition", None)) is not None:
         if isinstance(op_condition, expr.Expr):
             condition_type = type_keys.Condition.EXPRESSION
         else:
             condition_type = type_keys.Condition.TWO_TUPLE
-            condition_register = _dumps_register(instruction.operation._condition[0], index_map)
-            condition_value = int(instruction.operation._condition[1])
+            condition_register = _dumps_register(instruction.operation.condition[0], index_map)
+            condition_value = int(instruction.operation.condition[1])
 
     gate_class_name = gate_class_name.encode(common.ENCODE)
     label = getattr(instruction.operation, "label", None)
@@ -1323,7 +1310,7 @@ def write_circuit(
     instruction_buffer.close()
 
     # Write calibrations
-    _write_calibrations(file_obj, circuit._calibrations_prop, metadata_serializer, version=version)
+    _write_calibrations(file_obj, circuit.calibrations, metadata_serializer, version=version)
     _write_layout(file_obj, circuit)
 
 
@@ -1453,9 +1440,7 @@ def read_circuit(file_obj, version, metadata_deserializer=None, use_symengine=Fa
 
     # Read calibrations
     if version >= 5:
-        circ._calibrations_prop = _read_calibrations(
-            file_obj, version, vectors, metadata_deserializer
-        )
+        circ.calibrations = _read_calibrations(file_obj, version, vectors, metadata_deserializer)
 
     for vec_name, (vector, initialized_params) in vectors.items():
         if len(initialized_params) != len(vector):

qiskit/qpy/binary_io/schedules.py

@@ -20,6 +20,9 @@ from io import BytesIO
 
 import numpy as np
 import symengine as sym
+from symengine.lib.symengine_wrapper import (  # pylint: disable = no-name-in-module
+    load_basic,
+)
 
 from qiskit.exceptions import QiskitError
 from qiskit.pulse import library, channels, instructions
@@ -28,7 +31,6 @@ from qiskit.qpy import formats, common, type_keys
 from qiskit.qpy.binary_io import value
 from qiskit.qpy.exceptions import QpyError
 from qiskit.pulse.configuration import Kernel, Discriminator
-from qiskit.utils.deprecate_pulse import ignore_pulse_deprecation_warnings
 
 
 def _read_channel(file_obj, version):
@@ -104,7 +106,7 @@ def _loads_symbolic_expr(expr_bytes, use_symengine=False):
         return None
     expr_bytes = zlib.decompress(expr_bytes)
     if use_symengine:
-        return common.load_symengine_payload(expr_bytes)
+        return load_basic(expr_bytes)
     else:
         from sympy import parse_expr
 
@@ -511,7 +513,6 @@ def _dumps_reference_item(schedule, metadata_serializer, version):
     return type_key, data_bytes
 
 
-@ignore_pulse_deprecation_warnings
 def read_schedule_block(file_obj, version, metadata_deserializer=None, use_symengine=False):
     """Read a single ScheduleBlock from the file like object.