libqasm 0.6.7__cp312-cp312-macosx_11_0_arm64.whl → 0.6.8__cp312-cp312-macosx_11_0_arm64.whl

cqasm/v3x/semantic.py

@@ -638,10 +638,14 @@ class Annotated(Node):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
+        if typ == 'Gate':
+            return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'Variable':
             return Variable._deserialize(cbor, seq_to_ob, links)
-        if typ == 'Instruction':
-            return Instruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'GateInstruction':
+            return GateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'NonGateInstruction':
+            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -1162,6 +1166,342 @@ class MultiBlock(_Multiple):
 
 _typemap['Block'] = Block
 
+class Gate(Annotated):
+    """A gate can be a named gate or a composition of gate modifiers acting on a
+    gate. pow is the only gate modifier that has an operand."""
+
+    __slots__ = [
+        '_attr_name',
+        '_attr_gate',
+        '_attr_parameter',
+    ]
+
+    def __init__(
+        self,
+        name=None,
+        gate=None,
+        parameter=None,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+        self.name = name
+        self.gate = gate
+        self.parameter = parameter
+
+    @property
+    def name(self):
+        return self._attr_name
+
+    @name.setter
+    def name(self, val):
+        if val is None:
+            del self.name
+            return
+        if not isinstance(val, cqasm.v3x.primitives.Str):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('name must be of type cqasm.v3x.primitives.Str')
+            val = cqasm.v3x.primitives.Str(val)
+        self._attr_name = val
+
+    @name.deleter
+    def name(self):
+        self._attr_name = cqasm.v3x.primitives.Str()
+
+    @property
+    def gate(self):
+        return self._attr_gate
+
+    @gate.setter
+    def gate(self, val):
+        if val is None:
+            del self.gate
+            return
+        if not isinstance(val, Gate):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('gate must be of type Gate')
+            val = Gate(val)
+        self._attr_gate = val
+
+    @gate.deleter
+    def gate(self):
+        self._attr_gate = None
+
+    @property
+    def parameter(self):
+        return self._attr_parameter
+
+    @parameter.setter
+    def parameter(self, val):
+        if val is None:
+            del self.parameter
+            return
+        if not isinstance(val, cqasm.v3x.values.ValueBase):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('parameter must be of type cqasm.v3x.values.ValueBase')
+            val = cqasm.v3x.values.ValueBase(val)
+        self._attr_parameter = val
+
+    @parameter.deleter
+    def parameter(self):
+        self._attr_parameter = None
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, Gate):
+            return False
+        if self.name != other.name:
+            return False
+        if self.gate != other.gate:
+            return False
+        if self.parameter != other.parameter:
+            return False
+        if self.annotations != other.annotations:
+            return False
+        return True
+
+    def dump(self, indent=0, annotations=None, links=1):
+        """Returns a debug representation of this tree as a multiline string.
+        indent is the number of double spaces prefixed before every line.
+        annotations, if specified, must be a set-like object containing the key
+        strings of the annotations that are to be printed. links specifies the
+        maximum link recursion depth."""
+        s = ['  '*indent]
+        s.append('Gate(')
+        if annotations is None:
+            annotations = []
+        for key in annotations:
+            if key in self:
+                s.append(' # {}: {}'.format(key, self[key]))
+        s.append('\n')
+        indent += 1
+        s.append('  '*indent)
+        s.append('name: ')
+        s.append(str(self.name) + '\n')
+        s.append('  '*indent)
+        s.append('gate: ')
+        if self.gate is None:
+            s.append('-\n')
+        else:
+            s.append('<\n')
+            s.append(self.gate.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('parameter: ')
+        if self.parameter is None:
+            s.append('-\n')
+        else:
+            s.append('<\n')
+            s.append(self.parameter.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('annotations: ')
+        if not self.annotations:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.annotations:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
+        indent -= 1
+        s.append('  '*indent)
+        s.append(')')
+        return ''.join(s)
+
+    __str__ = dump
+    __repr__ = dump
+
+    def find_reachable(self, id_map=None):
+        """Returns a dictionary mapping Python id() values to stable sequence
+        numbers for all nodes in the tree rooted at this node. If id_map is
+        specified, found nodes are appended to it."""
+        if id_map is None:
+            id_map = {}
+        if id(self) in id_map:
+            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
+        id_map[id(self)] = len(id_map)
+        if self._attr_gate is not None:
+            self._attr_gate.find_reachable(id_map)
+        if self._attr_parameter is not None:
+            self._attr_parameter.find_reachable(id_map)
+        for el in self._attr_annotations:
+            el.find_reachable(id_map)
+        return id_map
+
+    def check_complete(self, id_map=None):
+        """Raises NotWellFormed if the tree rooted at this node is not
+        well-formed. If id_map is specified, this tree is only a subtree in the
+        context of a larger tree, and id_map must be a dict mapping from Python
+        id() codes to tree indices for all reachable nodes."""
+        if id_map is None:
+            id_map = self.find_reachable()
+        if self._attr_gate is not None:
+            self._attr_gate.check_complete(id_map)
+        if self._attr_parameter is not None:
+            self._attr_parameter.check_complete(id_map)
+        for child in self._attr_annotations:
+            child.check_complete(id_map)
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return Gate(
+            name=self._attr_name,
+            gate=self._attr_gate,
+            parameter=self._attr_parameter,
+            annotations=self._attr_annotations.copy()
+        )
+
+    def clone(self):
+        """Returns a deep copy of this node. This mimics the C++ interface,
+        deficiencies with links included; that is, links always point to the
+        original tree. If you're not cloning a subtree in a context where this
+        is the desired behavior, you may want to use the copy.deepcopy() from
+        the stdlib instead, which should copy links correctly."""
+        return Gate(
+            name=_cloned(self._attr_name),
+            gate=_cloned(self._attr_gate),
+            parameter=_cloned(self._attr_parameter),
+            annotations=_cloned(self._attr_annotations)
+        )
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ != 'Gate':
+            raise ValueError('found node serialization for ' + typ + ', but expected Gate')
+
+        # Deserialize the name field.
+        field = cbor.get('name', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field name')
+        if hasattr(cqasm.v3x.primitives.Str, 'deserialize_cbor'):
+            f_name = cqasm.v3x.primitives.Str.deserialize_cbor(field)
+        else:
+            f_name = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Str, field)
+
+        # Deserialize the gate field.
+        field = cbor.get('gate', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field gate')
+        if field.get('@T') != '?':
+            raise ValueError('unexpected edge type for field gate')
+        if field.get('@t', None) is None:
+            f_gate = None
+        else:
+            f_gate = Gate._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the parameter field.
+        field = cbor.get('parameter', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field parameter')
+        if field.get('@T') != '?':
+            raise ValueError('unexpected edge type for field parameter')
+        if field.get('@t', None) is None:
+            f_parameter = None
+        else:
+            f_parameter = cqasm.v3x.values.ValueBase._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the annotations field.
+        field = cbor.get('annotations', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field annotations')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field annotations')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_annotations = MultiAnnotationData()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
+
+        # Construct the Gate node.
+        node = Gate(f_name, f_gate, f_parameter, f_annotations)
+
+        # Deserialize annotations.
+        for key, val in cbor.items():
+            if not (key.startswith('{') and key.endswith('}')):
+                continue
+            key = key[1:-1]
+            node[key] = cqasm.v3x.primitives.deserialize(key, val)
+
+        # Register node in sequence number lookup.
+        seq = cbor.get('@i', None)
+        if not isinstance(seq, int):
+            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
+        if seq in seq_to_ob:
+            raise ValueError('duplicate sequence number %d' % seq)
+        seq_to_ob[seq] = node
+
+        return node
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'Gate'}
+
+        # Serialize the name field.
+        if hasattr(self._attr_name, 'serialize_cbor'):
+            cbor['name'] = self._attr_name.serialize_cbor()
+        else:
+            cbor['name'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Str, self._attr_name)
+
+        # Serialize the gate field.
+        field = {'@T': '?'}
+        if self._attr_gate is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_gate._serialize(id_map))
+        cbor['gate'] = field
+
+        # Serialize the parameter field.
+        field = {'@T': '?'}
+        if self._attr_parameter is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_parameter._serialize(id_map))
+        cbor['parameter'] = field
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiGate(_Multiple):
+    """Wrapper for an edge with multiple Gate objects."""
+
+    _T = Gate
+
+
+_typemap['Gate'] = Gate
+
 class Statement(Annotated):
     __slots__ = []
 
@@ -1184,16 +1524,422 @@ class Statement(Annotated):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'Instruction':
-            return Instruction._deserialize(cbor, seq_to_ob, links)
-        raise ValueError('unknown or unexpected type (@t) found in node serialization')
+        if typ == 'GateInstruction':
+            return GateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'NonGateInstruction':
+            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        raise ValueError('unknown or unexpected type (@t) found in node serialization')
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'Statement'}
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiStatement(_Multiple):
+    """Wrapper for an edge with multiple Statement objects."""
+
+    _T = Statement
+
+
+_typemap['Statement'] = Statement
+
+class Instruction(Statement):
+    __slots__ = []
+
+    def __init__(
+        self,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ == 'GateInstruction':
+            return GateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'NonGateInstruction':
+            return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        raise ValueError('unknown or unexpected type (@t) found in node serialization')
+
+    def _serialize(self, id_map):
+        """Serializes this node to the Python primitive representation of its
+        CBOR serialization. The tree that the node belongs to must be
+        well-formed. id_map must match Python id() calls for all nodes to unique
+        integers, to use for the sequence number representation of links."""
+        cbor = {'@i': id_map[id(self)], '@t': 'Instruction'}
+
+        # Serialize the annotations field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_annotations:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['annotations'] = field
+
+        # Serialize annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
+
+        return cbor
+
+
+class MultiInstruction(_Multiple):
+    """Wrapper for an edge with multiple Instruction objects."""
+
+    _T = Instruction
+
+
+_typemap['Instruction'] = Instruction
+
+class GateInstruction(Instruction):
+    """A gate, or a composition of gate modifiers and a gate"""
+
+    __slots__ = [
+        '_attr_instruction_ref',
+        '_attr_gate',
+        '_attr_operands',
+    ]
+
+    def __init__(
+        self,
+        instruction_ref=None,
+        gate=None,
+        operands=None,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+        self.instruction_ref = instruction_ref
+        self.gate = gate
+        self.operands = operands
+
+    @property
+    def instruction_ref(self):
+        return self._attr_instruction_ref
+
+    @instruction_ref.setter
+    def instruction_ref(self, val):
+        if val is None:
+            del self.instruction_ref
+            return
+        if not isinstance(val, cqasm.v3x.instruction.InstructionRef):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('instruction_ref must be of type cqasm.v3x.instruction.InstructionRef')
+            val = cqasm.v3x.instruction.InstructionRef(val)
+        self._attr_instruction_ref = val
+
+    @instruction_ref.deleter
+    def instruction_ref(self):
+        self._attr_instruction_ref = cqasm.v3x.instruction.InstructionRef()
+
+    @property
+    def gate(self):
+        return self._attr_gate
+
+    @gate.setter
+    def gate(self, val):
+        if val is None:
+            del self.gate
+            return
+        if not isinstance(val, Gate):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('gate must be of type Gate')
+            val = Gate(val)
+        self._attr_gate = val
+
+    @gate.deleter
+    def gate(self):
+        self._attr_gate = None
+
+    @property
+    def operands(self):
+        return self._attr_operands
+
+    @operands.setter
+    def operands(self, val):
+        if val is None:
+            del self.operands
+            return
+        if not isinstance(val, cqasm.v3x.values.MultiValueBase):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('operands must be of type cqasm.v3x.values.MultiValueBase')
+            val = cqasm.v3x.values.MultiValueBase(val)
+        self._attr_operands = val
+
+    @operands.deleter
+    def operands(self):
+        self._attr_operands = cqasm.v3x.values.MultiValueBase()
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, GateInstruction):
+            return False
+        if self.instruction_ref != other.instruction_ref:
+            return False
+        if self.gate != other.gate:
+            return False
+        if self.operands != other.operands:
+            return False
+        if self.annotations != other.annotations:
+            return False
+        return True
+
+    def dump(self, indent=0, annotations=None, links=1):
+        """Returns a debug representation of this tree as a multiline string.
+        indent is the number of double spaces prefixed before every line.
+        annotations, if specified, must be a set-like object containing the key
+        strings of the annotations that are to be printed. links specifies the
+        maximum link recursion depth."""
+        s = ['  '*indent]
+        s.append('GateInstruction(')
+        if annotations is None:
+            annotations = []
+        for key in annotations:
+            if key in self:
+                s.append(' # {}: {}'.format(key, self[key]))
+        s.append('\n')
+        indent += 1
+        s.append('  '*indent)
+        s.append('instruction_ref: ')
+        s.append(str(self.instruction_ref) + '\n')
+        s.append('  '*indent)
+        s.append('gate: ')
+        if self.gate is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            s.append(self.gate.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('operands: ')
+        if not self.operands:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.operands:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
+        s.append('  '*indent)
+        s.append('annotations: ')
+        if not self.annotations:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.annotations:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
+        indent -= 1
+        s.append('  '*indent)
+        s.append(')')
+        return ''.join(s)
+
+    __str__ = dump
+    __repr__ = dump
+
+    def find_reachable(self, id_map=None):
+        """Returns a dictionary mapping Python id() values to stable sequence
+        numbers for all nodes in the tree rooted at this node. If id_map is
+        specified, found nodes are appended to it."""
+        if id_map is None:
+            id_map = {}
+        if id(self) in id_map:
+            raise NotWellFormed('node {!r} with id {} occurs more than once'.format(self, id(self)))
+        id_map[id(self)] = len(id_map)
+        if self._attr_gate is not None:
+            self._attr_gate.find_reachable(id_map)
+        for el in self._attr_operands:
+            el.find_reachable(id_map)
+        for el in self._attr_annotations:
+            el.find_reachable(id_map)
+        return id_map
+
+    def check_complete(self, id_map=None):
+        """Raises NotWellFormed if the tree rooted at this node is not
+        well-formed. If id_map is specified, this tree is only a subtree in the
+        context of a larger tree, and id_map must be a dict mapping from Python
+        id() codes to tree indices for all reachable nodes."""
+        if id_map is None:
+            id_map = self.find_reachable()
+        if self._attr_gate is None:
+            raise NotWellFormed('gate is required but not set')
+        if self._attr_gate is not None:
+            self._attr_gate.check_complete(id_map)
+        for child in self._attr_operands:
+            child.check_complete(id_map)
+        for child in self._attr_annotations:
+            child.check_complete(id_map)
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return GateInstruction(
+            instruction_ref=self._attr_instruction_ref,
+            gate=self._attr_gate,
+            operands=self._attr_operands.copy(),
+            annotations=self._attr_annotations.copy()
+        )
+
+    def clone(self):
+        """Returns a deep copy of this node. This mimics the C++ interface,
+        deficiencies with links included; that is, links always point to the
+        original tree. If you're not cloning a subtree in a context where this
+        is the desired behavior, you may want to use the copy.deepcopy() from
+        the stdlib instead, which should copy links correctly."""
+        return GateInstruction(
+            instruction_ref=_cloned(self._attr_instruction_ref),
+            gate=_cloned(self._attr_gate),
+            operands=_cloned(self._attr_operands),
+            annotations=_cloned(self._attr_annotations)
+        )
+
+    @staticmethod
+    def _deserialize(cbor, seq_to_ob, links):
+        """Attempts to deserialize the given cbor object (in Python primitive
+        representation) into a node of this type. All (sub)nodes are added to
+        the seq_to_ob dict, indexed by their cbor sequence number. All links are
+        registered in the links list by means of a two-tuple of the setter
+        function for the link field and the sequence number of the target node.
+        """
+        if not isinstance(cbor, dict):
+            raise TypeError('node description object must be a dict')
+        typ = cbor.get('@t', None)
+        if typ is None:
+            raise ValueError('type (@t) field is missing from node serialization')
+        if typ != 'GateInstruction':
+            raise ValueError('found node serialization for ' + typ + ', but expected GateInstruction')
+
+        # Deserialize the instruction_ref field.
+        field = cbor.get('instruction_ref', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field instruction_ref')
+        if hasattr(cqasm.v3x.instruction.InstructionRef, 'deserialize_cbor'):
+            f_instruction_ref = cqasm.v3x.instruction.InstructionRef.deserialize_cbor(field)
+        else:
+            f_instruction_ref = cqasm.v3x.primitives.deserialize(cqasm.v3x.instruction.InstructionRef, field)
+
+        # Deserialize the gate field.
+        field = cbor.get('gate', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field gate')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field gate')
+        if field.get('@t', None) is None:
+            f_gate = None
+        else:
+            f_gate = Gate._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the operands field.
+        field = cbor.get('operands', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field operands')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field operands')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_operands = cqasm.v3x.values.MultiValueBase()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_operands.append(cqasm.v3x.values.ValueBase._deserialize(element, seq_to_ob, links))
+
+        # Deserialize the annotations field.
+        field = cbor.get('annotations', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field annotations')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field annotations')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_annotations = MultiAnnotationData()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
+
+        # Construct the GateInstruction node.
+        node = GateInstruction(f_instruction_ref, f_gate, f_operands, f_annotations)
+
+        # Deserialize annotations.
+        for key, val in cbor.items():
+            if not (key.startswith('{') and key.endswith('}')):
+                continue
+            key = key[1:-1]
+            node[key] = cqasm.v3x.primitives.deserialize(key, val)
+
+        # Register node in sequence number lookup.
+        seq = cbor.get('@i', None)
+        if not isinstance(seq, int):
+            raise ValueError('sequence number field (@i) is not an integer or missing from node serialization')
+        if seq in seq_to_ob:
+            raise ValueError('duplicate sequence number %d' % seq)
+        seq_to_ob[seq] = node
+
+        return node
 
     def _serialize(self, id_map):
         """Serializes this node to the Python primitive representation of its
         CBOR serialization. The tree that the node belongs to must be
         well-formed. id_map must match Python id() calls for all nodes to unique
         integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'Statement'}
+        cbor = {'@i': id_map[id(self)], '@t': 'GateInstruction'}
+
+        # Serialize the instruction_ref field.
+        if hasattr(self._attr_instruction_ref, 'serialize_cbor'):
+            cbor['instruction_ref'] = self._attr_instruction_ref.serialize_cbor()
+        else:
+            cbor['instruction_ref'] = cqasm.v3x.primitives.serialize(cqasm.v3x.instruction.InstructionRef, self._attr_instruction_ref)
+
+        # Serialize the gate field.
+        field = {'@T': '1'}
+        if self._attr_gate is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_gate._serialize(id_map))
+        cbor['gate'] = field
+
+        # Serialize the operands field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_operands:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['operands'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}
@@ -1212,16 +1958,16 @@ class Statement(Annotated):
         return cbor
 
 
-class MultiStatement(_Multiple):
-    """Wrapper for an edge with multiple Statement objects."""
+class MultiGateInstruction(_Multiple):
+    """Wrapper for an edge with multiple GateInstruction objects."""
 
-    _T = Statement
+    _T = GateInstruction
 
 
-_typemap['Statement'] = Statement
+_typemap['GateInstruction'] = GateInstruction
 
-class Instruction(Statement):
-    """Regular instruction (a gate, or a measure instruction)."""
+class NonGateInstruction(Instruction):
+    """A measure instruction or a reset instruction"""
 
     __slots__ = [
         '_attr_instruction_ref',
@@ -1303,7 +2049,7 @@ class Instruction(Statement):
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Instruction):
+        if not isinstance(other, NonGateInstruction):
             return False
         if self.instruction_ref != other.instruction_ref:
             return False
@@ -1322,7 +2068,7 @@ class Instruction(Statement):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('Instruction(')
+        s.append('NonGateInstruction(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1391,7 +2137,7 @@ class Instruction(Statement):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return Instruction(
+        return NonGateInstruction(
             instruction_ref=self._attr_instruction_ref,
             name=self._attr_name,
             operands=self._attr_operands.copy(),
@@ -1404,7 +2150,7 @@ class Instruction(Statement):
         original tree. If you're not cloning a subtree in a context where this
         is the desired behavior, you may want to use the copy.deepcopy() from
         the stdlib instead, which should copy links correctly."""
-        return Instruction(
+        return NonGateInstruction(
             instruction_ref=_cloned(self._attr_instruction_ref),
             name=_cloned(self._attr_name),
             operands=_cloned(self._attr_operands),
@@ -1424,8 +2170,8 @@ class Instruction(Statement):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'Instruction':
-            raise ValueError('found node serialization for ' + typ + ', but expected Instruction')
+        if typ != 'NonGateInstruction':
+            raise ValueError('found node serialization for ' + typ + ', but expected NonGateInstruction')
 
         # Deserialize the instruction_ref field.
         field = cbor.get('instruction_ref', None)
@@ -1475,8 +2221,8 @@ class Instruction(Statement):
                 raise ValueError('unexpected edge type for Any/Many element')
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
-        # Construct the Instruction node.
-        node = Instruction(f_instruction_ref, f_name, f_operands, f_annotations)
+        # Construct the NonGateInstruction node.
+        node = NonGateInstruction(f_instruction_ref, f_name, f_operands, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1500,7 +2246,7 @@ class Instruction(Statement):
         CBOR serialization. The tree that the node belongs to must be
         well-formed. id_map must match Python id() calls for all nodes to unique
         integers, to use for the sequence number representation of links."""
-        cbor = {'@i': id_map[id(self)], '@t': 'Instruction'}
+        cbor = {'@i': id_map[id(self)], '@t': 'NonGateInstruction'}
 
         # Serialize the instruction_ref field.
         if hasattr(self._attr_instruction_ref, 'serialize_cbor'):
@@ -1541,13 +2287,13 @@ class Instruction(Statement):
         return cbor
 
 
-class MultiInstruction(_Multiple):
-    """Wrapper for an edge with multiple Instruction objects."""
+class MultiNonGateInstruction(_Multiple):
+    """Wrapper for an edge with multiple NonGateInstruction objects."""
 
-    _T = Instruction
+    _T = NonGateInstruction
 
 
-_typemap['Instruction'] = Instruction
+_typemap['NonGateInstruction'] = NonGateInstruction
 
 class Program(Node):
     __slots__ = [