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

qiskit/qasm3/exporter.py

@@ -30,7 +30,6 @@ from qiskit.circuit import (
     Barrier,
     CircuitInstruction,
     Clbit,
-    ControlledGate,
     Gate,
     Measure,
     Parameter,
@@ -140,9 +139,16 @@ class Exporter:
     ):
         """
         Args:
-            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.
+            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.
+
             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
@@ -202,46 +208,60 @@ 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": 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]),
+        "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],
     },
 }
 
 _BUILTIN_GATES = {
-    "U": library.UGate(*_FIXED_PARAMETERS[:3]),
+    "U": _CANONICAL_STANDARD_GATES[StandardGate.UGate],
 }
 
 
@@ -472,9 +492,14 @@ 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 (
-            our_defn.canonical is None or our_defn.canonical == canonical
+            # 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
         ):
             return ast.Identifier(gate.name)
         if canonical._standard_gate is not None:
@@ -499,11 +524,14 @@ 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).
-    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
+    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]
+    )
 
 
 @dataclasses.dataclass
@@ -590,12 +618,10 @@ class QASM3Builder:
         self.scope = old_scope
         self.symbols = old_symbols
 
-    def _lookup_variable(self, variable) -> ast.Identifier:
-        """Lookup a Qiskit object within the current context, and return the name that should be
+    def _lookup_bit(self, bit) -> ast.Identifier:
+        """Lookup a Qiskit bit within the current context, and return the name that should be
         used to represent it in OpenQASM 3 programmes."""
-        if isinstance(variable, Bit):
-            variable = self.scope.bit_map[variable]
-        return self.symbols.get_variable(variable)
+        return self.symbols.get_variable(self.scope.bit_map[bit])
 
     def build_program(self):
         """Builds a Program"""
@@ -675,9 +701,9 @@ class QASM3Builder:
     def build_includes(self):
         """Builds a list of included files."""
         for filename in self.includes:
-            if (definitions := _KNOWN_INCLUDES.get(filename)) is None:
-                raise QASM3ExporterError(f"Unknown OpenQASM 3 include file: '{filename}'")
-            for name, gate in definitions.items():
+            # 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():
                 self.symbols.register_gate_without_definition(name, gate)
             yield ast.Include(filename)
 
@@ -902,7 +928,7 @@ class QASM3Builder:
         out = []
         for register in registers:
             name = self.symbols.register_variable(register.name, register, allow_rename=True)
-            elements = [self._lookup_variable(bit) for bit in register]
+            elements = [self._lookup_bit(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(
@@ -949,18 +975,17 @@ class QASM3Builder:
             if isinstance(instruction.operation, Gate):
                 nodes = [self.build_gate_call(instruction)]
             elif isinstance(instruction.operation, Barrier):
-                operands = [self._lookup_variable(operand) for operand in instruction.qubits]
+                operands = [self._lookup_bit(operand) for operand in instruction.qubits]
                 nodes = [ast.QuantumBarrier(operands)]
             elif isinstance(instruction.operation, Measure):
                 measurement = ast.QuantumMeasurement(
-                    [self._lookup_variable(operand) for operand in instruction.qubits]
+                    [self._lookup_bit(operand) for operand in instruction.qubits]
                 )
-                qubit = self._lookup_variable(instruction.clbits[0])
+                qubit = self._lookup_bit(instruction.clbits[0])
                 nodes = [ast.QuantumMeasurementAssignment(qubit, measurement)]
             elif isinstance(instruction.operation, Reset):
                 nodes = [
-                    ast.QuantumReset(self._lookup_variable(operand))
-                    for operand in instruction.qubits
+                    ast.QuantumReset(self._lookup_bit(operand)) for operand in instruction.qubits
                 ]
             elif isinstance(instruction.operation, Delay):
                 nodes = [self.build_delay(instruction)]
@@ -981,13 +1006,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,
                     )
                 )
@@ -1094,9 +1119,14 @@ 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))
+        return node.accept(_ExprBuilder(self._lookup_variable_for_expression))
 
     def build_delay(self, instruction: CircuitInstruction) -> ast.QuantumDelay:
         """Build a built-in delay statement."""
@@ -1116,9 +1146,7 @@ class QASM3Builder:
                 "dt": ast.DurationUnit.SAMPLE,
             }
             duration = ast.DurationLiteral(duration_value, unit_map[unit])
-        return ast.QuantumDelay(
-            duration, [self._lookup_variable(qubit) for qubit in instruction.qubits]
-        )
+        return ast.QuantumDelay(duration, [self._lookup_bit(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
@@ -1138,9 +1166,11 @@ 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._lookup_variable(param).string)
+                param: Parameter(self.symbols.get_variable(param).string, uuid=param.uuid)
                 for param in expression.parameters
             }
         )
@@ -1153,18 +1183,14 @@ class QASM3Builder:
         ident = self.symbols.get_gate(instruction.operation)
         if ident is None:
             ident = self.define_gate(instruction.operation)
-        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
-            ]
-
+        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")
         return ast.QuantumGateCall(ident, qubits, parameters=parameters)
 
 

qiskit/qobj/converters/pulse_instruction.py

@@ -31,6 +31,7 @@ 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):
@@ -87,9 +88,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 coforms to
+    The transfer layer format must be the text representation that conforms to
     the `OpenPulse specification<https://arxiv.org/abs/1809.03452>`__.
-    Extention to the OpenPulse can be achieved by subclassing this this with
+    Extension to the OpenPulse can be achieved by subclassing this this with
     extra methods corresponding to each augmented instruction. For example,
 
     .. code-block:: python
@@ -509,9 +510,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 coforms to
+    The transfer layer format must be the text representation that conforms to
     the `OpenPulse specification<https://arxiv.org/abs/1809.03452>`__.
-    Extention to the OpenPulse can be achieved by subclassing this this with
+    Extension to the OpenPulse can be achieved by subclassing this this with
     extra methods corresponding to each augmented instruction. For example,
 
     .. code-block:: python
@@ -532,6 +533,7 @@ 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,6 +97,8 @@ Attributes:
         will be able to load all released format versions of QPY (up until
         ``QPY_VERSION``).
 
+.. _qpy_compatibility:
+
 QPY Compatibility
 =================
 
@@ -116,6 +118,30 @@ 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
 --------------------------
 
@@ -133,6 +159,24 @@ 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
@@ -298,6 +342,141 @@ 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
@@ -1621,6 +1800,8 @@ 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,6 +318,13 @@ 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
@@ -414,6 +421,12 @@ 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
@@ -761,13 +774,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)
@@ -1310,7 +1323,7 @@ def write_circuit(
     instruction_buffer.close()
 
     # Write calibrations
-    _write_calibrations(file_obj, circuit.calibrations, metadata_serializer, version=version)
+    _write_calibrations(file_obj, circuit._calibrations_prop, metadata_serializer, version=version)
     _write_layout(file_obj, circuit)
 
 
@@ -1440,7 +1453,9 @@ def read_circuit(file_obj, version, metadata_deserializer=None, use_symengine=Fa
 
     # Read calibrations
     if version >= 5:
-        circ.calibrations = _read_calibrations(file_obj, version, vectors, metadata_deserializer)
+        circ._calibrations_prop = _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,9 +20,6 @@ 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
@@ -31,6 +28,7 @@ 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):
@@ -106,7 +104,7 @@ def _loads_symbolic_expr(expr_bytes, use_symengine=False):
         return None
     expr_bytes = zlib.decompress(expr_bytes)
     if use_symengine:
-        return load_basic(expr_bytes)
+        return common.load_symengine_payload(expr_bytes)
     else:
         from sympy import parse_expr
 
@@ -513,6 +511,7 @@ 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.