qiskit 1.0.2__cp38-abi3-win32.whl → 1.1.0__cp38-abi3-win32.whl

qiskit/qpy/binary_io/schedules.py

@@ -328,7 +328,7 @@ def _read_element(file_obj, version, metadata_deserializer, use_symengine):
     return instance
 
 
-def _loads_reference_item(type_key, data_bytes, version, metadata_deserializer):
+def _loads_reference_item(type_key, data_bytes, metadata_deserializer, version):
     if type_key == type_keys.Value.NULL:
         return None
     if type_key == type_keys.Program.SCHEDULE_BLOCK:
@@ -346,13 +346,13 @@ def _loads_reference_item(type_key, data_bytes, version, metadata_deserializer):
     )
 
 
-def _write_channel(file_obj, data):
+def _write_channel(file_obj, data, version):
     type_key = type_keys.ScheduleChannel.assign(data)
     common.write_type_key(file_obj, type_key)
-    value.write_value(file_obj, data.index)
+    value.write_value(file_obj, data.index, version=version)
 
 
-def _write_waveform(file_obj, data):
+def _write_waveform(file_obj, data, version):
     samples_bytes = common.data_to_binary(data.samples, np.save)
 
     header = struct.pack(
@@ -363,39 +363,43 @@ def _write_waveform(file_obj, data):
     )
     file_obj.write(header)
     file_obj.write(samples_bytes)
-    value.write_value(file_obj, data.name)
+    value.write_value(file_obj, data.name, version=version)
 
 
-def _dumps_obj(obj):
+def _dumps_obj(obj, version):
     """Wraps `value.dumps_value` to serialize dictionary and list objects
     which are not supported by `value.dumps_value`.
     """
     if isinstance(obj, dict):
         with BytesIO() as container:
-            common.write_mapping(file_obj=container, mapping=obj, serializer=_dumps_obj)
+            common.write_mapping(
+                file_obj=container, mapping=obj, serializer=_dumps_obj, version=version
+            )
             binary_data = container.getvalue()
         return b"D", binary_data
     elif isinstance(obj, list):
         with BytesIO() as container:
-            common.write_sequence(file_obj=container, sequence=obj, serializer=_dumps_obj)
+            common.write_sequence(
+                file_obj=container, sequence=obj, serializer=_dumps_obj, version=version
+            )
             binary_data = container.getvalue()
         return b"l", binary_data
     else:
-        return value.dumps_value(obj)
+        return value.dumps_value(obj, version=version)
 
 
-def _write_kernel(file_obj, data):
+def _write_kernel(file_obj, data, version):
     name = data.name
     params = data.params
-    common.write_mapping(file_obj=file_obj, mapping=params, serializer=_dumps_obj)
-    value.write_value(file_obj, name)
+    common.write_mapping(file_obj=file_obj, mapping=params, serializer=_dumps_obj, version=version)
+    value.write_value(file_obj, name, version=version)
 
 
-def _write_discriminator(file_obj, data):
+def _write_discriminator(file_obj, data, version):
     name = data.name
     params = data.params
-    common.write_mapping(file_obj=file_obj, mapping=params, serializer=_dumps_obj)
-    value.write_value(file_obj, name)
+    common.write_mapping(file_obj=file_obj, mapping=params, serializer=_dumps_obj, version=version)
+    value.write_value(file_obj, name, version=version)
 
 
 def _dumps_symbolic_expr(expr, use_symengine):
@@ -410,7 +414,7 @@ def _dumps_symbolic_expr(expr, use_symengine):
     return zlib.compress(expr_bytes)
 
 
-def _write_symbolic_pulse(file_obj, data, use_symengine):
+def _write_symbolic_pulse(file_obj, data, use_symengine, version):
     class_name_bytes = data.__class__.__name__.encode(common.ENCODE)
     pulse_type_bytes = data.pulse_type.encode(common.ENCODE)
     envelope_bytes = _dumps_symbolic_expr(data.envelope, use_symengine)
@@ -436,52 +440,51 @@ def _write_symbolic_pulse(file_obj, data, use_symengine):
         file_obj,
         mapping=data._params,
         serializer=value.dumps_value,
+        version=version,
     )
-    value.write_value(file_obj, data.duration)
-    value.write_value(file_obj, data.name)
+    value.write_value(file_obj, data.duration, version=version)
+    value.write_value(file_obj, data.name, version=version)
 
 
-def _write_alignment_context(file_obj, context):
+def _write_alignment_context(file_obj, context, version):
     type_key = type_keys.ScheduleAlignment.assign(context)
     common.write_type_key(file_obj, type_key)
     common.write_sequence(
-        file_obj,
-        sequence=context._context_params,
-        serializer=value.dumps_value,
+        file_obj, sequence=context._context_params, serializer=value.dumps_value, version=version
     )
 
 
-def _dumps_operand(operand, use_symengine):
+def _dumps_operand(operand, use_symengine, version):
     if isinstance(operand, library.Waveform):
         type_key = type_keys.ScheduleOperand.WAVEFORM
-        data_bytes = common.data_to_binary(operand, _write_waveform)
+        data_bytes = common.data_to_binary(operand, _write_waveform, version=version)
     elif isinstance(operand, library.SymbolicPulse):
         type_key = type_keys.ScheduleOperand.SYMBOLIC_PULSE
         data_bytes = common.data_to_binary(
-            operand, _write_symbolic_pulse, use_symengine=use_symengine
+            operand, _write_symbolic_pulse, use_symengine=use_symengine, version=version
         )
     elif isinstance(operand, channels.Channel):
         type_key = type_keys.ScheduleOperand.CHANNEL
-        data_bytes = common.data_to_binary(operand, _write_channel)
+        data_bytes = common.data_to_binary(operand, _write_channel, version=version)
     elif isinstance(operand, str):
         type_key = type_keys.ScheduleOperand.OPERAND_STR
         data_bytes = operand.encode(common.ENCODE)
     elif isinstance(operand, Kernel):
         type_key = type_keys.ScheduleOperand.KERNEL
-        data_bytes = common.data_to_binary(operand, _write_kernel)
+        data_bytes = common.data_to_binary(operand, _write_kernel, version=version)
     elif isinstance(operand, Discriminator):
         type_key = type_keys.ScheduleOperand.DISCRIMINATOR
-        data_bytes = common.data_to_binary(operand, _write_discriminator)
+        data_bytes = common.data_to_binary(operand, _write_discriminator, version=version)
     else:
-        type_key, data_bytes = value.dumps_value(operand)
+        type_key, data_bytes = value.dumps_value(operand, version=version)
 
     return type_key, data_bytes
 
 
-def _write_element(file_obj, element, metadata_serializer, use_symengine):
+def _write_element(file_obj, element, metadata_serializer, use_symengine, version):
     if isinstance(element, ScheduleBlock):
         common.write_type_key(file_obj, type_keys.Program.SCHEDULE_BLOCK)
-        write_schedule_block(file_obj, element, metadata_serializer, use_symengine)
+        write_schedule_block(file_obj, element, metadata_serializer, use_symengine, version=version)
     else:
         type_key = type_keys.ScheduleInstruction.assign(element)
         common.write_type_key(file_obj, type_key)
@@ -490,11 +493,12 @@ def _write_element(file_obj, element, metadata_serializer, use_symengine):
             sequence=element.operands,
             serializer=_dumps_operand,
             use_symengine=use_symengine,
+            version=version,
         )
-        value.write_value(file_obj, element.name)
+        value.write_value(file_obj, element.name, version=version)
 
 
-def _dumps_reference_item(schedule, metadata_serializer):
+def _dumps_reference_item(schedule, metadata_serializer, version):
     if schedule is None:
         type_key = type_keys.Value.NULL
         data_bytes = b""
@@ -504,6 +508,7 @@ def _dumps_reference_item(schedule, metadata_serializer):
             obj=schedule,
             serializer=write_schedule_block,
             metadata_serializer=metadata_serializer,
+            version=version,
         )
     return type_key, data_bytes
 
@@ -576,7 +581,7 @@ def read_schedule_block(file_obj, version, metadata_deserializer=None, use_symen
 
 def write_schedule_block(
     file_obj, block, metadata_serializer=None, use_symengine=False, version=common.QPY_VERSION
-):  # pylint: disable=unused-argument
+):
     """Write a single ScheduleBlock object in the file like object.
 
     Args:
@@ -610,11 +615,11 @@ def write_schedule_block(
     file_obj.write(block_name)
     file_obj.write(metadata)
 
-    _write_alignment_context(file_obj, block.alignment_context)
+    _write_alignment_context(file_obj, block.alignment_context, version=version)
     for block_elm in block._blocks:
         # Do not call block.blocks. This implicitly assigns references to instruction.
         # This breaks original reference structure.
-        _write_element(file_obj, block_elm, metadata_serializer, use_symengine)
+        _write_element(file_obj, block_elm, metadata_serializer, use_symengine, version=version)
 
     # Write references
     flat_key_refdict = {}
@@ -627,4 +632,5 @@ def write_schedule_block(
         mapping=flat_key_refdict,
         serializer=_dumps_reference_item,
         metadata_serializer=metadata_serializer,
+        version=version,
     )

qiskit/qpy/binary_io/value.py

@@ -53,7 +53,7 @@ def _write_parameter_vec(file_obj, obj):
     file_obj.write(name_bytes)
 
 
-def _write_parameter_expression(file_obj, obj, use_symengine):
+def _write_parameter_expression(file_obj, obj, use_symengine, *, version):
     if use_symengine:
         expr_bytes = obj._symbol_expr.__reduce__()[1][0]
     else:
@@ -81,7 +81,7 @@ def _write_parameter_expression(file_obj, obj, use_symengine):
             value_key = symbol_key
             value_data = bytes()
         else:
-            value_key, value_data = dumps_value(value, use_symengine=use_symengine)
+            value_key, value_data = dumps_value(value, version=version, use_symengine=use_symengine)
 
         elem_header = struct.pack(
             formats.PARAM_EXPR_MAP_ELEM_V3_PACK,
@@ -95,11 +95,13 @@ def _write_parameter_expression(file_obj, obj, use_symengine):
 
 
 class _ExprWriter(expr.ExprVisitor[None]):
-    __slots__ = ("file_obj", "clbit_indices")
+    __slots__ = ("file_obj", "clbit_indices", "standalone_var_indices", "version")
 
-    def __init__(self, file_obj, clbit_indices):
+    def __init__(self, file_obj, clbit_indices, standalone_var_indices, version):
         self.file_obj = file_obj
         self.clbit_indices = clbit_indices
+        self.standalone_var_indices = standalone_var_indices
+        self.version = version
 
     def visit_generic(self, node, /):
         raise exceptions.QpyError(f"unhandled Expr object '{node}'")
@@ -107,7 +109,15 @@ class _ExprWriter(expr.ExprVisitor[None]):
     def visit_var(self, node, /):
         self.file_obj.write(type_keys.Expression.VAR)
         _write_expr_type(self.file_obj, node.type)
-        if isinstance(node.var, Clbit):
+        if node.standalone:
+            self.file_obj.write(type_keys.ExprVar.UUID)
+            self.file_obj.write(
+                struct.pack(
+                    formats.EXPR_VAR_UUID_PACK,
+                    *formats.EXPR_VAR_UUID(self.standalone_var_indices[node]),
+                )
+            )
+        elif isinstance(node.var, Clbit):
             self.file_obj.write(type_keys.ExprVar.CLBIT)
             self.file_obj.write(
                 struct.pack(
@@ -172,14 +182,30 @@ class _ExprWriter(expr.ExprVisitor[None]):
         self.file_obj.write(type_keys.Expression.BINARY)
         _write_expr_type(self.file_obj, node.type)
         self.file_obj.write(
-            struct.pack(formats.EXPRESSION_BINARY_PACK, *formats.EXPRESSION_UNARY(node.op.value))
+            struct.pack(formats.EXPRESSION_BINARY_PACK, *formats.EXPRESSION_BINARY(node.op.value))
         )
         node.left.accept(self)
         node.right.accept(self)
 
+    def visit_index(self, node, /):
+        if self.version < 12:
+            raise exceptions.UnsupportedFeatureForVersion(
+                "the 'Index' expression", required=12, target=self.version
+            )
+        self.file_obj.write(type_keys.Expression.INDEX)
+        _write_expr_type(self.file_obj, node.type)
+        node.target.accept(self)
+        node.index.accept(self)
 
-def _write_expr(file_obj, node: expr.Expr, clbit_indices: collections.abc.Mapping[Clbit, int]):
-    node.accept(_ExprWriter(file_obj, clbit_indices))
+
+def _write_expr(
+    file_obj,
+    node: expr.Expr,
+    clbit_indices: collections.abc.Mapping[Clbit, int],
+    standalone_var_indices: collections.abc.Mapping[expr.Var, int],
+    version: int,
+):
+    node.accept(_ExprWriter(file_obj, clbit_indices, standalone_var_indices, version))
 
 
 def _write_expr_type(file_obj, type_: types.Type):
@@ -315,12 +341,18 @@ def _read_expr(
     file_obj,
     clbits: collections.abc.Sequence[Clbit],
     cregs: collections.abc.Mapping[str, ClassicalRegister],
+    standalone_vars: collections.abc.Sequence[expr.Var],
 ) -> expr.Expr:
     # pylint: disable=too-many-return-statements
     type_key = file_obj.read(formats.EXPRESSION_DISCRIMINATOR_SIZE)
     type_ = _read_expr_type(file_obj)
     if type_key == type_keys.Expression.VAR:
         var_type_key = file_obj.read(formats.EXPR_VAR_DISCRIMINATOR_SIZE)
+        if var_type_key == type_keys.ExprVar.UUID:
+            payload = formats.EXPR_VAR_UUID._make(
+                struct.unpack(formats.EXPR_VAR_UUID_PACK, file_obj.read(formats.EXPR_VAR_UUID_SIZE))
+            )
+            return standalone_vars[payload.var_index]
         if var_type_key == type_keys.ExprVar.CLBIT:
             payload = formats.EXPR_VAR_CLBIT._make(
                 struct.unpack(
@@ -360,14 +392,20 @@ def _read_expr(
         payload = formats.EXPRESSION_CAST._make(
             struct.unpack(formats.EXPRESSION_CAST_PACK, file_obj.read(formats.EXPRESSION_CAST_SIZE))
         )
-        return expr.Cast(_read_expr(file_obj, clbits, cregs), type_, implicit=payload.implicit)
+        return expr.Cast(
+            _read_expr(file_obj, clbits, cregs, standalone_vars), type_, implicit=payload.implicit
+        )
     if type_key == type_keys.Expression.UNARY:
         payload = formats.EXPRESSION_UNARY._make(
             struct.unpack(
                 formats.EXPRESSION_UNARY_PACK, file_obj.read(formats.EXPRESSION_UNARY_SIZE)
             )
         )
-        return expr.Unary(expr.Unary.Op(payload.opcode), _read_expr(file_obj, clbits, cregs), type_)
+        return expr.Unary(
+            expr.Unary.Op(payload.opcode),
+            _read_expr(file_obj, clbits, cregs, standalone_vars),
+            type_,
+        )
     if type_key == type_keys.Expression.BINARY:
         payload = formats.EXPRESSION_BINARY._make(
             struct.unpack(
@@ -376,11 +414,17 @@ def _read_expr(
         )
         return expr.Binary(
             expr.Binary.Op(payload.opcode),
-            _read_expr(file_obj, clbits, cregs),
-            _read_expr(file_obj, clbits, cregs),
+            _read_expr(file_obj, clbits, cregs, standalone_vars),
+            _read_expr(file_obj, clbits, cregs, standalone_vars),
+            type_,
+        )
+    if type_key == type_keys.Expression.INDEX:
+        return expr.Index(
+            _read_expr(file_obj, clbits, cregs, standalone_vars),
+            _read_expr(file_obj, clbits, cregs, standalone_vars),
             type_,
         )
-    raise exceptions.QpyError("Invalid classical-expression Expr key '{type_key}'")
+    raise exceptions.QpyError(f"Invalid classical-expression Expr key '{type_key}'")
 
 
 def _read_expr_type(file_obj) -> types.Type:
@@ -395,11 +439,92 @@ def _read_expr_type(file_obj) -> types.Type:
     raise exceptions.QpyError(f"Invalid classical-expression Type key '{type_key}'")
 
 
-def dumps_value(obj, *, index_map=None, use_symengine=False):
+def read_standalone_vars(file_obj, num_vars):
+    """Read the ``num_vars`` standalone variable declarations from the file.
+
+    Args:
+        file_obj (File): a file-like object to read from.
+        num_vars (int): the number of variables to read.
+
+    Returns:
+        tuple[dict, list]: the first item is a mapping of the ``ExprVarDeclaration`` type keys to
+        the variables defined by that type key, and the second is the total order of variable
+        declarations.
+    """
+    read_vars = {
+        type_keys.ExprVarDeclaration.INPUT: [],
+        type_keys.ExprVarDeclaration.CAPTURE: [],
+        type_keys.ExprVarDeclaration.LOCAL: [],
+    }
+    var_order = []
+    for _ in range(num_vars):
+        data = formats.EXPR_VAR_DECLARATION._make(
+            struct.unpack(
+                formats.EXPR_VAR_DECLARATION_PACK,
+                file_obj.read(formats.EXPR_VAR_DECLARATION_SIZE),
+            )
+        )
+        type_ = _read_expr_type(file_obj)
+        name = file_obj.read(data.name_size).decode(common.ENCODE)
+        var = expr.Var(uuid.UUID(bytes=data.uuid_bytes), type_, name=name)
+        read_vars[data.usage].append(var)
+        var_order.append(var)
+    return read_vars, var_order
+
+
+def _write_standalone_var(file_obj, var, type_key):
+    name = var.name.encode(common.ENCODE)
+    file_obj.write(
+        struct.pack(
+            formats.EXPR_VAR_DECLARATION_PACK,
+            *formats.EXPR_VAR_DECLARATION(var.var.bytes, type_key, len(name)),
+        )
+    )
+    _write_expr_type(file_obj, var.type)
+    file_obj.write(name)
+
+
+def write_standalone_vars(file_obj, circuit):
+    """Write the standalone variables out from a circuit.
+
+    Args:
+        file_obj (File): the file-like object to write to.
+        circuit (QuantumCircuit): the circuit to take the variables from.
+
+    Returns:
+        dict[expr.Var, int]: a mapping of the variables written to the index that they were written
+        at.
+    """
+    index = 0
+    out = {}
+    for var in circuit.iter_input_vars():
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.INPUT)
+        out[var] = index
+        index += 1
+    for var in circuit.iter_captured_vars():
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.CAPTURE)
+        out[var] = index
+        index += 1
+    for var in circuit.iter_declared_vars():
+        _write_standalone_var(file_obj, var, type_keys.ExprVarDeclaration.LOCAL)
+        out[var] = index
+        index += 1
+    return out
+
+
+def dumps_value(
+    obj,
+    *,
+    version,
+    index_map=None,
+    use_symengine=False,
+    standalone_var_indices=None,
+):
     """Serialize input value object.
 
     Args:
         obj (any): Arbitrary value object to serialize.
+        version (int): the target QPY version for the dump.
         index_map (dict): Dictionary with two keys, "q" and "c".  Each key has a value that is a
             dictionary mapping :class:`.Qubit` or :class:`.Clbit` instances (respectively) to their
             integer indices.
@@ -407,6 +532,8 @@ def dumps_value(obj, *, index_map=None, use_symengine=False):
             native mechanism. This is a faster serialization alternative, but not supported in all
             platforms. Please check that your target platform is supported by the symengine library
             before setting this option, as it will be required by qpy to deserialize the payload.
+        standalone_var_indices (dict): Dictionary that maps standalone :class:`.expr.Var` entries to
+            the index that should be used to refer to them.
 
     Returns:
         tuple: TypeKey and binary data.
@@ -434,23 +561,33 @@ def dumps_value(obj, *, index_map=None, use_symengine=False):
         binary_data = common.data_to_binary(obj, _write_parameter)
     elif type_key == type_keys.Value.PARAMETER_EXPRESSION:
         binary_data = common.data_to_binary(
-            obj, _write_parameter_expression, use_symengine=use_symengine
+            obj, _write_parameter_expression, use_symengine=use_symengine, version=version
         )
     elif type_key == type_keys.Value.EXPRESSION:
         clbit_indices = {} if index_map is None else index_map["c"]
-        binary_data = common.data_to_binary(obj, _write_expr, clbit_indices=clbit_indices)
+        standalone_var_indices = {} if standalone_var_indices is None else standalone_var_indices
+        binary_data = common.data_to_binary(
+            obj,
+            _write_expr,
+            clbit_indices=clbit_indices,
+            standalone_var_indices=standalone_var_indices,
+            version=version,
+        )
     else:
         raise exceptions.QpyError(f"Serialization for {type_key} is not implemented in value I/O.")
 
     return type_key, binary_data
 
 
-def write_value(file_obj, obj, *, index_map=None, use_symengine=False):
+def write_value(
+    file_obj, obj, *, version, index_map=None, use_symengine=False, standalone_var_indices=None
+):
     """Write a value to the file like object.
 
     Args:
         file_obj (File): A file like object to write data.
         obj (any): Value to write.
+        version (int): the target QPY version for the dump.
         index_map (dict): Dictionary with two keys, "q" and "c".  Each key has a value that is a
             dictionary mapping :class:`.Qubit` or :class:`.Clbit` instances (respectively) to their
             integer indices.
@@ -458,13 +595,29 @@ def write_value(file_obj, obj, *, index_map=None, use_symengine=False):
             native mechanism. This is a faster serialization alternative, but not supported in all
             platforms. Please check that your target platform is supported by the symengine library
             before setting this option, as it will be required by qpy to deserialize the payload.
+        standalone_var_indices (dict): Dictionary that maps standalone :class:`.expr.Var` entries to
+            the index that should be used to refer to them.
     """
-    type_key, data = dumps_value(obj, index_map=index_map, use_symengine=use_symengine)
+    type_key, data = dumps_value(
+        obj,
+        version=version,
+        index_map=index_map,
+        use_symengine=use_symengine,
+        standalone_var_indices=standalone_var_indices,
+    )
     common.write_generic_typed_data(file_obj, type_key, data)
 
 
 def loads_value(
-    type_key, binary_data, version, vectors, *, clbits=(), cregs=None, use_symengine=False
+    type_key,
+    binary_data,
+    version,
+    vectors,
+    *,
+    clbits=(),
+    cregs=None,
+    use_symengine=False,
+    standalone_vars=(),
 ):
     """Deserialize input binary data to value object.
 
@@ -479,6 +632,8 @@ def loads_value(
             native mechanism. This is a faster serialization alternative, but not supported in all
             platforms. Please check that your target platform is supported by the symengine library
             before setting this option, as it will be required by qpy to deserialize the payload.
+        standalone_vars (Sequence[Var]): standalone :class:`.expr.Var` nodes in the order that they
+            were declared by the circuit header.
 
     Returns:
         any: Deserialized value object.
@@ -520,12 +675,27 @@ def loads_value(
                 use_symengine=use_symengine,
             )
     if type_key == type_keys.Value.EXPRESSION:
-        return common.data_from_binary(binary_data, _read_expr, clbits=clbits, cregs=cregs or {})
+        return common.data_from_binary(
+            binary_data,
+            _read_expr,
+            clbits=clbits,
+            cregs=cregs or {},
+            standalone_vars=standalone_vars,
+        )
 
     raise exceptions.QpyError(f"Serialization for {type_key} is not implemented in value I/O.")
 
 
-def read_value(file_obj, version, vectors, *, clbits=(), cregs=None, use_symengine=False):
+def read_value(
+    file_obj,
+    version,
+    vectors,
+    *,
+    clbits=(),
+    cregs=None,
+    use_symengine=False,
+    standalone_vars=(),
+):
     """Read a value from the file like object.
 
     Args:
@@ -538,6 +708,8 @@ def read_value(file_obj, version, vectors, *, clbits=(), cregs=None, use_symengi
             native mechanism. This is a faster serialization alternative, but not supported in all
             platforms. Please check that your target platform is supported by the symengine library
             before setting this option, as it will be required by qpy to deserialize the payload.
+        standalone_vars (Sequence[expr.Var]): standalone variables in the order they were defined in
+            the QPY payload.
 
     Returns:
         any: Deserialized value object.
@@ -545,5 +717,12 @@ def read_value(file_obj, version, vectors, *, clbits=(), cregs=None, use_symengi
     type_key, data = common.read_generic_typed_data(file_obj)
 
     return loads_value(
-        type_key, data, version, vectors, clbits=clbits, cregs=cregs, use_symengine=use_symengine
+        type_key,
+        data,
+        version,
+        vectors,
+        clbits=clbits,
+        cregs=cregs,
+        use_symengine=use_symengine,
+        standalone_vars=standalone_vars,
     )

qiskit/qpy/common.py

@@ -20,7 +20,7 @@ import struct
 
 from qiskit.qpy import formats
 
-QPY_VERSION = 11
+QPY_VERSION = 12
 QPY_COMPATIBILITY_VERSION = 10
 ENCODE = "utf8"
 

qiskit/qpy/exceptions.py

@@ -28,6 +28,26 @@ class QpyError(QiskitError):
         return repr(self.message)
 
 
+class UnsupportedFeatureForVersion(QpyError):
+    """QPY error raised when the target dump version is too low for a feature that is present in the
+    object to be serialized."""
+
+    def __init__(self, feature: str, required: int, target: int):
+        """
+        Args:
+            feature: a description of the problematic feature.
+            required: the minimum version of QPY that would be required to represent this
+                feature.
+            target: the version of QPY that is being used in the serialization.
+        """
+        self.feature = feature
+        self.required = required
+        self.target = target
+        super().__init__(
+            f"Dumping QPY version {target}, but version {required} is required for: {feature}."
+        )
+
+
 class QPYLoadingDeprecatedFeatureWarning(QiskitWarning):
     """Visible deprecation warning for QPY loading functions without
     a stable point in the call stack."""

qiskit/qpy/formats.py

@@ -42,6 +42,24 @@ FILE_HEADER = namedtuple(
 FILE_HEADER_PACK = "!6sBBBBQ"
 FILE_HEADER_SIZE = struct.calcsize(FILE_HEADER_PACK)
 
+
+CIRCUIT_HEADER_V12 = namedtuple(
+    "HEADER",
+    [
+        "name_size",
+        "global_phase_type",
+        "global_phase_size",
+        "num_qubits",
+        "num_clbits",
+        "metadata_size",
+        "num_registers",
+        "num_instructions",
+        "num_vars",
+    ],
+)
+CIRCUIT_HEADER_V12_PACK = "!H1cHIIQIQI"
+CIRCUIT_HEADER_V12_SIZE = struct.calcsize(CIRCUIT_HEADER_V12_PACK)
+
 # CIRCUIT_HEADER_V2
 CIRCUIT_HEADER_V2 = namedtuple(
     "HEADER",
@@ -309,6 +327,13 @@ INITIAL_LAYOUT_BIT = namedtuple("INITIAL_LAYOUT_BIT", ["index", "register_size"]
 INITIAL_LAYOUT_BIT_PACK = "!ii"
 INITIAL_LAYOUT_BIT_SIZE = struct.calcsize(INITIAL_LAYOUT_BIT_PACK)
 
+# EXPR_VAR_DECLARATION
+
+EXPR_VAR_DECLARATION = namedtuple("EXPR_VAR_DECLARATION", ["uuid_bytes", "usage", "name_size"])
+EXPR_VAR_DECLARATION_PACK = "!16scH"
+EXPR_VAR_DECLARATION_SIZE = struct.calcsize(EXPR_VAR_DECLARATION_PACK)
+
+
 # EXPRESSION
 
 EXPRESSION_DISCRIMINATOR_SIZE = 1
@@ -351,6 +376,10 @@ EXPR_VAR_REGISTER = namedtuple("EXPR_VAR_REGISTER", ["reg_name_size"])
 EXPR_VAR_REGISTER_PACK = "!H"
 EXPR_VAR_REGISTER_SIZE = struct.calcsize(EXPR_VAR_REGISTER_PACK)
 
+EXPR_VAR_UUID = namedtuple("EXPR_VAR_UUID", ["var_index"])
+EXPR_VAR_UUID_PACK = "!H"
+EXPR_VAR_UUID_SIZE = struct.calcsize(EXPR_VAR_UUID_PACK)
+
 
 # EXPR_VALUE