libqasm 0.6.5__cp312-cp312-win_amd64.whl → 0.6.7__cp312-cp312-win_amd64.whl

cqasm/v3x/ast.py

@@ -1172,6 +1172,8 @@ class Annotated(Node):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -2526,6 +2528,8 @@ class Statement(Annotated):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -2588,6 +2592,8 @@ class BlockStatement(Statement):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -5003,6 +5009,8 @@ class Instruction(BlockStatement):
             return Gate._deserialize(cbor, seq_to_ob, links)
         if typ == 'MeasureInstruction':
             return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'ResetInstruction':
+            return ResetInstruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -5331,91 +5339,41 @@ _typemap['Gate'] = Gate
 
 class GlobalBlock(Block):
     __slots__ = [
-        '_attr_qubit_variable_declaration',
-        '_attr_gates',
-        '_attr_measure_instructions',
+        '_attr_statements',
     ]
 
     def __init__(
         self,
-        qubit_variable_declaration=None,
-        gates=None,
-        measure_instructions=None,
+        statements=None,
     ):
         super().__init__()
-        self.qubit_variable_declaration = qubit_variable_declaration
-        self.gates = gates
-        self.measure_instructions = measure_instructions
+        self.statements = statements
 
     @property
-    def qubit_variable_declaration(self):
-        return self._attr_qubit_variable_declaration
+    def statements(self):
+        return self._attr_statements
 
-    @qubit_variable_declaration.setter
-    def qubit_variable_declaration(self, val):
+    @statements.setter
+    def statements(self, val):
         if val is None:
-            del self.qubit_variable_declaration
+            del self.statements
             return
-        if not isinstance(val, Variable):
+        if not isinstance(val, MultiStatement):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('qubit_variable_declaration must be of type Variable')
-            val = Variable(val)
-        self._attr_qubit_variable_declaration = val
+                raise TypeError('statements must be of type MultiStatement')
+            val = MultiStatement(val)
+        self._attr_statements = val
 
-    @qubit_variable_declaration.deleter
-    def qubit_variable_declaration(self):
-        self._attr_qubit_variable_declaration = None
-
-    @property
-    def gates(self):
-        return self._attr_gates
-
-    @gates.setter
-    def gates(self, val):
-        if val is None:
-            del self.gates
-            return
-        if not isinstance(val, MultiGate):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('gates must be of type MultiGate')
-            val = MultiGate(val)
-        self._attr_gates = val
-
-    @gates.deleter
-    def gates(self):
-        self._attr_gates = MultiGate()
-
-    @property
-    def measure_instructions(self):
-        return self._attr_measure_instructions
-
-    @measure_instructions.setter
-    def measure_instructions(self, val):
-        if val is None:
-            del self.measure_instructions
-            return
-        if not isinstance(val, MultiMeasureInstruction):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('measure_instructions must be of type MultiMeasureInstruction')
-            val = MultiMeasureInstruction(val)
-        self._attr_measure_instructions = val
-
-    @measure_instructions.deleter
-    def measure_instructions(self):
-        self._attr_measure_instructions = MultiMeasureInstruction()
+    @statements.deleter
+    def statements(self):
+        self._attr_statements = MultiStatement()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
         if not isinstance(other, GlobalBlock):
             return False
-        if self.qubit_variable_declaration != other.qubit_variable_declaration:
-            return False
-        if self.gates != other.gates:
-            return False
-        if self.measure_instructions != other.measure_instructions:
+        if self.statements != other.statements:
             return False
         return True
 
@@ -5435,29 +5393,12 @@ class GlobalBlock(Block):
         s.append('\n')
         indent += 1
         s.append('  '*indent)
-        s.append('qubit_variable_declaration: ')
-        if self.qubit_variable_declaration is None:
-            s.append('!MISSING\n')
-        else:
-            s.append('<\n')
-            s.append(self.qubit_variable_declaration.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + '>\n')
-        s.append('  '*indent)
-        s.append('gates: ')
-        if not self.gates:
+        s.append('statements: ')
+        if not self.statements:
             s.append('-\n')
         else:
             s.append('[\n')
-            for child in self.gates:
-                s.append(child.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + ']\n')
-        s.append('  '*indent)
-        s.append('measure_instructions: ')
-        if not self.measure_instructions:
-            s.append('-\n')
-        else:
-            s.append('[\n')
-            for child in self.measure_instructions:
+            for child in self.statements:
                 s.append(child.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + ']\n')
         indent -= 1
@@ -5477,11 +5418,7 @@ class GlobalBlock(Block):
         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_qubit_variable_declaration is not None:
-            self._attr_qubit_variable_declaration.find_reachable(id_map)
-        for el in self._attr_gates:
-            el.find_reachable(id_map)
-        for el in self._attr_measure_instructions:
+        for el in self._attr_statements:
             el.find_reachable(id_map)
         return id_map
 
@@ -5492,21 +5429,13 @@ class GlobalBlock(Block):
         id() codes to tree indices for all reachable nodes."""
         if id_map is None:
             id_map = self.find_reachable()
-        if self._attr_qubit_variable_declaration is None:
-            raise NotWellFormed('qubit_variable_declaration is required but not set')
-        if self._attr_qubit_variable_declaration is not None:
-            self._attr_qubit_variable_declaration.check_complete(id_map)
-        for child in self._attr_gates:
-            child.check_complete(id_map)
-        for child in self._attr_measure_instructions:
+        for child in self._attr_statements:
             child.check_complete(id_map)
 
     def copy(self):
         """Returns a shallow copy of this node."""
         return GlobalBlock(
-            qubit_variable_declaration=self._attr_qubit_variable_declaration,
-            gates=self._attr_gates.copy(),
-            measure_instructions=self._attr_measure_instructions.copy()
+            statements=self._attr_statements.copy()
         )
 
     def clone(self):
@@ -5516,9 +5445,7 @@ class GlobalBlock(Block):
         is the desired behavior, you may want to use the copy.deepcopy() from
         the stdlib instead, which should copy links correctly."""
         return GlobalBlock(
-            qubit_variable_declaration=_cloned(self._attr_qubit_variable_declaration),
-            gates=_cloned(self._attr_gates),
-            measure_instructions=_cloned(self._attr_measure_instructions)
+            statements=_cloned(self._attr_statements)
         )
 
     @staticmethod
@@ -5537,49 +5464,23 @@ class GlobalBlock(Block):
         if typ != 'GlobalBlock':
             raise ValueError('found node serialization for ' + typ + ', but expected GlobalBlock')
 
-        # Deserialize the qubit_variable_declaration field.
-        field = cbor.get('qubit_variable_declaration', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field qubit_variable_declaration')
-        if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field qubit_variable_declaration')
-        if field.get('@t', None) is None:
-            f_qubit_variable_declaration = None
-        else:
-            f_qubit_variable_declaration = Variable._deserialize(field, seq_to_ob, links)
-
-        # Deserialize the gates field.
-        field = cbor.get('gates', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field gates')
-        if field.get('@T') != '*':
-            raise ValueError('unexpected edge type for field gates')
-        data = field.get('@d', None)
-        if not isinstance(data, list):
-            raise ValueError('missing serialization of Any/Many contents')
-        f_gates = MultiGate()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_gates.append(Gate._deserialize(element, seq_to_ob, links))
-
-        # Deserialize the measure_instructions field.
-        field = cbor.get('measure_instructions', None)
+        # Deserialize the statements field.
+        field = cbor.get('statements', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field measure_instructions')
+            raise ValueError('missing or invalid serialization of field statements')
         if field.get('@T') != '*':
-            raise ValueError('unexpected edge type for field measure_instructions')
+            raise ValueError('unexpected edge type for field statements')
         data = field.get('@d', None)
         if not isinstance(data, list):
             raise ValueError('missing serialization of Any/Many contents')
-        f_measure_instructions = MultiMeasureInstruction()
+        f_statements = MultiStatement()
         for element in data:
             if element.get('@T') != '1':
                 raise ValueError('unexpected edge type for Any/Many element')
-            f_measure_instructions.append(MeasureInstruction._deserialize(element, seq_to_ob, links))
+            f_statements.append(Statement._deserialize(element, seq_to_ob, links))
 
         # Construct the GlobalBlock node.
-        node = GlobalBlock(f_qubit_variable_declaration, f_gates, f_measure_instructions)
+        node = GlobalBlock(f_statements)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -5605,33 +5506,15 @@ class GlobalBlock(Block):
         integers, to use for the sequence number representation of links."""
         cbor = {'@i': id_map[id(self)], '@t': 'GlobalBlock'}
 
-        # Serialize the qubit_variable_declaration field.
-        field = {'@T': '1'}
-        if self._attr_qubit_variable_declaration is None:
-            field['@t'] = None
-        else:
-            field.update(self._attr_qubit_variable_declaration._serialize(id_map))
-        cbor['qubit_variable_declaration'] = field
-
-        # Serialize the gates field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_gates:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['gates'] = field
-
-        # Serialize the measure_instructions field.
+        # Serialize the statements field.
         field = {'@T': '*'}
         lst = []
-        for el in self._attr_measure_instructions:
+        for el in self._attr_statements:
             el = el._serialize(id_map)
             el['@T'] = '1'
             lst.append(el)
         field['@d'] = lst
-        cbor['measure_instructions'] = field
+        cbor['statements'] = field
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -7952,20 +7835,28 @@ class MultiLogicalXorExpression(_Multiple):
 _typemap['LogicalXorExpression'] = LogicalXorExpression
 
 class MeasureInstruction(Instruction):
+    """For some instructions, like the measure instruction, we want to
+    differentiate between left hand side and right and side operands. For a
+    measure instruction, the right hand side operand should be a qubit, and the
+    left hand side operand a bit."""
+
     __slots__ = [
         '_attr_name',
-        '_attr_operand',
+        '_attr_lhs',
+        '_attr_rhs',
     ]
 
     def __init__(
         self,
         name=None,
-        operand=None,
+        lhs=None,
+        rhs=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.name = name
-        self.operand = operand
+        self.lhs = lhs
+        self.rhs = rhs
 
     @property
     def name(self):
@@ -7988,24 +7879,44 @@ class MeasureInstruction(Instruction):
         self._attr_name = None
 
     @property
-    def operand(self):
-        return self._attr_operand
+    def lhs(self):
+        return self._attr_lhs
 
-    @operand.setter
-    def operand(self, val):
+    @lhs.setter
+    def lhs(self, val):
         if val is None:
-            del self.operand
+            del self.lhs
             return
         if not isinstance(val, Expression):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('operand must be of type Expression')
+                raise TypeError('lhs must be of type Expression')
             val = Expression(val)
-        self._attr_operand = val
+        self._attr_lhs = val
 
-    @operand.deleter
-    def operand(self):
-        self._attr_operand = None
+    @lhs.deleter
+    def lhs(self):
+        self._attr_lhs = None
+
+    @property
+    def rhs(self):
+        return self._attr_rhs
+
+    @rhs.setter
+    def rhs(self, val):
+        if val is None:
+            del self.rhs
+            return
+        if not isinstance(val, Expression):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('rhs must be of type Expression')
+            val = Expression(val)
+        self._attr_rhs = val
+
+    @rhs.deleter
+    def rhs(self):
+        self._attr_rhs = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -8013,7 +7924,9 @@ class MeasureInstruction(Instruction):
             return False
         if self.name != other.name:
             return False
-        if self.operand != other.operand:
+        if self.lhs != other.lhs:
+            return False
+        if self.rhs != other.rhs:
             return False
         if self.annotations != other.annotations:
             return False
@@ -8043,12 +7956,20 @@ class MeasureInstruction(Instruction):
             s.append(self.name.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('operand: ')
-        if self.operand is None:
+        s.append('lhs: ')
+        if self.lhs is None:
             s.append('!MISSING\n')
         else:
             s.append('<\n')
-            s.append(self.operand.dump(indent + 1, annotations, links) + '\n')
+            s.append(self.lhs.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('rhs: ')
+        if self.rhs is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            s.append(self.rhs.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
         s.append('annotations: ')
@@ -8078,8 +7999,10 @@ class MeasureInstruction(Instruction):
         id_map[id(self)] = len(id_map)
         if self._attr_name is not None:
             self._attr_name.find_reachable(id_map)
-        if self._attr_operand is not None:
-            self._attr_operand.find_reachable(id_map)
+        if self._attr_lhs is not None:
+            self._attr_lhs.find_reachable(id_map)
+        if self._attr_rhs is not None:
+            self._attr_rhs.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -8095,10 +8018,14 @@ class MeasureInstruction(Instruction):
             raise NotWellFormed('name is required but not set')
         if self._attr_name is not None:
             self._attr_name.check_complete(id_map)
-        if self._attr_operand is None:
-            raise NotWellFormed('operand is required but not set')
-        if self._attr_operand is not None:
-            self._attr_operand.check_complete(id_map)
+        if self._attr_lhs is None:
+            raise NotWellFormed('lhs is required but not set')
+        if self._attr_lhs is not None:
+            self._attr_lhs.check_complete(id_map)
+        if self._attr_rhs is None:
+            raise NotWellFormed('rhs is required but not set')
+        if self._attr_rhs is not None:
+            self._attr_rhs.check_complete(id_map)
         for child in self._attr_annotations:
             child.check_complete(id_map)
 
@@ -8106,7 +8033,8 @@ class MeasureInstruction(Instruction):
         """Returns a shallow copy of this node."""
         return MeasureInstruction(
             name=self._attr_name,
-            operand=self._attr_operand,
+            lhs=self._attr_lhs,
+            rhs=self._attr_rhs,
             annotations=self._attr_annotations.copy()
         )
 
@@ -8118,7 +8046,8 @@ class MeasureInstruction(Instruction):
         the stdlib instead, which should copy links correctly."""
         return MeasureInstruction(
             name=_cloned(self._attr_name),
-            operand=_cloned(self._attr_operand),
+            lhs=_cloned(self._attr_lhs),
+            rhs=_cloned(self._attr_rhs),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -8149,16 +8078,27 @@ class MeasureInstruction(Instruction):
         else:
             f_name = Identifier._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the operand field.
-        field = cbor.get('operand', None)
+        # Deserialize the lhs field.
+        field = cbor.get('lhs', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field operand')
+            raise ValueError('missing or invalid serialization of field lhs')
         if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field operand')
+            raise ValueError('unexpected edge type for field lhs')
         if field.get('@t', None) is None:
-            f_operand = None
+            f_lhs = None
         else:
-            f_operand = Expression._deserialize(field, seq_to_ob, links)
+            f_lhs = Expression._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the rhs field.
+        field = cbor.get('rhs', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field rhs')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field rhs')
+        if field.get('@t', None) is None:
+            f_rhs = None
+        else:
+            f_rhs = Expression._deserialize(field, seq_to_ob, links)
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -8176,7 +8116,7 @@ class MeasureInstruction(Instruction):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the MeasureInstruction node.
-        node = MeasureInstruction(f_name, f_operand, f_annotations)
+        node = MeasureInstruction(f_name, f_lhs, f_rhs, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -8210,13 +8150,21 @@ class MeasureInstruction(Instruction):
             field.update(self._attr_name._serialize(id_map))
         cbor['name'] = field
 
-        # Serialize the operand field.
+        # Serialize the lhs field.
         field = {'@T': '1'}
-        if self._attr_operand is None:
+        if self._attr_lhs is None:
             field['@t'] = None
         else:
-            field.update(self._attr_operand._serialize(id_map))
-        cbor['operand'] = field
+            field.update(self._attr_lhs._serialize(id_map))
+        cbor['lhs'] = field
+
+        # Serialize the rhs field.
+        field = {'@T': '1'}
+        if self._attr_rhs is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_rhs._serialize(id_map))
+        cbor['rhs'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}
@@ -8991,7 +8939,7 @@ class Program(Root):
         s.append('  '*indent)
         s.append('block: ')
         if self.block is None:
-            s.append('-\n')
+            s.append('!MISSING\n')
         else:
             s.append('<\n')
             s.append(self.block.dump(indent + 1, annotations, links) + '\n')
@@ -9030,6 +8978,8 @@ class Program(Root):
             raise NotWellFormed('version is required but not set')
         if self._attr_version is not None:
             self._attr_version.check_complete(id_map)
+        if self._attr_block is None:
+            raise NotWellFormed('block is required but not set')
         if self._attr_block is not None:
             self._attr_block.check_complete(id_map)
 
@@ -9082,7 +9032,7 @@ class Program(Root):
         field = cbor.get('block', None)
         if not isinstance(field, dict):
             raise ValueError('missing or invalid serialization of field block')
-        if field.get('@T') != '?':
+        if field.get('@T') != '1':
             raise ValueError('unexpected edge type for field block')
         if field.get('@t', None) is None:
             f_block = None
@@ -9125,7 +9075,7 @@ class Program(Root):
         cbor['version'] = field
 
         # Serialize the block field.
-        field = {'@T': '?'}
+        field = {'@T': '1'}
         if self._attr_block is None:
             field['@t'] = None
         else:
@@ -9147,6 +9097,296 @@ class MultiProgram(_Multiple):
 
 _typemap['Program'] = Program
 
+class ResetInstruction(Instruction):
+    __slots__ = [
+        '_attr_name',
+        '_attr_operand',
+    ]
+
+    def __init__(
+        self,
+        name=None,
+        operand=None,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+        self.name = name
+        self.operand = operand
+
+    @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, Identifier):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('name must be of type Identifier')
+            val = Identifier(val)
+        self._attr_name = val
+
+    @name.deleter
+    def name(self):
+        self._attr_name = None
+
+    @property
+    def operand(self):
+        return self._attr_operand
+
+    @operand.setter
+    def operand(self, val):
+        if val is None:
+            del self.operand
+            return
+        if not isinstance(val, Expression):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('operand must be of type Expression')
+            val = Expression(val)
+        self._attr_operand = val
+
+    @operand.deleter
+    def operand(self):
+        self._attr_operand = None
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, ResetInstruction):
+            return False
+        if self.name != other.name:
+            return False
+        if self.operand != other.operand:
+            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('ResetInstruction(')
+        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: ')
+        if self.name is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            s.append(self.name.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
+        s.append('  '*indent)
+        s.append('operand: ')
+        if self.operand is None:
+            s.append('-\n')
+        else:
+            s.append('<\n')
+            s.append(self.operand.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_name is not None:
+            self._attr_name.find_reachable(id_map)
+        if self._attr_operand is not None:
+            self._attr_operand.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_name is None:
+            raise NotWellFormed('name is required but not set')
+        if self._attr_name is not None:
+            self._attr_name.check_complete(id_map)
+        if self._attr_operand is not None:
+            self._attr_operand.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 ResetInstruction(
+            name=self._attr_name,
+            operand=self._attr_operand,
+            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 ResetInstruction(
+            name=_cloned(self._attr_name),
+            operand=_cloned(self._attr_operand),
+            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 != 'ResetInstruction':
+            raise ValueError('found node serialization for ' + typ + ', but expected ResetInstruction')
+
+        # Deserialize the name field.
+        field = cbor.get('name', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field name')
+        if field.get('@T') != '1':
+            raise ValueError('unexpected edge type for field name')
+        if field.get('@t', None) is None:
+            f_name = None
+        else:
+            f_name = Identifier._deserialize(field, seq_to_ob, links)
+
+        # Deserialize the operand field.
+        field = cbor.get('operand', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field operand')
+        if field.get('@T') != '?':
+            raise ValueError('unexpected edge type for field operand')
+        if field.get('@t', None) is None:
+            f_operand = None
+        else:
+            f_operand = Expression._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 ResetInstruction node.
+        node = ResetInstruction(f_name, f_operand, 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': 'ResetInstruction'}
+
+        # Serialize the name field.
+        field = {'@T': '1'}
+        if self._attr_name is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_name._serialize(id_map))
+        cbor['name'] = field
+
+        # Serialize the operand field.
+        field = {'@T': '?'}
+        if self._attr_operand is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_operand._serialize(id_map))
+        cbor['operand'] = 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 MultiResetInstruction(_Multiple):
+    """Wrapper for an edge with multiple ResetInstruction objects."""
+
+    _T = ResetInstruction
+
+
+_typemap['ResetInstruction'] = ResetInstruction
+
 class ShiftExpression(BinaryExpression):
     __slots__ = []