libqasm 1.0.0__cp310-cp310-win_amd64.whl → 1.2.0__cp310-cp310-win_amd64.whl

cqasm/v3x/semantic.py

@@ -646,6 +646,8 @@ class Annotated(Node):
             return GateInstruction._deserialize(cbor, seq_to_ob, links)
         if typ == 'NonGateInstruction':
             return NonGateInstruction._deserialize(cbor, seq_to_ob, links)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -972,6 +974,392 @@ class MultiAnnotationData(_Multiple):
 
 _typemap['AnnotationData'] = AnnotationData
 
+class Statement(Annotated):
+    __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)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._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)
+        if typ == 'AsmDeclaration':
+            return AsmDeclaration._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 AsmDeclaration(Instruction):
+    __slots__ = [
+        '_attr_backend_name',
+        '_attr_backend_code',
+    ]
+
+    def __init__(
+        self,
+        backend_name=None,
+        backend_code=None,
+        annotations=None,
+    ):
+        super().__init__(annotations=annotations)
+        self.backend_name = backend_name
+        self.backend_code = backend_code
+
+    @property
+    def backend_name(self):
+        return self._attr_backend_name
+
+    @backend_name.setter
+    def backend_name(self, val):
+        if val is None:
+            del self.backend_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('backend_name must be of type cqasm.v3x.primitives.Str')
+            val = cqasm.v3x.primitives.Str(val)
+        self._attr_backend_name = val
+
+    @backend_name.deleter
+    def backend_name(self):
+        self._attr_backend_name = cqasm.v3x.primitives.Str()
+
+    @property
+    def backend_code(self):
+        return self._attr_backend_code
+
+    @backend_code.setter
+    def backend_code(self, val):
+        if val is None:
+            del self.backend_code
+            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('backend_code must be of type cqasm.v3x.primitives.Str')
+            val = cqasm.v3x.primitives.Str(val)
+        self._attr_backend_code = val
+
+    @backend_code.deleter
+    def backend_code(self):
+        self._attr_backend_code = cqasm.v3x.primitives.Str()
+
+    def __eq__(self, other):
+        """Equality operator. Ignores annotations!"""
+        if not isinstance(other, AsmDeclaration):
+            return False
+        if self.backend_name != other.backend_name:
+            return False
+        if self.backend_code != other.backend_code:
+            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('AsmDeclaration(')
+        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('backend_name: ')
+        s.append(str(self.backend_name) + '\n')
+        s.append('  '*indent)
+        s.append('backend_code: ')
+        s.append(str(self.backend_code) + '\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)
+        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()
+        for child in self._attr_annotations:
+            child.check_complete(id_map)
+
+    def copy(self):
+        """Returns a shallow copy of this node."""
+        return AsmDeclaration(
+            backend_name=self._attr_backend_name,
+            backend_code=self._attr_backend_code,
+            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 AsmDeclaration(
+            backend_name=_cloned(self._attr_backend_name),
+            backend_code=_cloned(self._attr_backend_code),
+            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 != 'AsmDeclaration':
+            raise ValueError('found node serialization for ' + typ + ', but expected AsmDeclaration')
+
+        # Deserialize the backend_name field.
+        field = cbor.get('backend_name', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field backend_name')
+        if hasattr(cqasm.v3x.primitives.Str, 'deserialize_cbor'):
+            f_backend_name = cqasm.v3x.primitives.Str.deserialize_cbor(field)
+        else:
+            f_backend_name = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Str, field)
+
+        # Deserialize the backend_code field.
+        field = cbor.get('backend_code', None)
+        if not isinstance(field, dict):
+            raise ValueError('missing or invalid serialization of field backend_code')
+        if hasattr(cqasm.v3x.primitives.Str, 'deserialize_cbor'):
+            f_backend_code = cqasm.v3x.primitives.Str.deserialize_cbor(field)
+        else:
+            f_backend_code = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Str, field)
+
+        # 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 AsmDeclaration node.
+        node = AsmDeclaration(f_backend_name, f_backend_code, 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': 'AsmDeclaration'}
+
+        # Serialize the backend_name field.
+        if hasattr(self._attr_backend_name, 'serialize_cbor'):
+            cbor['backend_name'] = self._attr_backend_name.serialize_cbor()
+        else:
+            cbor['backend_name'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Str, self._attr_backend_name)
+
+        # Serialize the backend_code field.
+        if hasattr(self._attr_backend_code, 'serialize_cbor'):
+            cbor['backend_code'] = self._attr_backend_code.serialize_cbor()
+        else:
+            cbor['backend_code'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Str, self._attr_backend_code)
+
+        # 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 MultiAsmDeclaration(_Multiple):
+    """Wrapper for an edge with multiple AsmDeclaration objects."""
+
+    _T = AsmDeclaration
+
+
+_typemap['AsmDeclaration'] = AsmDeclaration
+
 class Block(Node):
     __slots__ = [
         '_attr_statements',
@@ -1173,20 +1561,20 @@ class Gate(Annotated):
     __slots__ = [
         '_attr_name',
         '_attr_gate',
-        '_attr_parameter',
+        '_attr_parameters',
     ]
 
     def __init__(
         self,
         name=None,
         gate=None,
-        parameter=None,
+        parameters=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.name = name
         self.gate = gate
-        self.parameter = parameter
+        self.parameters = parameters
 
     @property
     def name(self):
@@ -1229,24 +1617,24 @@ class Gate(Annotated):
         self._attr_gate = None
 
     @property
-    def parameter(self):
-        return self._attr_parameter
+    def parameters(self):
+        return self._attr_parameters
 
-    @parameter.setter
-    def parameter(self, val):
+    @parameters.setter
+    def parameters(self, val):
         if val is None:
-            del self.parameter
+            del self.parameters
             return
-        if not isinstance(val, cqasm.v3x.values.ValueBase):
+        if not isinstance(val, cqasm.v3x.values.MultiValueBase):
             # 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
+                raise TypeError('parameters must be of type cqasm.v3x.values.MultiValueBase')
+            val = cqasm.v3x.values.MultiValueBase(val)
+        self._attr_parameters = val
 
-    @parameter.deleter
-    def parameter(self):
-        self._attr_parameter = None
+    @parameters.deleter
+    def parameters(self):
+        self._attr_parameters = cqasm.v3x.values.MultiValueBase()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -1256,7 +1644,7 @@ class Gate(Annotated):
             return False
         if self.gate != other.gate:
             return False
-        if self.parameter != other.parameter:
+        if self.parameters != other.parameters:
             return False
         if self.annotations != other.annotations:
             return False
@@ -1289,13 +1677,14 @@ class Gate(Annotated):
             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('parameters: ')
+        if not self.parameters:
             s.append('-\n')
         else:
-            s.append('<\n')
-            s.append(self.parameter.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + '>\n')
+            s.append('[\n')
+            for child in self.parameters:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
         s.append('  '*indent)
         s.append('annotations: ')
         if not self.annotations:
@@ -1324,8 +1713,8 @@ class Gate(Annotated):
         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_parameters:
+            el.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -1339,8 +1728,8 @@ class Gate(Annotated):
             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_parameters:
+            child.check_complete(id_map)
         for child in self._attr_annotations:
             child.check_complete(id_map)
 
@@ -1349,7 +1738,7 @@ class Gate(Annotated):
         return Gate(
             name=self._attr_name,
             gate=self._attr_gate,
-            parameter=self._attr_parameter,
+            parameters=self._attr_parameters.copy(),
             annotations=self._attr_annotations.copy()
         )
 
@@ -1362,7 +1751,7 @@ class Gate(Annotated):
         return Gate(
             name=_cloned(self._attr_name),
             gate=_cloned(self._attr_gate),
-            parameter=_cloned(self._attr_parameter),
+            parameters=_cloned(self._attr_parameters),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -1402,16 +1791,20 @@ class Gate(Annotated):
         else:
             f_gate = Gate._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the parameter field.
-        field = cbor.get('parameter', None)
+        # Deserialize the parameters field.
+        field = cbor.get('parameters', 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)
+            raise ValueError('missing or invalid serialization of field parameters')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field parameters')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_parameters = cqasm.v3x.values.MultiValueBase()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_parameters.append(cqasm.v3x.values.ValueBase._deserialize(element, seq_to_ob, links))
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -1429,7 +1822,7 @@ class Gate(Annotated):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the Gate node.
-        node = Gate(f_name, f_gate, f_parameter, f_annotations)
+        node = Gate(f_name, f_gate, f_parameters, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1469,73 +1862,15 @@ class Gate(Annotated):
             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.
+        # Serialize the parameters field.
         field = {'@T': '*'}
         lst = []
-        for el in self._attr_annotations:
+        for el in self._attr_parameters:
             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__ = []
-
-    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': 'Statement'}
+        cbor['parameters'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}
@@ -1554,73 +1889,13 @@ class Statement(Annotated):
         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."""
+class MultiGate(_Multiple):
+    """Wrapper for an edge with multiple Gate objects."""
 
-    _T = Instruction
+    _T = Gate
 
 
-_typemap['Instruction'] = Instruction
+_typemap['Gate'] = Gate
 
 class GateInstruction(Instruction):
     """A gate, or a composition of gate modifiers and a gate"""
@@ -1967,13 +2242,13 @@ class MultiGateInstruction(_Multiple):
 _typemap['GateInstruction'] = GateInstruction
 
 class NonGateInstruction(Instruction):
-    """A measure instruction or a reset instruction"""
+    """A non-gate instruction: init, measure, reset, barrier, wait..."""
 
     __slots__ = [
         '_attr_instruction_ref',
         '_attr_name',
         '_attr_operands',
-        '_attr_parameter',
+        '_attr_parameters',
     ]
 
     def __init__(
@@ -1981,14 +2256,14 @@ class NonGateInstruction(Instruction):
         instruction_ref=None,
         name=None,
         operands=None,
-        parameter=None,
+        parameters=None,
         annotations=None,
     ):
         super().__init__(annotations=annotations)
         self.instruction_ref = instruction_ref
         self.name = name
         self.operands = operands
-        self.parameter = parameter
+        self.parameters = parameters
 
     @property
     def instruction_ref(self):
@@ -2051,24 +2326,24 @@ class NonGateInstruction(Instruction):
         self._attr_operands = cqasm.v3x.values.MultiValueBase()
 
     @property
-    def parameter(self):
-        return self._attr_parameter
+    def parameters(self):
+        return self._attr_parameters
 
-    @parameter.setter
-    def parameter(self, val):
+    @parameters.setter
+    def parameters(self, val):
         if val is None:
-            del self.parameter
+            del self.parameters
             return
-        if not isinstance(val, cqasm.v3x.values.ValueBase):
+        if not isinstance(val, cqasm.v3x.values.MultiValueBase):
             # 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
+                raise TypeError('parameters must be of type cqasm.v3x.values.MultiValueBase')
+            val = cqasm.v3x.values.MultiValueBase(val)
+        self._attr_parameters = val
 
-    @parameter.deleter
-    def parameter(self):
-        self._attr_parameter = None
+    @parameters.deleter
+    def parameters(self):
+        self._attr_parameters = cqasm.v3x.values.MultiValueBase()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -2080,7 +2355,7 @@ class NonGateInstruction(Instruction):
             return False
         if self.operands != other.operands:
             return False
-        if self.parameter != other.parameter:
+        if self.parameters != other.parameters:
             return False
         if self.annotations != other.annotations:
             return False
@@ -2117,13 +2392,14 @@ class NonGateInstruction(Instruction):
                 s.append(child.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + ']\n')
         s.append('  '*indent)
-        s.append('parameter: ')
-        if self.parameter is None:
+        s.append('parameters: ')
+        if not self.parameters:
             s.append('-\n')
         else:
-            s.append('<\n')
-            s.append(self.parameter.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + '>\n')
+            s.append('[\n')
+            for child in self.parameters:
+                s.append(child.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + ']\n')
         s.append('  '*indent)
         s.append('annotations: ')
         if not self.annotations:
@@ -2152,8 +2428,8 @@ class NonGateInstruction(Instruction):
         id_map[id(self)] = len(id_map)
         for el in self._attr_operands:
             el.find_reachable(id_map)
-        if self._attr_parameter is not None:
-            self._attr_parameter.find_reachable(id_map)
+        for el in self._attr_parameters:
+            el.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -2167,8 +2443,8 @@ class NonGateInstruction(Instruction):
             id_map = self.find_reachable()
         for child in self._attr_operands:
             child.check_complete(id_map)
-        if self._attr_parameter is not None:
-            self._attr_parameter.check_complete(id_map)
+        for child in self._attr_parameters:
+            child.check_complete(id_map)
         for child in self._attr_annotations:
             child.check_complete(id_map)
 
@@ -2178,7 +2454,7 @@ class NonGateInstruction(Instruction):
             instruction_ref=self._attr_instruction_ref,
             name=self._attr_name,
             operands=self._attr_operands.copy(),
-            parameter=self._attr_parameter,
+            parameters=self._attr_parameters.copy(),
             annotations=self._attr_annotations.copy()
         )
 
@@ -2192,7 +2468,7 @@ class NonGateInstruction(Instruction):
             instruction_ref=_cloned(self._attr_instruction_ref),
             name=_cloned(self._attr_name),
             operands=_cloned(self._attr_operands),
-            parameter=_cloned(self._attr_parameter),
+            parameters=_cloned(self._attr_parameters),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -2245,16 +2521,20 @@ class NonGateInstruction(Instruction):
                 raise ValueError('unexpected edge type for Any/Many element')
             f_operands.append(cqasm.v3x.values.ValueBase._deserialize(element, seq_to_ob, links))
 
-        # Deserialize the parameter field.
-        field = cbor.get('parameter', None)
+        # Deserialize the parameters field.
+        field = cbor.get('parameters', 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)
+            raise ValueError('missing or invalid serialization of field parameters')
+        if field.get('@T') != '*':
+            raise ValueError('unexpected edge type for field parameters')
+        data = field.get('@d', None)
+        if not isinstance(data, list):
+            raise ValueError('missing serialization of Any/Many contents')
+        f_parameters = cqasm.v3x.values.MultiValueBase()
+        for element in data:
+            if element.get('@T') != '1':
+                raise ValueError('unexpected edge type for Any/Many element')
+            f_parameters.append(cqasm.v3x.values.ValueBase._deserialize(element, seq_to_ob, links))
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -2272,7 +2552,7 @@ class NonGateInstruction(Instruction):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the NonGateInstruction node.
-        node = NonGateInstruction(f_instruction_ref, f_name, f_operands, f_parameter, f_annotations)
+        node = NonGateInstruction(f_instruction_ref, f_name, f_operands, f_parameters, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -2320,13 +2600,15 @@ class NonGateInstruction(Instruction):
         field['@d'] = lst
         cbor['operands'] = 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 parameters field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_parameters:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['parameters'] = field
 
         # Serialize the annotations field.
         field = {'@T': '*'}