Introducing Qubits and Clbits classes

CHANGELOG.rst

@@ -40,6 +40,11 @@ Removed
 - The ``qiskit.qiskiterror`` module has been removed. Please use
   ``qiskit.exceptions`` instead. (#2399)
 
+Changed
+-------
+- Qubits and classical bits are not represented as a tuples anymore, but as
+  instances of ``Qubit`` and ``Clbit`` respectively.
+
 `0.8.0`_ - 2019-05-02
 =====================
 

qiskit/assembler/assemble_circuits.py

@@ -87,11 +87,11 @@ def assemble_circuits(circuits, run_config, qobj_id, qobj_header):
             qargs = op_context[1]
             cargs = op_context[2]
             if qargs:
-                qubit_indices = [qubit_labels.index([qubit[0].name, qubit[1]])
+                qubit_indices = [qubit_labels.index([qubit.register.name, qubit.index])
                                  for qubit in qargs]
                 instruction.qubits = qubit_indices
             if cargs:
-                clbit_indices = [clbit_labels.index([clbit[0].name, clbit[1]])
+                clbit_indices = [clbit_labels.index([clbit.register.name, clbit.index])
                                  for clbit in cargs]
                 instruction.memory = clbit_indices
                 # If the experiment has conditional instructions, assume every

qiskit/circuit/__init__.py

@@ -14,8 +14,8 @@
 
 """Module for Circuits."""
 from .quantumcircuit import QuantumCircuit
-from .classicalregister import ClassicalRegister
-from .quantumregister import QuantumRegister
+from .classicalregister import ClassicalRegister, Clbit
+from .quantumregister import QuantumRegister, Qubit
 from .gate import Gate
 from .instruction import Instruction
 from .instructionset import InstructionSet

qiskit/circuit/bit.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+
+# This code is part of Qiskit.
+#
+# (C) Copyright IBM 2019.
+#
+# This code is licensed under the Apache License, Version 2.0. You may
+# obtain a copy of this license in the LICENSE.txt file in the root directory
+# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
+#
+# Any modifications or derivative works of this code must retain this
+# copyright notice, and modified files need to carry a notice indicating
+# that they have been altered from the originals.
+
+"""
+Quantum bit and Classical bit objects.
+"""
+from warnings import warn
+from qiskit.exceptions import QiskitError
+
+
+class Bit:
+    """Implement a generic bit."""
+
+    def __init__(self, register, index):
+        """Create a new generic bit.
+        """
+        try:
+            index = int(index)
+        except Exception:
+            raise QiskitError("index needs to be castable to an int: type %s was provided" %
+                              type(index))
+
+        if index < 0:
+            index += register.size
+
+        if index >= register.size:
+            raise QiskitError("index must be under the size of the register: %s was provided" %
+                              index)
+
+        self.register = register
+        self.index = index
+
+    def __repr__(self):
+        """Return the official string representing the bit."""
+        return "%s(%s, %s)" % (self.__class__.__name__, self.register, self.index)
+
+    def __getitem__(self, item):
+        warn('Accessing a bit register by bit[0] or its index by bit[1] is deprecated. '
+             'Go for bit.register and bit.index.', DeprecationWarning)
+        if item == 0:
+            return self.register
+        elif item == 1:
+            return self.index
+        else:
+            raise IndexError
+
+    def __hash__(self):
+        return hash((self.register, self.index))
+
+    def __eq__(self, other):
+        if isinstance(other, tuple):
+            return other[1] == self.index and other[0] == self.register
+        return other.index == self.index and other.register == self.register

qiskit/circuit/classicalregister.py

@@ -17,7 +17,20 @@
 """
 import itertools
 
+from qiskit.exceptions import QiskitError
 from .register import Register
+from .bit import Bit
+
+
+class Clbit(Bit):
+    """Implement a classical bit."""
+
+    def __init__(self, register, index):
+        if isinstance(register, ClassicalRegister):
+            super().__init__(register, index)
+        else:
+            raise QiskitError('Clbit needs a ClassicalRegister and %s was provided' %
+                              type(register).__name__)
 
 
 class ClassicalRegister(Register):
@@ -27,6 +40,7 @@ class ClassicalRegister(Register):
     instances_counter = itertools.count()
     # Prefix to use for auto naming.
     prefix = 'c'
+    bit_type = Clbit
 
     def qasm(self):
         """Return OPENQASM string for this register."""

qiskit/circuit/quantumcircuit.py

@@ -18,24 +18,28 @@
 import itertools
 import sys
 import multiprocessing as mp
+from warnings import warn
 
 from qiskit.circuit.instruction import Instruction
 from qiskit.qasm.qasm import Qasm
 from qiskit.exceptions import QiskitError
 from qiskit.circuit.parameter import Parameter
-from .quantumregister import QuantumRegister
-from .classicalregister import ClassicalRegister
+from .quantumregister import QuantumRegister, Qubit
+from .classicalregister import ClassicalRegister, Clbit
 from .parametertable import ParameterTable
 from .parametervector import ParameterVector
 from .instructionset import InstructionSet
 from .register import Register
+from .bit import Bit
 
 
 def _is_bit(obj):
     """Determine if obj is a bit"""
     # If there is a bit type this could be replaced by isinstance.
     if isinstance(obj, tuple) and len(obj) == 2:
         if isinstance(obj[0], Register) and isinstance(obj[1], int) and obj[1] < len(obj[0]):
+            warn('Referring to a bit as a tuple is being deprecated. '
+                 'Instead go of (qr, 0), use qr[0].', DeprecationWarning)
             return True
     return False
 
@@ -265,35 +269,43 @@ def cast(value, _type):
 
     @staticmethod
     def _bit_argument_conversion(bit_representation, in_array):
+        ret = None
         try:
             if _is_bit(bit_representation):
+                # circuit.h((qr, 0)) -> circuit.h([qr[0]])
+                ret = [bit_representation[0][bit_representation[1]]]
+            elif isinstance(bit_representation, Bit):
                 # circuit.h(qr[0]) -> circuit.h([qr[0]])
-                return [bit_representation]
+                ret = [bit_representation]
             elif isinstance(bit_representation, Register):
                 # circuit.h(qr) -> circuit.h([qr[0], qr[1]])
-                return bit_representation[:]
+                ret = bit_representation[:]
             elif isinstance(QuantumCircuit.cast(bit_representation, int), int):
                 # circuit.h(0) -> circuit.h([qr[0]])
-                return [in_array[bit_representation]]
+                ret = [in_array[bit_representation]]
             elif isinstance(bit_representation, slice):
                 # circuit.h(slice(0,2)) -> circuit.h([qr[0], qr[1]])
-                return in_array[bit_representation]
+                ret = in_array[bit_representation]
             elif isinstance(bit_representation, list) and \
                     all(_is_bit(bit) for bit in bit_representation):
+                ret = [bit[0][bit[1]] for bit in bit_representation]
+            elif isinstance(bit_representation, list) and \
+                    all(isinstance(bit, Bit) for bit in bit_representation):
                 # circuit.h([qr[0], qr[1]]) -> circuit.h([qr[0], qr[1]])
-                return bit_representation
+                ret = bit_representation
             elif isinstance(QuantumCircuit.cast(bit_representation, list), (range, list)):
                 # circuit.h([0, 1])     -> circuit.h([qr[0], qr[1]])
                 # circuit.h(range(0,2)) -> circuit.h([qr[0], qr[1]])
-                return [in_array[index] for index in bit_representation]
+                ret = [in_array[index] for index in bit_representation]
             else:
                 raise QiskitError('Not able to expand a %s (%s)' % (bit_representation,
                                                                     type(bit_representation)))
         except IndexError:
             raise QiskitError('Index out of range.')
         except TypeError:
-            raise QiskitError('Type error handeling %s (%s)' % (bit_representation,
-                                                                type(bit_representation)))
+            raise QiskitError('Type error handling %s (%s)' % (bit_representation,
+                                                               type(bit_representation)))
+        return ret
 
     def qbit_argument_conversion(self, qubit_representation):
         """
@@ -429,25 +441,17 @@ def _check_dups(self, qubits):
 
     def _check_qargs(self, qargs):
         """Raise exception if a qarg is not in this circuit or bad format."""
-        if not all(isinstance(i, tuple) and
-                   isinstance(i[0], QuantumRegister) and
-                   isinstance(i[1], int) for i in qargs):
-            raise QiskitError("qarg not (QuantumRegister, int) tuple")
-        if not all(self.has_register(i[0]) for i in qargs):
+        if not all(isinstance(i, Qubit) for i in qargs):
+            raise QiskitError("qarg is not a Qubit")
+        if not all(self.has_register(i.register) for i in qargs):
             raise QiskitError("register not in this circuit")
-        for qubit in qargs:
-            qubit[0].check_range(qubit[1])
 
     def _check_cargs(self, cargs):
         """Raise exception if clbit is not in this circuit or bad format."""
-        if not all(isinstance(i, tuple) and
-                   isinstance(i[0], ClassicalRegister) and
-                   isinstance(i[1], int) for i in cargs):
-            raise QiskitError("carg not (ClassicalRegister, int) tuple")
-        if not all(self.has_register(i[0]) for i in cargs):
+        if not all(isinstance(i, Clbit) for i in cargs):
+            raise QiskitError("carg is not a Clbit")
+        if not all(self.has_register(i.register) for i in cargs):
             raise QiskitError("register not in this circuit")
-        for clbit in cargs:
-            clbit[0].check_range(clbit[1])
 
     def to_instruction(self, parameter_map=None):
         """Create an Instruction out of this circuit.
@@ -502,11 +506,11 @@ def qasm(self):
                 qubit = qargs[0]
                 clbit = cargs[0]
                 string_temp += "%s %s[%d] -> %s[%d];\n" % (instruction.qasm(),
-                                                           qubit[0].name, qubit[1],
-                                                           clbit[0].name, clbit[1])
+                                                           qubit.register.name, qubit.index,
+                                                           clbit.register.name, clbit.index)
             else:
                 string_temp += "%s %s;\n" % (instruction.qasm(),
-                                             ",".join(["%s[%d]" % (j[0].name, j[1])
+                                             ",".join(["%s[%d]" % (j.register.name, j.index)
                                                        for j in qargs + cargs]))
         return string_temp
 
@@ -627,7 +631,7 @@ def depth(self):
                 for ind, reg in enumerate(qargs + cargs):
                     # Add to the stacks of the qubits and
                     # cbits used in the gate.
-                    reg_ints.append(reg_map[reg[0].name] + reg[1])
+                    reg_ints.append(reg_map[reg.register.name] + reg.index)
                     levels.append(op_stack[reg_ints[ind]] + 1)
                 if instr.control:
                     # Controls operate over all bits in the
@@ -719,7 +723,7 @@ def num_connected_components(self, unitary_only=False):
                                 break
 
                 for item in args:
-                    reg_int = reg_map[item[0].name] + item[1]
+                    reg_int = reg_map[item.register.name] + item.index
                     for k in range(num_sub_graphs):
                         if reg_int in sub_graphs[k]:
                             if k not in graphs_touched:

qiskit/circuit/quantumregister.py

@@ -17,7 +17,20 @@
 """
 import itertools
 
+from qiskit.exceptions import QiskitError
 from .register import Register
+from .bit import Bit
+
+
+class Qubit(Bit):
+    """Implement a quantum bit."""
+
+    def __init__(self, register, index):
+        if isinstance(register, QuantumRegister):
+            super().__init__(register, index)
+        else:
+            raise QiskitError('Qubit needs a QuantumRegister and %s was provided' %
+                              type(register).__name__)
 
 
 class QuantumRegister(Register):
@@ -26,6 +39,7 @@ class QuantumRegister(Register):
     instances_counter = itertools.count()
     # Prefix to use for auto naming.
     prefix = 'q'
+    bit_type = Qubit
 
     def qasm(self):
         """Return OPENQASM string for this register."""