libqasm 0.5.2__cp311-cp311-macosx_10_10_universal2.whl → 0.6.1__cp311-cp311-macosx_10_10_universal2.whl

cqasm/v3x/types.py

@@ -633,28 +633,14 @@ class TypeBase(Node):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ == 'Axis':
-            return Axis._deserialize(cbor, seq_to_ob, links)
         if typ == 'Bool':
             return Bool._deserialize(cbor, seq_to_ob, links)
         if typ == 'Int':
             return Int._deserialize(cbor, seq_to_ob, links)
-        if typ == 'Real':
-            return Real._deserialize(cbor, seq_to_ob, links)
-        if typ == 'Complex':
-            return Complex._deserialize(cbor, seq_to_ob, links)
-        if typ == 'Bit':
-            return Bit._deserialize(cbor, seq_to_ob, links)
+        if typ == 'Float':
+            return Float._deserialize(cbor, seq_to_ob, links)
         if typ == 'Qubit':
             return Qubit._deserialize(cbor, seq_to_ob, links)
-        if typ == 'BoolArray':
-            return BoolArray._deserialize(cbor, seq_to_ob, links)
-        if typ == 'IntArray':
-            return IntArray._deserialize(cbor, seq_to_ob, links)
-        if typ == 'RealArray':
-            return RealArray._deserialize(cbor, seq_to_ob, links)
-        if typ == 'BitArray':
-            return BitArray._deserialize(cbor, seq_to_ob, links)
         if typ == 'QubitArray':
             return QubitArray._deserialize(cbor, seq_to_ob, links)
         raise ValueError('unknown or unexpected type (@t) found in node serialization')
@@ -687,8 +673,8 @@ class MultiTypeBase(_Multiple):
 
 _typemap['TypeBase'] = TypeBase
 
-class Axis(TypeBase):
-    """Type of an axis (x, y, and z vectors)."""
+class Bool(TypeBase):
+    """Type of a boolean."""
 
     __slots__ = []
 
@@ -700,7 +686,7 @@ class Axis(TypeBase):
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Axis):
+        if not isinstance(other, Bool):
             return False
         if self.size != other.size:
             return False
@@ -713,7 +699,7 @@ class Axis(TypeBase):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('Axis(')
+        s.append('Bool(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -753,7 +739,7 @@ class Axis(TypeBase):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return Axis(
+        return Bool(
             size=self._attr_size
         )
 
@@ -763,7 +749,7 @@ class Axis(TypeBase):
         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 Axis(
+        return Bool(
             size=_cloned(self._attr_size)
         )
 
@@ -780,8 +766,8 @@ class Axis(TypeBase):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'Axis':
-            raise ValueError('found node serialization for ' + typ + ', but expected Axis')
+        if typ != 'Bool':
+            raise ValueError('found node serialization for ' + typ + ', but expected Bool')
 
         # Deserialize the size field.
         field = cbor.get('size', None)
@@ -792,8 +778,8 @@ class Axis(TypeBase):
         else:
             f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
 
-        # Construct the Axis node.
-        node = Axis(f_size)
+        # Construct the Bool node.
+        node = Bool(f_size)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -817,7 +803,7 @@ class Axis(TypeBase):
         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': 'Axis'}
+        cbor = {'@i': id_map[id(self)], '@t': 'Bool'}
 
         # Serialize the size field.
         if hasattr(self._attr_size, 'serialize_cbor'):
@@ -832,166 +818,17 @@ class Axis(TypeBase):
         return cbor
 
 
-class MultiAxis(_Multiple):
-    """Wrapper for an edge with multiple Axis objects."""
-
-    _T = Axis
-
-
-_typemap['Axis'] = Axis
-
-class Bit(TypeBase):
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Bit):
-            return False
-        if self.size != other.size:
-            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('Bit(')
-        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('size: ')
-        s.append(str(self.size) + '\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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return Bit(
-            size=self._attr_size
-        )
-
-    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 Bit(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'Bit':
-            raise ValueError('found node serialization for ' + typ + ', but expected Bit')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the Bit node.
-        node = Bit(f_size)
-
-        # 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': 'Bit'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
+class MultiBool(_Multiple):
+    """Wrapper for an edge with multiple Bool objects."""
 
-class MultiBit(_Multiple):
-    """Wrapper for an edge with multiple Bit objects."""
+    _T = Bool
 
-    _T = Bit
 
+_typemap['Bool'] = Bool
 
-_typemap['Bit'] = Bit
+class Float(TypeBase):
+    """Type of a float number (IEEE double)."""
 
-class BitArray(TypeBase):
     __slots__ = []
 
     def __init__(
@@ -1002,7 +839,7 @@ class BitArray(TypeBase):
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, BitArray):
+        if not isinstance(other, Float):
             return False
         if self.size != other.size:
             return False
@@ -1015,7 +852,7 @@ class BitArray(TypeBase):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('BitArray(')
+        s.append('Float(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1055,7 +892,7 @@ class BitArray(TypeBase):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return BitArray(
+        return Float(
             size=self._attr_size
         )
 
@@ -1065,7 +902,7 @@ class BitArray(TypeBase):
         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 BitArray(
+        return Float(
             size=_cloned(self._attr_size)
         )
 
@@ -1082,8 +919,8 @@ class BitArray(TypeBase):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'BitArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected BitArray')
+        if typ != 'Float':
+            raise ValueError('found node serialization for ' + typ + ', but expected Float')
 
         # Deserialize the size field.
         field = cbor.get('size', None)
@@ -1094,8 +931,8 @@ class BitArray(TypeBase):
         else:
             f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
 
-        # Construct the BitArray node.
-        node = BitArray(f_size)
+        # Construct the Float node.
+        node = Float(f_size)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1119,7 +956,7 @@ class BitArray(TypeBase):
         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': 'BitArray'}
+        cbor = {'@i': id_map[id(self)], '@t': 'Float'}
 
         # Serialize the size field.
         if hasattr(self._attr_size, 'serialize_cbor'):
@@ -1134,16 +971,16 @@ class BitArray(TypeBase):
         return cbor
 
 
-class MultiBitArray(_Multiple):
-    """Wrapper for an edge with multiple BitArray objects."""
+class MultiFloat(_Multiple):
+    """Wrapper for an edge with multiple Float objects."""
 
-    _T = BitArray
+    _T = Float
 
 
-_typemap['BitArray'] = BitArray
+_typemap['Float'] = Float
 
-class Bool(TypeBase):
-    """Type of a boolean."""
+class Int(TypeBase):
+    """Type of an integer (signed 64-bit)."""
 
     __slots__ = []
 
@@ -1155,7 +992,7 @@ class Bool(TypeBase):
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Bool):
+        if not isinstance(other, Int):
             return False
         if self.size != other.size:
             return False
@@ -1168,7 +1005,7 @@ class Bool(TypeBase):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('Bool(')
+        s.append('Int(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1208,7 +1045,7 @@ class Bool(TypeBase):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return Bool(
+        return Int(
             size=self._attr_size
         )
 
@@ -1218,7 +1055,7 @@ class Bool(TypeBase):
         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 Bool(
+        return Int(
             size=_cloned(self._attr_size)
         )
 
@@ -1235,8 +1072,8 @@ class Bool(TypeBase):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'Bool':
-            raise ValueError('found node serialization for ' + typ + ', but expected Bool')
+        if typ != 'Int':
+            raise ValueError('found node serialization for ' + typ + ', but expected Int')
 
         # Deserialize the size field.
         field = cbor.get('size', None)
@@ -1247,8 +1084,8 @@ class Bool(TypeBase):
         else:
             f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
 
-        # Construct the Bool node.
-        node = Bool(f_size)
+        # Construct the Int node.
+        node = Int(f_size)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1272,7 +1109,7 @@ class Bool(TypeBase):
         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': 'Bool'}
+        cbor = {'@i': id_map[id(self)], '@t': 'Int'}
 
         # Serialize the size field.
         if hasattr(self._attr_size, 'serialize_cbor'):
@@ -1287,15 +1124,15 @@ class Bool(TypeBase):
         return cbor
 
 
-class MultiBool(_Multiple):
-    """Wrapper for an edge with multiple Bool objects."""
+class MultiInt(_Multiple):
+    """Wrapper for an edge with multiple Int objects."""
 
-    _T = Bool
+    _T = Int
 
 
-_typemap['Bool'] = Bool
+_typemap['Int'] = Int
 
-class BoolArray(TypeBase):
+class Qubit(TypeBase):
     __slots__ = []
 
     def __init__(
@@ -1306,7 +1143,7 @@ class BoolArray(TypeBase):
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, BoolArray):
+        if not isinstance(other, Qubit):
             return False
         if self.size != other.size:
             return False
@@ -1319,7 +1156,7 @@ class BoolArray(TypeBase):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('BoolArray(')
+        s.append('Qubit(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1359,7 +1196,7 @@ class BoolArray(TypeBase):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return BoolArray(
+        return Qubit(
             size=self._attr_size
         )
 
@@ -1369,7 +1206,7 @@ class BoolArray(TypeBase):
         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 BoolArray(
+        return Qubit(
             size=_cloned(self._attr_size)
         )
 
@@ -1386,8 +1223,8 @@ class BoolArray(TypeBase):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'BoolArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected BoolArray')
+        if typ != 'Qubit':
+            raise ValueError('found node serialization for ' + typ + ', but expected Qubit')
 
         # Deserialize the size field.
         field = cbor.get('size', None)
@@ -1398,8 +1235,8 @@ class BoolArray(TypeBase):
         else:
             f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
 
-        # Construct the BoolArray node.
-        node = BoolArray(f_size)
+        # Construct the Qubit node.
+        node = Qubit(f_size)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1423,7 +1260,7 @@ class BoolArray(TypeBase):
         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': 'BoolArray'}
+        cbor = {'@i': id_map[id(self)], '@t': 'Qubit'}
 
         # Serialize the size field.
         if hasattr(self._attr_size, 'serialize_cbor'):
@@ -1438,17 +1275,15 @@ class BoolArray(TypeBase):
         return cbor
 
 
-class MultiBoolArray(_Multiple):
-    """Wrapper for an edge with multiple BoolArray objects."""
-
-    _T = BoolArray
+class MultiQubit(_Multiple):
+    """Wrapper for an edge with multiple Qubit objects."""
 
+    _T = Qubit
 
-_typemap['BoolArray'] = BoolArray
 
-class Complex(TypeBase):
-    """Type of a complex number (2x IEEE double)."""
+_typemap['Qubit'] = Qubit
 
+class QubitArray(TypeBase):
     __slots__ = []
 
     def __init__(
@@ -1459,7 +1294,7 @@ class Complex(TypeBase):
 
     def __eq__(self, other):
         """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Complex):
+        if not isinstance(other, QubitArray):
             return False
         if self.size != other.size:
             return False
@@ -1472,7 +1307,7 @@ class Complex(TypeBase):
         strings of the annotations that are to be printed. links specifies the
         maximum link recursion depth."""
         s = ['  '*indent]
-        s.append('Complex(')
+        s.append('QubitArray(')
         if annotations is None:
             annotations = []
         for key in annotations:
@@ -1512,7 +1347,7 @@ class Complex(TypeBase):
 
     def copy(self):
         """Returns a shallow copy of this node."""
-        return Complex(
+        return QubitArray(
             size=self._attr_size
         )
 
@@ -1522,7 +1357,7 @@ class Complex(TypeBase):
         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 Complex(
+        return QubitArray(
             size=_cloned(self._attr_size)
         )
 
@@ -1539,8 +1374,8 @@ class Complex(TypeBase):
         typ = cbor.get('@t', None)
         if typ is None:
             raise ValueError('type (@t) field is missing from node serialization')
-        if typ != 'Complex':
-            raise ValueError('found node serialization for ' + typ + ', but expected Complex')
+        if typ != 'QubitArray':
+            raise ValueError('found node serialization for ' + typ + ', but expected QubitArray')
 
         # Deserialize the size field.
         field = cbor.get('size', None)
@@ -1551,8 +1386,8 @@ class Complex(TypeBase):
         else:
             f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
 
-        # Construct the Complex node.
-        node = Complex(f_size)
+        # Construct the QubitArray node.
+        node = QubitArray(f_size)
 
         # Deserialize annotations.
         for key, val in cbor.items():
@@ -1576,7 +1411,7 @@ class Complex(TypeBase):
         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': 'Complex'}
+        cbor = {'@i': id_map[id(self)], '@t': 'QubitArray'}
 
         # Serialize the size field.
         if hasattr(self._attr_size, 'serialize_cbor'):
@@ -1591,921 +1426,11 @@ class Complex(TypeBase):
         return cbor
 
 
-class MultiComplex(_Multiple):
-    """Wrapper for an edge with multiple Complex objects."""
-
-    _T = Complex
-
-
-_typemap['Complex'] = Complex
-
-class Int(TypeBase):
-    """Type of an integer (signed 64-bit)."""
-
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Int):
-            return False
-        if self.size != other.size:
-            return False
-        return True
+class MultiQubitArray(_Multiple):
+    """Wrapper for an edge with multiple QubitArray objects."""
 
-    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('Int(')
-        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('size: ')
-        s.append(str(self.size) + '\n')
-        indent -= 1
-        s.append('  '*indent)
-        s.append(')')
-        return ''.join(s)
+    _T = QubitArray
 
-    __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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return Int(
-            size=self._attr_size
-        )
-
-    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 Int(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'Int':
-            raise ValueError('found node serialization for ' + typ + ', but expected Int')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the Int node.
-        node = Int(f_size)
-
-        # 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': 'Int'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiInt(_Multiple):
-    """Wrapper for an edge with multiple Int objects."""
-
-    _T = Int
-
-
-_typemap['Int'] = Int
-
-class IntArray(TypeBase):
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, IntArray):
-            return False
-        if self.size != other.size:
-            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('IntArray(')
-        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('size: ')
-        s.append(str(self.size) + '\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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return IntArray(
-            size=self._attr_size
-        )
-
-    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 IntArray(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'IntArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected IntArray')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the IntArray node.
-        node = IntArray(f_size)
-
-        # 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': 'IntArray'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiIntArray(_Multiple):
-    """Wrapper for an edge with multiple IntArray objects."""
-
-    _T = IntArray
-
-
-_typemap['IntArray'] = IntArray
-
-class Qubit(TypeBase):
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Qubit):
-            return False
-        if self.size != other.size:
-            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('Qubit(')
-        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('size: ')
-        s.append(str(self.size) + '\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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return Qubit(
-            size=self._attr_size
-        )
-
-    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 Qubit(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'Qubit':
-            raise ValueError('found node serialization for ' + typ + ', but expected Qubit')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the Qubit node.
-        node = Qubit(f_size)
-
-        # 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': 'Qubit'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiQubit(_Multiple):
-    """Wrapper for an edge with multiple Qubit objects."""
-
-    _T = Qubit
-
-
-_typemap['Qubit'] = Qubit
-
-class QubitArray(TypeBase):
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, QubitArray):
-            return False
-        if self.size != other.size:
-            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('QubitArray(')
-        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('size: ')
-        s.append(str(self.size) + '\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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return QubitArray(
-            size=self._attr_size
-        )
-
-    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 QubitArray(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'QubitArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected QubitArray')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the QubitArray node.
-        node = QubitArray(f_size)
-
-        # 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': 'QubitArray'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiQubitArray(_Multiple):
-    """Wrapper for an edge with multiple QubitArray objects."""
-
-    _T = QubitArray
-
-
-_typemap['QubitArray'] = QubitArray
-
-class Real(TypeBase):
-    """Type of a real number (IEEE double)."""
-
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, Real):
-            return False
-        if self.size != other.size:
-            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('Real(')
-        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('size: ')
-        s.append(str(self.size) + '\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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return Real(
-            size=self._attr_size
-        )
-
-    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 Real(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'Real':
-            raise ValueError('found node serialization for ' + typ + ', but expected Real')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the Real node.
-        node = Real(f_size)
-
-        # 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': 'Real'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiReal(_Multiple):
-    """Wrapper for an edge with multiple Real objects."""
-
-    _T = Real
-
-
-_typemap['Real'] = Real
-
-class RealArray(TypeBase):
-    __slots__ = []
-
-    def __init__(
-        self,
-        size=None,
-    ):
-        super().__init__(size=size)
-
-    def __eq__(self, other):
-        """Equality operator. Ignores annotations!"""
-        if not isinstance(other, RealArray):
-            return False
-        if self.size != other.size:
-            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('RealArray(')
-        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('size: ')
-        s.append(str(self.size) + '\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)
-        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()
-
-    def copy(self):
-        """Returns a shallow copy of this node."""
-        return RealArray(
-            size=self._attr_size
-        )
-
-    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 RealArray(
-            size=_cloned(self._attr_size)
-        )
-
-    @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 != 'RealArray':
-            raise ValueError('found node serialization for ' + typ + ', but expected RealArray')
-
-        # Deserialize the size field.
-        field = cbor.get('size', None)
-        if not isinstance(field, dict):
-            raise ValueError('missing or invalid serialization of field size')
-        if hasattr(cqasm.v3x.primitives.Int, 'deserialize_cbor'):
-            f_size = cqasm.v3x.primitives.Int.deserialize_cbor(field)
-        else:
-            f_size = cqasm.v3x.primitives.deserialize(cqasm.v3x.primitives.Int, field)
-
-        # Construct the RealArray node.
-        node = RealArray(f_size)
-
-        # 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': 'RealArray'}
-
-        # Serialize the size field.
-        if hasattr(self._attr_size, 'serialize_cbor'):
-            cbor['size'] = self._attr_size.serialize_cbor()
-        else:
-            cbor['size'] = cqasm.v3x.primitives.serialize(cqasm.v3x.primitives.Int, self._attr_size)
-
-        # Serialize annotations.
-        for key, val in self._annot.items():
-            cbor['{%s}' % key] = _py_to_cbor(cqasm.v3x.primitives.serialize(key, val))
-
-        return cbor
-
-
-class MultiRealArray(_Multiple):
-    """Wrapper for an edge with multiple RealArray objects."""
-
-    _T = RealArray
-
-
-_typemap['RealArray'] = RealArray
+_typemap['QubitArray'] = QubitArray