libqasm 0.5.2__cp38-cp38-win_amd64.whl → 0.6.1__cp38-cp38-win_amd64.whl

cqasm/v3x/semantic.py

@@ -638,12 +638,10 @@ class Annotated(Node):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'Instruction':
-            return Instruction._deserialize(cbor, seq_to_ob, links)
-        if typ == 'AssignmentInstruction':
-            return AssignmentInstruction._deserialize(cbor, seq_to_ob, links)
         if typ == 'Variable':
             return Variable._deserialize(cbor, seq_to_ob, links)
+        if typ == 'Instruction':
+            return Instruction._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
 
     def _serialize(self, id_map):
@@ -970,230 +968,43 @@ 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 == 'Instruction':
-            return Instruction._deserialize(cbor, seq_to_ob, links)
-        if typ == 'AssignmentInstruction':
-            return AssignmentInstruction._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 InstructionBase(Statement):
-    __slots__ = [
-        '_attr_condition',
-    ]
-
-    def __init__(
-        self,
-        condition=None,
-        annotations=None,
-    ):
-        super().__init__(annotations=annotations)
-        self.condition = condition
-
-    @property
-    def condition(self):
-        """Condition (C- notation). When there is no condition, this is a
-        constant boolean set to true."""
-        return self._attr_condition
-
-    @condition.setter
-    def condition(self, val):
-        if val is None:
-            del self.condition
-            return
-        if not isinstance(val, cqasm.v3x.values.Node):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('condition must be of type cqasm.v3x.values.Node')
-            val = cqasm.v3x.values.Node(val)
-        self._attr_condition = val
-
-    @condition.deleter
-    def condition(self):
-        self._attr_condition = None
-
-    @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 == 'Instruction':
-            return Instruction._deserialize(cbor, seq_to_ob, links)
-        if typ == 'AssignmentInstruction':
-            return AssignmentInstruction._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': 'InstructionBase'}
-
-        # Serialize the condition field.
-        field = {'@T': '1'}
-        if self._attr_condition is None:
-            field['@t'] = None
-        else:
-            field.update(self._attr_condition._serialize(id_map))
-        cbor['condition'] = 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 MultiInstructionBase(_Multiple):
-    """Wrapper for an edge with multiple InstructionBase objects."""
-
-    _T = InstructionBase
-
-
-_typemap['InstructionBase'] = InstructionBase
-
-class AssignmentInstruction(InstructionBase):
+class Block(Node):
     __slots__ = [
-        '_attr_lhs',
-        '_attr_rhs',
+        '_attr_statements',
     ]
 
     def __init__(
         self,
-        lhs=None,
-        rhs=None,
-        condition=None,
-        annotations=None,
+        statements=None,
     ):
-        super().__init__(condition=condition, annotations=annotations)
-        self.lhs = lhs
-        self.rhs = rhs
-
-    @property
-    def lhs(self):
-        """The assignment target."""
-        return self._attr_lhs
-
-    @lhs.setter
-    def lhs(self, val):
-        if val is None:
-            del self.lhs
-            return
-        if not isinstance(val, cqasm.v3x.values.Node):
-            # Try to "typecast" if this isn't an obvious mistake.
-            if isinstance(val, Node):
-                raise TypeError('lhs must be of type cqasm.v3x.values.Node')
-            val = cqasm.v3x.values.Node(val)
-        self._attr_lhs = val
-
-    @lhs.deleter
-    def lhs(self):
-        self._attr_lhs = None
+        super().__init__()
+        self.statements = statements
 
     @property
-    def rhs(self):
-        """The value to assign."""
-        return self._attr_rhs
+    def statements(self):
+        return self._attr_statements
 
-    @rhs.setter
-    def rhs(self, val):
+    @statements.setter
+    def statements(self, val):
         if val is None:
-            del self.rhs
+            del self.statements
             return
-        if not isinstance(val, cqasm.v3x.values.Node):
+        if not isinstance(val, MultiStatement):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('rhs must be of type cqasm.v3x.values.Node')
-            val = cqasm.v3x.values.Node(val)
-        self._attr_rhs = val
+                raise TypeError('statements must be of type MultiStatement')
+            val = MultiStatement(val)
+        self._attr_statements = val
 
-    @rhs.deleter
-    def rhs(self):
-        self._attr_rhs = None
+    @statements.deleter
+    def statements(self):
+        self._attr_statements = MultiStatement()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, AssignmentInstruction):
-            return False
-        if self.lhs != other.lhs:
+        if not isinstance(other, Block):
             return False
-        if self.rhs != other.rhs:
-            return False
-        if self.condition != other.condition:
-            return False
-        if self.annotations != other.annotations:
+        if self.statements != other.statements:
             return False
         return True
 
@@ -1204,7 +1015,7 @@ class AssignmentInstruction(InstructionBase):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('AssignmentInstruction(')
+        s.append('Block(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1213,36 +1024,12 @@ class AssignmentInstruction(InstructionBase):
         s.append('\n')
         indent += 1
         s.append('  '*indent)
-        s.append('lhs: ')
-        if self.lhs is None:
-            s.append('!MISSING\n')
-        else:
-            s.append('<\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('condition: ')
-        if self.condition is None:
-            s.append('!MISSING\n')
-        else:
-            s.append('<\n')
-            s.append(self.condition.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + '>\n')
-        s.append('  '*indent)
-        s.append('annotations: ')
-        if not self.annotations:
+        s.append('statements: ')
+        if not self.statements:
             s.append('-\n')
         else:
             s.append('[\n')
-            for child in self.annotations:
+            for child in self.statements:
                 s.append(child.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + ']\n')
         indent -= 1
@@ -1262,13 +1049,7 @@ class AssignmentInstruction(InstructionBase):
         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_condition is not None:
-            self._attr_condition.find_reachable(id_map)
-        for el in self._attr_annotations:
+        for el in self._attr_statements:
             el.find_reachable(id_map)
         return id_map
 
@@ -1279,28 +1060,13 @@ class AssignmentInstruction(InstructionBase):
         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_condition is None:
-            raise NotWellFormed('condition is required but not set')
-        if self._attr_condition is not None:
-            self._attr_condition.check_complete(id_map)
-        for child in self._attr_annotations:
+        for child in self._attr_statements:
             child.check_complete(id_map)
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return AssignmentInstruction(
-            lhs=self._attr_lhs,
-            rhs=self._attr_rhs,
-            condition=self._attr_condition,
-            annotations=self._attr_annotations.copy()
+        return Block(
+            statements=self._attr_statements.copy()
         )
 
     def clone(self):
@@ -1309,11 +1075,8 @@ class AssignmentInstruction(InstructionBase):
         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 AssignmentInstruction(
-            lhs=_cloned(self._attr_lhs),
-            rhs=_cloned(self._attr_rhs),
-            condition=_cloned(self._attr_condition),
-            annotations=_cloned(self._attr_annotations)
+        return Block(
+            statements=_cloned(self._attr_statements)
         )
 
     @staticmethod
@@ -1329,59 +1092,26 @@ class AssignmentInstruction(InstructionBase):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'AssignmentInstruction':
-            raise ValueError('found node serialization for ' + typ + ', but expected AssignmentInstruction')
+        if typ != 'Block':
+            raise ValueError('found node serialization for ' + typ + ', but expected Block')
 
-        # Deserialize the lhs field.
-        field = cbor.get('lhs', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field lhs')
-        if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field lhs')
-        if field.get('@t', None) is None:
-            f_lhs = None
-        else:
-            f_lhs = cqasm.v3x.values.Node._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 = cqasm.v3x.values.Node._deserialize(field, seq_to_ob, links)
-
-        # Deserialize the condition field.
-        field = cbor.get('condition', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field condition')
-        if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field condition')
-        if field.get('@t', None) is None:
-            f_condition = None
-        else:
-            f_condition = cqasm.v3x.values.Node._deserialize(field, seq_to_ob, links)
-
-        # Deserialize the annotations field.
-        field = cbor.get('annotations', None)
+        # Deserialize the statements field.
+        field = cbor.get('statements', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field annotations')
+            raise ValueError('missing or invalid serialization of field statements')
         if field.get('@T') != '*':
-            raise ValueError('unexpected edge type for field annotations')
+            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_annotations = MultiAnnotationData()
+        f_statements = MultiStatement()
         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))
+            f_statements.append(Statement._deserialize(element, seq_to_ob, links))
 
-        # Construct the AssignmentInstruction node.
-        node = AssignmentInstruction(f_lhs, f_rhs, f_condition, f_annotations)
+        # Construct the Block node.
+        node = Block(f_statements)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1405,31 +1135,65 @@ class AssignmentInstruction(InstructionBase):
         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': 'AssignmentInstruction'}
+        cbor = {'@i': id_map[id(self)], '@t': 'Block'}
 
-        # Serialize the lhs field.
-        field = {'@T': '1'}
-        if self._attr_lhs is None:
-            field['@t'] = None
-        else:
-            field.update(self._attr_lhs._serialize(id_map))
-        cbor['lhs'] = field
+        # Serialize the statements field.
+        field = {'@T': '*'}
+        lst = []
+        for el in self._attr_statements:
+            el = el._serialize(id_map)
+            el['@T'] = '1'
+            lst.append(el)
+        field['@d'] = lst
+        cbor['statements'] = 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 annotations.
+        for key, val in self._annot.items():
+            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
 
-        # Serialize the condition field.
-        field = {'@T': '1'}
-        if self._attr_condition is None:
-            field['@t'] = None
-        else:
-            field.update(self._attr_condition._serialize(id_map))
-        cbor['condition'] = field
+        return cbor
+
+
+class MultiBlock(_Multiple):
+    """Wrapper for an edge with multiple Block objects."""
+
+    _T = Block
+
+
+_typemap['Block'] = Block
+
+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 == 'Instruction':
+            return Instruction._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': '*'}
@@ -1448,60 +1212,57 @@ class AssignmentInstruction(InstructionBase):
         return cbor
 
 
-class MultiAssignmentInstruction(_Multiple):
-    """Wrapper for an edge with multiple AssignmentInstruction objects."""
+class MultiStatement(_Multiple):
+    """Wrapper for an edge with multiple Statement objects."""
 
-    _T = AssignmentInstruction
+    _T = Statement
 
 
-_typemap['AssignmentInstruction'] = AssignmentInstruction
+_typemap['Statement'] = Statement
 
-class Instruction(InstructionBase):
-    """A regular instruction (gate)."""
+class Instruction(Statement):
+    """Regular instruction (a gate, or a measure instruction)."""
 
     __slots__ = [
-        '_attr_instruction',
+        '_attr_instruction_ref',
         '_attr_name',
         '_attr_operands',
     ]
 
     def __init__(
         self,
-        instruction=None,
+        instruction_ref=None,
         name=None,
         operands=None,
-        condition=None,
         annotations=None,
     ):
-        super().__init__(condition=condition, annotations=annotations)
-        self.instruction = instruction
+        super().__init__(annotations=annotations)
+        self.instruction_ref = instruction_ref
         self.name = name
         self.operands = operands
 
     @property
-    def instruction(self):
-        """Instruction type as registered through the API."""
-        return self._attr_instruction
+    def instruction_ref(self):
+        return self._attr_instruction_ref
 
-    @instruction.setter
-    def instruction(self, val):
+    @instruction_ref.setter
+    def instruction_ref(self, val):
         if val is None:
-            del self.instruction
+            del self.instruction_ref
             return
         if not isinstance(val, cqasm.v3x.instruction.InstructionRef):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('instruction must be of type cqasm.v3x.instruction.InstructionRef')
+                raise TypeError('instruction_ref must be of type cqasm.v3x.instruction.InstructionRef')
             val = cqasm.v3x.instruction.InstructionRef(val)
-        self._attr_instruction = val
+        self._attr_instruction_ref = val
 
-    @instruction.deleter
-    def instruction(self):
-        self._attr_instruction = cqasm.v3x.instruction.InstructionRef()
+    @instruction_ref.deleter
+    def instruction_ref(self):
+        self._attr_instruction_ref = cqasm.v3x.instruction.InstructionRef()
 
     @property
     def name(self):
-        """Name as it appears in the cQASM file."""
         return self._attr_name
 
     @name.setter
@@ -1522,7 +1283,6 @@ class Instruction(InstructionBase):
 
     @property
     def operands(self):
-        """Operands for the instruction."""
         return self._attr_operands
 
     @operands.setter
@@ -1530,29 +1290,27 @@ class Instruction(InstructionBase):
         if val is None:
             del self.operands
             return
-        if not isinstance(val, cqasm.v3x.values.MultiNode):
+        if not isinstance(val, cqasm.v3x.values.MultiValueBase):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('operands must be of type cqasm.v3x.values.MultiNode')
-            val = cqasm.v3x.values.MultiNode(val)
+                raise TypeError('operands must be of type cqasm.v3x.values.MultiValueBase')
+            val = cqasm.v3x.values.MultiValueBase(val)
         self._attr_operands = val
 
     @operands.deleter
     def operands(self):
-        self._attr_operands = cqasm.v3x.values.MultiNode()
+        self._attr_operands = cqasm.v3x.values.MultiValueBase()
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
         if not isinstance(other, Instruction):
             return False
-        if self.instruction != other.instruction:
+        if self.instruction_ref != other.instruction_ref:
             return False
         if self.name != other.name:
             return False
         if self.operands != other.operands:
             return False
-        if self.condition != other.condition:
-            return False
         if self.annotations != other.annotations:
             return False
         return True
@@ -1573,8 +1331,8 @@ class Instruction(InstructionBase):
         s.append('\n')
         indent += 1
         s.append('  '*indent)
-        s.append('instruction: ')
-        s.append(str(self.instruction) + '\n')
+        s.append('instruction_ref: ')
+        s.append(str(self.instruction_ref) + '\n')
         s.append('  '*indent)
         s.append('name: ')
         s.append(str(self.name) + '\n')
@@ -1588,14 +1346,6 @@ class Instruction(InstructionBase):
                 s.append(child.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + ']\n')
         s.append('  '*indent)
-        s.append('condition: ')
-        if self.condition is None:
-            s.append('!MISSING\n')
-        else:
-            s.append('<\n')
-            s.append(self.condition.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + '>\n')
-        s.append('  '*indent)
         s.append('annotations: ')
         if not self.annotations:
             s.append('-\n')
@@ -1623,8 +1373,6 @@ class Instruction(InstructionBase):
         id_map[id(self)] = len(id_map)
         for el in self._attr_operands:
             el.find_reachable(id_map)
-        if self._attr_condition is not None:
-            self._attr_condition.find_reachable(id_map)
         for el in self._attr_annotations:
             el.find_reachable(id_map)
         return id_map
@@ -1638,20 +1386,15 @@ class Instruction(InstructionBase):
             id_map = self.find_reachable()
         for child in self._attr_operands:
             child.check_complete(id_map)
-        if self._attr_condition is None:
-            raise NotWellFormed('condition is required but not set')
-        if self._attr_condition is not None:
-            self._attr_condition.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 Instruction(
-            instruction=self._attr_instruction,
+            instruction_ref=self._attr_instruction_ref,
             name=self._attr_name,
             operands=self._attr_operands.copy(),
-            condition=self._attr_condition,
             annotations=self._attr_annotations.copy()
         )
 
@@ -1662,10 +1405,9 @@ class Instruction(InstructionBase):
         is the desired behavior, you may want to use the copy.deepcopy() from
         the stdlib instead, which should copy links correctly."""
         return Instruction(
-            instruction=_cloned(self._attr_instruction),
+            instruction_ref=_cloned(self._attr_instruction_ref),
             name=_cloned(self._attr_name),
             operands=_cloned(self._attr_operands),
-            condition=_cloned(self._attr_condition),
             annotations=_cloned(self._attr_annotations)
         )
 
@@ -1685,14 +1427,14 @@ class Instruction(InstructionBase):
         if typ != 'Instruction':
             raise ValueError('found node serialization for ' + typ + ', but expected Instruction')
 
-        # Deserialize the instruction field.
-        field = cbor.get('instruction', None)
+        # Deserialize the instruction_ref field.
+        field = cbor.get('instruction_ref', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field instruction')
+            raise ValueError('missing or invalid serialization of field instruction_ref')
         if hasattr(cqasm.v3x.instruction.InstructionRef, 'deserialize_cbor'):
-            f_instruction = cqasm.v3x.instruction.InstructionRef.deserialize_cbor(field)
+            f_instruction_ref = cqasm.v3x.instruction.InstructionRef.deserialize_cbor(field)
         else:
-            f_instruction = cqasm.v3x.primitives.deserialize(cqasm.v3x.instruction.InstructionRef, field)
+            f_instruction_ref = cqasm.v3x.primitives.deserialize(cqasm.v3x.instruction.InstructionRef, field)
 
         # Deserialize the name field.
         field = cbor.get('name', None)
@@ -1712,22 +1454,11 @@ class Instruction(InstructionBase):
         data = field.get('@d', None)
         if not isinstance(data, list):
             raise ValueError('missing serialization of Any/Many contents')
-        f_operands = cqasm.v3x.values.MultiNode()
+        f_operands = cqasm.v3x.values.MultiValueBase()
         for element in data:
             if element.get('@T') != '1':
                 raise ValueError('unexpected edge type for Any/Many element')
-            f_operands.append(cqasm.v3x.values.Node._deserialize(element, seq_to_ob, links))
-
-        # Deserialize the condition field.
-        field = cbor.get('condition', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field condition')
-        if field.get('@T') != '1':
-            raise ValueError('unexpected edge type for field condition')
-        if field.get('@t', None) is None:
-            f_condition = None
-        else:
-            f_condition = cqasm.v3x.values.Node._deserialize(field, seq_to_ob, links)
+            f_operands.append(cqasm.v3x.values.ValueBase._deserialize(element, seq_to_ob, links))
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)
@@ -1745,7 +1476,7 @@ class Instruction(InstructionBase):
             f_annotations.append(AnnotationData._deserialize(element, seq_to_ob, links))
 
         # Construct the Instruction node.
-        node = Instruction(f_instruction, f_name, f_operands, f_condition, f_annotations)
+        node = Instruction(f_instruction_ref, f_name, f_operands, f_annotations)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1771,11 +1502,11 @@ class Instruction(InstructionBase):
         integers, to use for the sequence number representation of links."""
         cbor = {'@i': id_map[id(self)], '@t': 'Instruction'}
 
-        # Serialize the instruction field.
-        if hasattr(self._attr_instruction, 'serialize_cbor'):
-            cbor['instruction'] = self._attr_instruction.serialize_cbor()
+        # Serialize the instruction_ref field.
+        if hasattr(self._attr_instruction_ref, 'serialize_cbor'):
+            cbor['instruction_ref'] = self._attr_instruction_ref.serialize_cbor()
         else:
-            cbor['instruction'] = cqasm.v3x.primitives.serialize(cqasm.v3x.instruction.InstructionRef, self._attr_instruction)
+            cbor['instruction_ref'] = cqasm.v3x.primitives.serialize(cqasm.v3x.instruction.InstructionRef, self._attr_instruction_ref)
 
         # Serialize the name field.
         if hasattr(self._attr_name, 'serialize_cbor'):
@@ -1793,14 +1524,6 @@ class Instruction(InstructionBase):
         field['@d'] = lst
         cbor['operands'] = field
 
-        # Serialize the condition field.
-        field = {'@T': '1'}
-        if self._attr_condition is None:
-            field['@t'] = None
-        else:
-            field.update(self._attr_condition._serialize(id_map))
-        cbor['condition'] = field
-
         # Serialize the annotations field.
         field = {'@T': '*'}
         lst = []
@@ -1830,22 +1553,22 @@ class Program(Node):
     __slots__ = [
         '_attr_api_version',
         '_attr_version',
-        '_attr_statements',
-        '_attr_variables',
+        '_attr_qubit_variable_declaration',
+        '_attr_block',
     ]
 
     def __init__(
         self,
         api_version=None,
         version=None,
-        statements=None,
-        variables=None,
+        qubit_variable_declaration=None,
+        block=None,
     ):
         super().__init__()
         self.api_version = api_version
         self.version = version
-        self.statements = statements
-        self.variables = variables
+        self.qubit_variable_declaration = qubit_variable_declaration
+        self.block = block
 
     @property
     def api_version(self):
@@ -1892,46 +1615,46 @@ class Program(Node):
         self._attr_version = None
 
     @property
-    def statements(self):
-        """The list of statements."""
-        return self._attr_statements
+    def qubit_variable_declaration(self):
+        """Qubit variable."""
+        return self._attr_qubit_variable_declaration
 
-    @statements.setter
-    def statements(self, val):
+    @qubit_variable_declaration.setter
+    def qubit_variable_declaration(self, val):
         if val is None:
-            del self.statements
+            del self.qubit_variable_declaration
             return
-        if not isinstance(val, MultiStatement):
+        if not isinstance(val, Variable):
             # 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('qubit_variable_declaration must be of type Variable')
+            val = Variable(val)
+        self._attr_qubit_variable_declaration = val
 
-    @statements.deleter
-    def statements(self):
-        self._attr_statements = MultiStatement()
+    @qubit_variable_declaration.deleter
+    def qubit_variable_declaration(self):
+        self._attr_qubit_variable_declaration = None
 
     @property
-    def variables(self):
-        """The list of variables."""
-        return self._attr_variables
+    def block(self):
+        """Global scope block."""
+        return self._attr_block
 
-    @variables.setter
-    def variables(self, val):
+    @block.setter
+    def block(self, val):
         if val is None:
-            del self.variables
+            del self.block
             return
-        if not isinstance(val, MultiVariable):
+        if not isinstance(val, Block):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('variables must be of type MultiVariable')
-            val = MultiVariable(val)
-        self._attr_variables = val
+                raise TypeError('block must be of type Block')
+            val = Block(val)
+        self._attr_block = val
 
-    @variables.deleter
-    def variables(self):
-        self._attr_variables = MultiVariable()
+    @block.deleter
+    def block(self):
+        self._attr_block = None
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
@@ -1941,9 +1664,9 @@ class Program(Node):
             return False
         if self.version != other.version:
             return False
-        if self.statements != other.statements:
+        if self.qubit_variable_declaration != other.qubit_variable_declaration:
             return False
-        if self.variables != other.variables:
+        if self.block != other.block:
             return False
         return True
 
@@ -1974,23 +1697,21 @@ class Program(Node):
             s.append(self.version.dump(indent + 1, annotations, links) + '\n')
             s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('statements: ')
-        if not self.statements:
+        s.append('qubit_variable_declaration: ')
+        if self.qubit_variable_declaration is None:
             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')
+            s.append('<\n')
+            s.append(self.qubit_variable_declaration.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
         s.append('  '*indent)
-        s.append('variables: ')
-        if not self.variables:
+        s.append('block: ')
+        if self.block is None:
             s.append('-\n')
         else:
-            s.append('[\n')
-            for child in self.variables:
-                s.append(child.dump(indent + 1, annotations, links) + '\n')
-            s.append('  '*indent + ']\n')
+            s.append('<\n')
+            s.append(self.block.dump(indent + 1, annotations, links) + '\n')
+            s.append('  '*indent + '>\n')
         indent -= 1
         s.append('  '*indent)
         s.append(')')
@@ -2010,10 +1731,10 @@ class Program(Node):
         id_map[id(self)] = len(id_map)
         if self._attr_version is not None:
             self._attr_version.find_reachable(id_map)
-        for el in self._attr_statements:
-            el.find_reachable(id_map)
-        for el in self._attr_variables:
-            el.find_reachable(id_map)
+        if self._attr_qubit_variable_declaration is not None:
+            self._attr_qubit_variable_declaration.find_reachable(id_map)
+        if self._attr_block is not None:
+            self._attr_block.find_reachable(id_map)
         return id_map
 
     def check_complete(self, id_map=None):
@@ -2027,18 +1748,18 @@ class Program(Node):
             raise NotWellFormed('version is required but not set')
         if self._attr_version is not None:
             self._attr_version.check_complete(id_map)
-        for child in self._attr_statements:
-            child.check_complete(id_map)
-        for child in self._attr_variables:
-            child.check_complete(id_map)
+        if self._attr_qubit_variable_declaration is not None:
+            self._attr_qubit_variable_declaration.check_complete(id_map)
+        if self._attr_block is not None:
+            self._attr_block.check_complete(id_map)
 
     def copy(self):
         """Returns a shallow copy of this node."""
         return Program(
             api_version=self._attr_api_version,
             version=self._attr_version,
-            statements=self._attr_statements.copy(),
-            variables=self._attr_variables.copy()
+            qubit_variable_declaration=self._attr_qubit_variable_declaration,
+            block=self._attr_block
         )
 
     def clone(self):
@@ -2050,8 +1771,8 @@ class Program(Node):
         return Program(
             api_version=_cloned(self._attr_api_version),
             version=_cloned(self._attr_version),
-            statements=_cloned(self._attr_statements),
-            variables=_cloned(self._attr_variables)
+            qubit_variable_declaration=_cloned(self._attr_qubit_variable_declaration),
+            block=_cloned(self._attr_block)
         )
 
     @staticmethod
@@ -2090,38 +1811,30 @@ class Program(Node):
         else:
             f_version = Version._deserialize(field, seq_to_ob, links)
 
-        # Deserialize the statements field.
-        field = cbor.get('statements', None)
+        # 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 statements')
-        if field.get('@T') != '*':
-            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_statements = MultiStatement()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_statements.append(Statement._deserialize(element, seq_to_ob, links))
+            raise ValueError('missing or invalid serialization of field qubit_variable_declaration')
+        if field.get('@T') != '?':
+            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 variables field.
-        field = cbor.get('variables', None)
+        # Deserialize the block field.
+        field = cbor.get('block', None)
         if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field variables')
-        if field.get('@T') != '*':
-            raise ValueError('unexpected edge type for field variables')
-        data = field.get('@d', None)
-        if not isinstance(data, list):
-            raise ValueError('missing serialization of Any/Many contents')
-        f_variables = MultiVariable()
-        for element in data:
-            if element.get('@T') != '1':
-                raise ValueError('unexpected edge type for Any/Many element')
-            f_variables.append(Variable._deserialize(element, seq_to_ob, links))
+            raise ValueError('missing or invalid serialization of field block')
+        if field.get('@T') != '?':
+            raise ValueError('unexpected edge type for field block')
+        if field.get('@t', None) is None:
+            f_block = None
+        else:
+            f_block = Block._deserialize(field, seq_to_ob, links)
 
         # Construct the Program node.
-        node = Program(f_api_version, f_version, f_statements, f_variables)
+        node = Program(f_api_version, f_version, f_qubit_variable_declaration, f_block)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -2161,25 +1874,21 @@ class Program(Node):
             field.update(self._attr_version._serialize(id_map))
         cbor['version'] = field
 
-        # Serialize the statements field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_statements:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['statements'] = field
+        # Serialize the qubit_variable_declaration field.
+        field = {'@T': '?'}
+        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 variables field.
-        field = {'@T': '*'}
-        lst = []
-        for el in self._attr_variables:
-            el = el._serialize(id_map)
-            el['@T'] = '1'
-            lst.append(el)
-        field['@d'] = lst
-        cbor['variables'] = field
+        # Serialize the block field.
+        field = {'@T': '?'}
+        if self._attr_block is None:
+            field['@t'] = None
+        else:
+            field.update(self._attr_block._serialize(id_map))
+        cbor['block'] = field
 
         # Serialize annotations.
         for key, val in self._annot.items():
@@ -2241,11 +1950,11 @@ class Variable(Annotated):
         if val is None:
             del self.typ
             return
-        if not isinstance(val, cqasm.v3x.types.Node):
+        if not isinstance(val, cqasm.v3x.types.TypeBase):
             # Try to "typecast" if this isn't an obvious mistake.
             if isinstance(val, Node):
-                raise TypeError('typ must be of type cqasm.v3x.types.Node')
-            val = cqasm.v3x.types.Node(val)
+                raise TypeError('typ must be of type cqasm.v3x.types.TypeBase')
+            val = cqasm.v3x.types.TypeBase(val)
         self._attr_typ = val
 
     @typ.deleter
@@ -2390,7 +2099,7 @@ class Variable(Annotated):
         if field.get('@t', None) is None:
             f_typ = None
         else:
-            f_typ = cqasm.v3x.types.Node._deserialize(field, seq_to_ob, links)
+            f_typ = cqasm.v3x.types.TypeBase._deserialize(field, seq_to_ob, links)
 
         # Deserialize the annotations field.
         field = cbor.get('annotations', None)