libqasm 0.6.6__cp310-cp310-win_amd64.whl → 0.6.8__cp310-cp310-win_amd64.whl

cqasm/v3x/ast.py

@@ -1166,12 +1166,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 == 'Variable':
-            return Variable._deserialize(cbor, seq_to_ob, links)
         if typ == 'Gate':
             return Gate._deserialize(cbor, seq_to_ob, links)
-        if typ == 'MeasureInstruction':
-            return MeasureInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'Variable':
+            return Variable._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):
@@ -2522,10 +2524,10 @@ class Statement(Annotated):
             raise ValueError('type (@t) field is missing from node serialization')
         if typ == 'Variable':
             return Variable._deserialize(cbor, seq_to_ob, links)
-        if typ == 'Gate':
-            return Gate._deserialize(cbor, seq_to_ob, links)
-        if typ == 'MeasureInstruction':
-            return MeasureInstruction._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):
@@ -2584,10 +2586,10 @@ class BlockStatement(Statement):
             raise ValueError('type (@t) field is missing from node serialization')
         if typ == 'Variable':
             return Variable._deserialize(cbor, seq_to_ob, links)
-        if typ == 'Gate':
-            return Gate._deserialize(cbor, seq_to_ob, links)
-        if typ == 'MeasureInstruction':
-            return MeasureInstruction._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):
@@ -4977,81 +4979,27 @@ class MultiFunctionCall(_Multiple):
 
 _typemap['FunctionCall'] = FunctionCall
 
-class Instruction(BlockStatement):
-    __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 == 'Gate':
-            return Gate._deserialize(cbor, seq_to_ob, links)
-        if typ == 'MeasureInstruction':
-            return MeasureInstruction._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 Gate(Annotated):
+    """A gate can be a named gate or a composition of gate modifiers acting on a
+     gate."""
 
-class Gate(Instruction):
     __slots__ = [
         '_attr_name',
-        '_attr_operands',
+        '_attr_gate',
+        '_attr_parameter',
     ]
 
     def __init__(
         self,
         name=None,
-        operands=None,
+        gate=None,
+        parameter=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.name = name
-        self.operands = operands
+        self.gate = gate
+        self.parameter = parameter
 
     @property
     def name(self):
@@ -5074,24 +5022,44 @@ class Gate(Instruction):
         self._attr_name = None
 
     @property
-    def operands(self):
-        return self._attr_operands
+    def gate(self):
+        return self._attr_gate
 
-    @operands.setter
-    def operands(self, val):
+    @gate.setter
+    def gate(self, val):
         if val is None:
-            del self.operands
+            del self.gate
             return
-        if not isinstance(val, ExpressionList):
+        if not isinstance(val, Gate):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('operands must be of type ExpressionList')
-            val = ExpressionList(val)
-        self._attr_operands = val
+                raise TypeError('gate must be of type Gate')
+            val = Gate(val)
+        self._attr_gate = val
 
-    @operands.deleter
-    def operands(self):
-        self._attr_operands = None
+    @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, Expression):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('parameter must be of type Expression')
+            val = Expression(val)
+        self._attr_parameter = val
+
+    @parameter.deleter
+    def parameter(self):
+        self._attr_parameter = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -5099,7 +5067,9 @@ class Gate(Instruction):
             return False
         if self.name != other.name:
             return False
-        if self.operands != other.operands:
+        if self.gate != other.gate:
+            return False
+        if self.parameter != other.parameter:
             return False
         if self.annotations != other.annotations:
             return False
@@ -5129,12 +5099,20 @@ class Gate(Instruction):
             s.append(self.name.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('operands: ')
-        if self.operands is None:
-            s.append('!MISSING\n')
+        s.append('gate: ')
+        if self.gate is None:
+            s.append('-\n')
         else:
             s.append('<\n')
-            s.append(self.operands.dump(indent + 1, annotations, links) + '\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: ')
@@ -5164,8 +5142,10 @@ class Gate(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_operands is not None:
-            self._attr_operands.find_reachable(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
@@ -5181,10 +5161,10 @@ class Gate(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_operands is None:
-            raise NotWellFormed('operands is required but not set')
-        if self._attr_operands is not None:
-            self._attr_operands.check_complete(id_map)
+        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)
 
@@ -5192,7 +5172,8 @@ class Gate(Instruction):
         """Returns a shallow copy of this node."""
         return Gate(
             name=self._attr_name,
-            operands=self._attr_operands,
+            gate=self._attr_gate,
+            parameter=self._attr_parameter,
             annotations=self._attr_annotations.copy()
         )
 
@@ -5204,7 +5185,8 @@ class Gate(Instruction):
         the stdlib instead, which should copy links correctly."""
         return Gate(
             name=_cloned(self._attr_name),
-            operands=_cloned(self._attr_operands),
+            gate=_cloned(self._attr_gate),
+            parameter=_cloned(self._attr_parameter),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -5235,16 +5217,27 @@ class Gate(Instruction):
         else:
             f_name = Identifier._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the operands field.
-        field = cbor.get('operands', None)
+        # Deserialize the gate field.
+        field = cbor.get('gate', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field operands')
-        if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field operands')
+            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_operands = None
+            f_gate = None
         else:
-            f_operands = ExpressionList._deserialize(field, seq_to_ob, links)
+            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 = Expression._deserialize(field, seq_to_ob, links)
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -5262,7 +5255,7 @@ class Gate(Instruction):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the Gate node.
-        node = Gate(f_name, f_operands, f_annotations)
+        node = Gate(f_name, f_gate, f_parameter, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -5296,13 +5289,21 @@ class Gate(Instruction):
             field.update(self._attr_name._serialize(id_map))
         cbor['name'] = field
 
-        # Serialize the operands field.
-        field = {'@T': '1'}
-        if self._attr_operands is None:
+        # Serialize the gate field.
+        field = {'@T': '?'}
+        if self._attr_gate is None:
             field['@t'] = None
         else:
-            field.update(self._attr_operands._serialize(id_map))
-        cbor['operands'] = field
+            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': '*'}
@@ -5329,43 +5330,131 @@ class MultiGate(_Multiple):
 
 _typemap['Gate'] = Gate
 
-class GlobalBlock(Block):
+class Instruction(BlockStatement):
+    __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):
     __slots__ = [
-        '_attr_statements',
+        '_attr_gate',
+        '_attr_operands',
     ]
 
     def __init__(
         self,
-        statements=None,
+        gate=None,
+        operands=None,
+        annotations=None,
     ):
-        super().__init__()
-        self.statements = statements
+        super().__init__(annotations=annotations)
+        self.gate = gate
+        self.operands = operands
 
     @property
-    def statements(self):
-        return self._attr_statements
+    def gate(self):
+        return self._attr_gate
 
-    @statements.setter
-    def statements(self, val):
+    @gate.setter
+    def gate(self, val):
         if val is None:
-            del self.statements
+            del self.gate
             return
-        if not isinstance(val, MultiStatement):
+        if not isinstance(val, Gate):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('statements must be of type MultiStatement')
-            val = MultiStatement(val)
-        self._attr_statements = val
+                raise TypeError('gate must be of type Gate')
+            val = Gate(val)
+        self._attr_gate = val
 
-    @statements.deleter
-    def statements(self):
-        self._attr_statements = MultiStatement()
+    @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, ExpressionList):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('operands must be of type ExpressionList')
+            val = ExpressionList(val)
+        self._attr_operands = val
+
+    @operands.deleter
+    def operands(self):
+        self._attr_operands = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, GlobalBlock):
+        if not isinstance(other, GateInstruction):
             return False
-        if self.statements != other.statements:
+        if self.gate != other.gate:
+            return False
+        if self.operands != other.operands:
+            return False
+        if self.annotations != other.annotations:
             return False
         return True
 
@@ -5376,7 +5465,7 @@ class GlobalBlock(Block):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('GlobalBlock(')
+        s.append('GateInstruction(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -5385,12 +5474,276 @@ class GlobalBlock(Block):
         s.append('\n')
         indent += 1
         s.append('  '*indent)
-        s.append('statements: ')
-        if not self.statements:
+        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 self.operands is None:
+            s.append('!MISSING\n')
+        else:
+            s.append('<\n')
+            s.append(self.operands.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.statements:
+            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_operands is not None:
+            self._attr_operands.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)
+        if self._attr_operands is None:
+            raise NotWellFormed('operands is required but not set')
+        if self._attr_operands is not None:
+            self._attr_operands.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(
+            gate=self._attr_gate,
+            operands=self._attr_operands,
+            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(
+            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 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') != '1':
+            raise ValueError('unexpected edge type for field operands')
+        if field.get('@t', None) is None:
+            f_operands = None
+        else:
+            f_operands = ExpressionList._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 GateInstruction node.
+        node = GateInstruction(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': 'GateInstruction'}
+
+        # 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': '1'}
+        if self._attr_operands is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_operands._serialize(id_map))
+        cbor['operands'] = 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 MultiGateInstruction(_Multiple):
+    """Wrapper for an edge with multiple GateInstruction objects."""
+
+    _T = GateInstruction
+
+
+_typemap['GateInstruction'] = GateInstruction
+
+class GlobalBlock(Block):
+    __slots__ = [
+        '_attr_statements',
+    ]
+
+    def __init__(
+        self,
+        statements=None,
+    ):
+        super().__init__()
+        self.statements = statements
+
+    @property
+    def statements(self):
+        return self._attr_statements
+
+    @statements.setter
+    def statements(self, val):
+        if val is None:
+            del self.statements
+            return
+        if not isinstance(val, MultiStatement):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('statements must be of type MultiStatement')
+            val = MultiStatement(val)
+        self._attr_statements = val
+
+    @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.statements != other.statements:
+            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('GlobalBlock(')
+        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('statements: ')
+        if not self.statements:
+            s.append('-\n')
+        else:
+            s.append('[\n')
+            for child in self.statements:
                 s.append(child.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + ']\n')
         indent -= 1
@@ -7826,103 +8179,25 @@ 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_lhs',
-        '_attr_rhs',
-    ]
+class ModuloExpression(ArithmeticExpression):
+    __slots__ = []
 
     def __init__(
         self,
-        name=None,
         lhs=None,
         rhs=None,
-        annotations=None,
     ):
-        super().__init__(annotations=annotations)
-        self.name = name
-        self.lhs = lhs
-        self.rhs = rhs
+        super().__init__(lhs=lhs, rhs=rhs)
 
-    @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 lhs(self):
-        return self._attr_lhs
-
-    @lhs.setter
-    def lhs(self, val):
-        if val is None:
-            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('lhs must be of type Expression')
-            val = Expression(val)
-        self._attr_lhs = val
-
-    @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!"""
-        if not isinstance(other, MeasureInstruction):
-            return False
-        if self.name != other.name:
-            return False
-        if self.lhs != other.lhs:
-            return False
-        if self.rhs != other.rhs:
-            return False
-        if self.annotations != other.annotations:
-            return False
-        return True
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, ModuloExpression):
+            return False
+        if self.lhs != other.lhs:
+            return False
+        if self.rhs != other.rhs:
+            return False
+        return True
 
     def dump(self, indent=0, annotations=None, links=1):
         """Returns a debug representation of this tree as a multiline string.
@@ -7931,7 +8206,7 @@ class MeasureInstruction(Instruction):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('MeasureInstruction(')
+        s.append('ModuloExpression(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -7940,14 +8215,6 @@ class MeasureInstruction(Instruction):
         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('lhs: ')
         if self.lhs is None:
             s.append('!MISSING\n')
@@ -7963,15 +8230,6 @@ class MeasureInstruction(Instruction):
             s.append('<\n')
             s.append(self.rhs.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(')')
@@ -7989,14 +8247,10 @@ class MeasureInstruction(Instruction):
         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_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
 
     def check_complete(self, id_map=None):
@@ -8006,10 +8260,6 @@ class MeasureInstruction(Instruction):
         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_lhs is None:
             raise NotWellFormed('lhs is required but not set')
         if self._attr_lhs is not None:
@@ -8018,16 +8268,12 @@ class MeasureInstruction(Instruction):
             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)
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return MeasureInstruction(
-            name=self._attr_name,
+        return ModuloExpression(
             lhs=self._attr_lhs,
-            rhs=self._attr_rhs,
-            annotations=self._attr_annotations.copy()
+            rhs=self._attr_rhs
         )
 
     def clone(self):
@@ -8036,11 +8282,9 @@ class MeasureInstruction(Instruction):
         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 MeasureInstruction(
-            name=_cloned(self._attr_name),
+        return ModuloExpression(
             lhs=_cloned(self._attr_lhs),
-            rhs=_cloned(self._attr_rhs),
-            annotations=_cloned(self._attr_annotations)
+            rhs=_cloned(self._attr_rhs)
         )
 
     @staticmethod
@@ -8056,19 +8300,8 @@ class MeasureInstruction(Instruction):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'MeasureInstruction':
-            raise ValueError('found node serialization for ' + typ + ', but expected MeasureInstruction')
-
-        # 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)
+        if typ != 'ModuloExpression':
+            raise ValueError('found node serialization for ' + typ + ', but expected ModuloExpression')
 
         # Deserialize the lhs field.
         field = cbor.get('lhs', None)
@@ -8092,23 +8325,8 @@ class MeasureInstruction(Instruction):
         else:
             f_rhs = 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 MeasureInstruction node.
-        node = MeasureInstruction(f_name, f_lhs, f_rhs, f_annotations)
+        # Construct the ModuloExpression node.
+        node = ModuloExpression(f_lhs, f_rhs)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -8132,15 +8350,7 @@ class MeasureInstruction(Instruction):
         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': 'MeasureInstruction'}
-
-        # 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
+        cbor = {'@i': id_map[id(self)], '@t': 'ModuloExpression'}
 
         # Serialize the lhs field.
         field = {'@T': '1'}
@@ -8158,16 +8368,6 @@ class MeasureInstruction(Instruction):
             field.update(self._attr_rhs._serialize(id_map))
         cbor['rhs'] = 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))
@@ -8175,31 +8375,79 @@ class MeasureInstruction(Instruction):
         return cbor
 
 
-class MultiMeasureInstruction(_Multiple):
-    """Wrapper for an edge with multiple MeasureInstruction objects."""
+class MultiModuloExpression(_Multiple):
+    """Wrapper for an edge with multiple ModuloExpression objects."""
 
-    _T = MeasureInstruction
+    _T = ModuloExpression
 
 
-_typemap['MeasureInstruction'] = MeasureInstruction
+_typemap['ModuloExpression'] = ModuloExpression
 
-class ModuloExpression(ArithmeticExpression):
-    __slots__ = []
+class NonGateInstruction(Instruction):
+    __slots__ = [
+        '_attr_name',
+        '_attr_operands',
+    ]
 
     def __init__(
         self,
-        lhs=None,
-        rhs=None,
+        name=None,
+        operands=None,
+        annotations=None,
     ):
-        super().__init__(lhs=lhs, rhs=rhs)
+        super().__init__(annotations=annotations)
+        self.name = name
+        self.operands = operands
+
+    @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, Keyword):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('name must be of type Keyword')
+            val = Keyword(val)
+        self._attr_name = val
+
+    @name.deleter
+    def name(self):
+        self._attr_name = 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, ExpressionList):
+            # Try to "typecast" if this isn't an obvious mistake.
+            if isinstance(val, Node):
+                raise TypeError('operands must be of type ExpressionList')
+            val = ExpressionList(val)
+        self._attr_operands = val
+
+    @operands.deleter
+    def operands(self):
+        self._attr_operands = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, ModuloExpression):
+        if not isinstance(other, NonGateInstruction):
             return False
-        if self.lhs != other.lhs:
+        if self.name != other.name:
             return False
-        if self.rhs != other.rhs:
+        if self.operands != other.operands:
+            return False
+        if self.annotations != other.annotations:
             return False
         return True
 
@@ -8210,7 +8458,7 @@ class ModuloExpression(ArithmeticExpression):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('ModuloExpression(')
+        s.append('NonGateInstruction(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -8219,21 +8467,30 @@ class ModuloExpression(ArithmeticExpression):
         s.append('\n')
         indent += 1
         s.append('  '*indent)
-        s.append('lhs: ')
-        if self.lhs is None:
+        s.append('name: ')
+        if self.name is None:
             s.append('!MISSING\n')
         else:
             s.append('<\n')
-            s.append(self.lhs.dump(indent + 1, annotations, links) + '\n')
+            s.append(self.name.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('rhs: ')
-        if self.rhs is None:
+        s.append('operands: ')
+        if self.operands is None:
             s.append('!MISSING\n')
         else:
             s.append('<\n')
-            s.append(self.rhs.dump(indent + 1, annotations, links) + '\n')
+            s.append(self.operands.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(')')
@@ -8251,10 +8508,12 @@ class ModuloExpression(ArithmeticExpression):
         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_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)
+        if self._attr_name is not None:
+            self._attr_name.find_reachable(id_map)
+        if self._attr_operands is not None:
+            self._attr_operands.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):
@@ -8264,20 +8523,23 @@ class ModuloExpression(ArithmeticExpression):
         id() codes to tree indices for all reachable nodes."""
         if id_map is None:
             id_map = self.find_reachable()
-        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)
+        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_operands is None:
+            raise NotWellFormed('operands is required but not set')
+        if self._attr_operands is not None:
+            self._attr_operands.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 ModuloExpression(
-            lhs=self._attr_lhs,
-            rhs=self._attr_rhs
+        return NonGateInstruction(
+            name=self._attr_name,
+            operands=self._attr_operands,
+            annotations=self._attr_annotations.copy()
         )
 
     def clone(self):
@@ -8286,9 +8548,10 @@ class ModuloExpression(ArithmeticExpression):
         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 ModuloExpression(
-            lhs=_cloned(self._attr_lhs),
-            rhs=_cloned(self._attr_rhs)
+        return NonGateInstruction(
+            name=_cloned(self._attr_name),
+            operands=_cloned(self._attr_operands),
+            annotations=_cloned(self._attr_annotations)
         )
 
     @staticmethod
@@ -8304,33 +8567,48 @@ class ModuloExpression(ArithmeticExpression):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'ModuloExpression':
-            raise ValueError('found node serialization for ' + typ + ', but expected ModuloExpression')
+        if typ != 'NonGateInstruction':
+            raise ValueError('found node serialization for ' + typ + ', but expected NonGateInstruction')
 
-        # Deserialize the lhs field.
-        field = cbor.get('lhs', None)
+        # Deserialize the name field.
+        field = cbor.get('name', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field lhs')
+            raise ValueError('missing or invalid serialization of field name')
         if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field lhs')
+            raise ValueError('unexpected edge type for field name')
         if field.get('@t', None) is None:
-            f_lhs = None
+            f_name = None
         else:
-            f_lhs = Expression._deserialize(field, seq_to_ob, links)
+            f_name = Keyword._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the rhs field.
-        field = cbor.get('rhs', None)
+        # Deserialize the operands field.
+        field = cbor.get('operands', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field rhs')
+            raise ValueError('missing or invalid serialization of field operands')
         if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field rhs')
+            raise ValueError('unexpected edge type for field operands')
         if field.get('@t', None) is None:
-            f_rhs = None
+            f_operands = None
         else:
-            f_rhs = Expression._deserialize(field, seq_to_ob, links)
+            f_operands = ExpressionList._deserialize(field, seq_to_ob, links)
 
-        # Construct the ModuloExpression node.
-        node = ModuloExpression(f_lhs, f_rhs)
+        # 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 NonGateInstruction node.
+        node = NonGateInstruction(f_name, f_operands, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -8354,23 +8632,33 @@ class ModuloExpression(ArithmeticExpression):
         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': 'ModuloExpression'}
+        cbor = {'@i': id_map[id(self)], '@t': 'NonGateInstruction'}
 
-        # Serialize the lhs field.
+        # Serialize the name field.
         field = {'@T': '1'}
-        if self._attr_lhs is None:
+        if self._attr_name is None:
             field['@t'] = None
         else:
-            field.update(self._attr_lhs._serialize(id_map))
-        cbor['lhs'] = field
+            field.update(self._attr_name._serialize(id_map))
+        cbor['name'] = field
 
-        # Serialize the rhs field.
+        # Serialize the operands field.
         field = {'@T': '1'}
-        if self._attr_rhs is None:
+        if self._attr_operands is None:
             field['@t'] = None
         else:
-            field.update(self._attr_rhs._serialize(id_map))
-        cbor['rhs'] = field
+            field.update(self._attr_operands._serialize(id_map))
+        cbor['operands'] = 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():
@@ -8379,13 +8667,13 @@ class ModuloExpression(ArithmeticExpression):
         return cbor
 
 
-class MultiModuloExpression(_Multiple):
-    """Wrapper for an edge with multiple ModuloExpression objects."""
+class MultiNonGateInstruction(_Multiple):
+    """Wrapper for an edge with multiple NonGateInstruction objects."""
 
-    _T = ModuloExpression
+    _T = NonGateInstruction
 
 
-_typemap['ModuloExpression'] = ModuloExpression
+_typemap['NonGateInstruction'] = NonGateInstruction
 
 class PowerExpression(ArithmeticExpression):
     __slots__ = []