Update documentation of the simulaqron.virtual_node package

Author: dieriver

docs/simulaqron.toolbox.rst

@@ -4,38 +4,6 @@ simulaqron.toolbox package
 Submodules
 ----------
 
-simulaqron.toolbox.get_simulaqron_path module
----------------------------------------------
-
-.. automodule:: simulaqron.toolbox.get_simulaqron_path
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-simulaqron.toolbox.has_module module
-------------------------------------
-
-.. automodule:: simulaqron.toolbox.has_module
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-simulaqron.toolbox.manage_nodes module
---------------------------------------
-
-.. automodule:: simulaqron.toolbox.manage_nodes
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
-simulaqron.toolbox.reset module
--------------------------------
-
-.. automodule:: simulaqron.toolbox.reset
-    :members:
-    :undoc-members:
-    :show-inheritance:
-
 simulaqron.toolbox.stabilizer_states module
 -------------------------------------------
 

docs/simulaqron.virtual_node.rst

@@ -36,7 +36,7 @@ simulaqron.virtual_node.qutip_simulator module
     :undoc-members:
     :show-inheritance:
 
-simulaqron.virtual_node.stabilizerSimulator module
+simulaqron.virtual_node.stabilizer_simulator module
 --------------------------------------------------
 
 .. automodule:: simulaqron.virtual_node.stabilizer_simulator

simulaqron/toolbox/stabilizer_states.py

@@ -23,7 +23,7 @@ class StabilizerState:
 
     Pauli2bool = {"I": (False, False), "X": (True, False), "Y": (True, True), "Z": (False, True)}
 
-    def __init__(self, data=None, check_symplectic=True):
+    def __init__(self, data=None, check_symplectic: bool = True):
         """
         This class represent a stabilizer state and allows to be manipulated using
         Clifford operations and Pauli-measurements.
@@ -82,8 +82,8 @@ def __init__(self, data=None, check_symplectic=True):
         The entangled state (|01> + |10>)/sqrt(2) can be created as:
             StabilizerState([[1, 1, 0, 0, 0],
                               0, 0, 1, 1, 1]])
-        :param check_symplectic: bool
-            Whether to check if all stabilizers commute or not.
+        :param check_symplectic: Whether to check if all stabilizers commute or not.
+        :type check_symplectic: bool
         """
         if data is None:
             self._group = np.empty(shape=(0, 0), dtype=bool)
@@ -265,6 +265,7 @@ def boolean_gaussian_elimination(matrix, return_pivot_columns=False):
         """
         Given a boolean matrix returns the matrix in row reduced echelon form
         where entries are seen as elements of GF(2), i.e. intergers modulus 2.
+
         :param matrix: The boolean matrix
         :type matrix: :obj:`numpy.array`
         :return:

simulaqron/virtual_node/basics.py

@@ -55,17 +55,18 @@ def __str__(self):
 class QuantumEngine(pb.Referenceable, abc.ABC):
     """
     Basic quantum engine. Abstract class meant to be subclassed to implement different simulation backends.
-
-    Attributes:
-        Arguments
-        node		node this register is started from
-        num		number of this register
-        maxQubits	maximum number of qubits this register supports
     """
 
     def __init__(self, node: str, num: int, maxQubits: int = 10):
         """
-        Initialize the simple engine. If no number is given for maxQubits, the assumption will be 10.
+        Initialize the simple engine.
+
+        :param node: Node name this register is started from.
+        :type node: str
+        :param num: Number of this register.
+        :type num: int
+        :param maxQubits: maximum number of qubits this register supports. If not give, it will default to 10.
+        :type maxQubits: int
         """
 
         self.maxQubits = maxQubits
@@ -80,7 +81,8 @@ def __init__(self, node: str, num: int, maxQubits: int = 10):
     @abc.abstractmethod
     def add_fresh_qubit(self) -> int:
         """
-        Add a new qubit initialized in the |0> state.
+        Add a new qubit initialized in the :math:`|0>` state.
+
         :return: The qubit number
         :rtype: int
         """
@@ -90,6 +92,9 @@ def add_fresh_qubit(self) -> int:
     def add_qubit(self, newQubit) -> int:
         """
         Add new qubit in the state described by the density matrix newQubit
+
+        :param newQubit: The new qubit state
+        :type newQubit: Any
         :return: The qubit number
         :rtype: int
         """
@@ -99,6 +104,9 @@ def add_qubit(self, newQubit) -> int:
     def remove_qubit(self, qubitNum: int) -> None:
         """
         Removes the qubit with the desired number qubitNum
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -117,8 +125,9 @@ def get_register_RI(self):
     def get_density_matrix_RI(self):
         """
         Retrieves the entire register in real and imaginary parts and returns the result of
-        the outer product. In other words, if the qubit is in state |q>, this function
-        returns the density matrix |q><q| of the qubit.
+        the outer product. In other words, if the qubit is in state :math:`|q>`, this function
+        returns the density matrix :math:`|q><q|` of the qubit.
+
         :return: The density matrix real and imaginary parts of a qubit state
         """
         pass
@@ -127,6 +136,9 @@ def get_density_matrix_RI(self):
     def apply_H(self, qubitNum):
         """
         Applies a Hadamard gate to the qubits with number qubitNum.
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -135,14 +147,20 @@ def apply_H(self, qubitNum):
     def apply_K(self, qubitNum):
         """
         Applies a K gate to the qubits with number qubitNum. Maps computational basis to Y eigenbasis.
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
 
     @abc.abstractmethod
     def apply_X(self, qubitNum):
         """
-        Applies a X gate to the qubits with number qubitNum.
+        Applies an X gate to the qubits with number qubitNum.
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -151,6 +169,9 @@ def apply_X(self, qubitNum):
     def apply_Z(self, qubitNum):
         """
         Applies a Z gate to the qubits with number qubitNum.
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -159,6 +180,9 @@ def apply_Z(self, qubitNum):
     def apply_Y(self, qubitNum):
         """
         Applies a Y gate to the qubits with number qubitNum.
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -167,6 +191,9 @@ def apply_Y(self, qubitNum):
     def apply_T(self, qubitNum):
         """
         Applies a T gate to the qubits with number qubitNum.
+
+        :param qubitNum: Qubit number
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -177,12 +204,12 @@ def apply_rotation(self, qubitNum, n, a):
         Applies a rotation around the axis n with the angle a to qubit with number qubitNum. If n is zero a ValueError
         is raised.
 
-        :param qubitNum: int
-            Qubit number
-        :param n: tuple
-            A tuple of three numbers specifying the rotation axis, e.g n=(1,0,0)
-        :param a: float
-            The rotation angle in radians.
+        :param qubitNum: Qubit number
+        :type qubitNum: int
+        :param n: A tuple of three numbers specifying the rotation axis, e.g n=(1,0,0)
+        :type n: Tuple[int, int, int]
+        :param a: The rotation angle in radians.
+        :type a: float
         :rtype: None
         """
         pass
@@ -191,6 +218,11 @@ def apply_rotation(self, qubitNum, n, a):
     def apply_CNOT(self, qubitNum1, qubitNum2):
         """
         Applies the CNOT to the qubit with the numbers qubitNum1 and qubitNum2.
+
+        :param qubitNum1: Qubit number 1
+        :type qubitNum1: int
+        :param qubitNum2: Qubit number 2
+        :type qubitNum2: int
         :rtype: None
         """
         pass
@@ -199,6 +231,11 @@ def apply_CNOT(self, qubitNum1, qubitNum2):
     def apply_CPHASE(self, qubitNum1, qubitNum2):
         """
         Applies the CPHASE to the qubit with the numbers qubitNum1 and qubitNum2.
+
+        :param qubitNum1: Qubit number 1
+        :type qubitNum1: int
+        :param qubitNum2: Qubit number 2
+        :type qubitNum2: int
         :rtype: None
         """
         pass
@@ -208,9 +245,10 @@ def apply_onequbit_gate(self, gateU, qubitNum):
         """
         Applies a unitary gate to the specified qubit.
 
-        Arguments:
-        gateU   	unitary to apply as Qobj
-        qubitNum 	the number of the qubit this gate is applied to
+        :param gateU: Unitary to apply as Qobj
+        :type gateU: Qobj
+        :param qubitNum: The number of the qubit this gate is applied to
+        :type qubitNum: int
         :rtype: None
         """
         pass
@@ -220,10 +258,12 @@ def apply_twoqubit_gate(self, gateU, qubit1, qubit2):
         """
         Applies a unitary gate to the two specified qubits.
 
-        Arguments:
-        gateU		unitary to apply as Qobj
-        qubit1 		the first qubit
-        qubit2		the second qubit
+        :param gateU: Unitary to apply as Qobj
+        :type gateU: Qobj
+        :param qubit1: The first qubit
+        :type qubit1: int
+        :param qubit2: The second qubit
+        :type qubit2: int
         :rtype: None
         """
         pass
@@ -234,9 +274,9 @@ def measure_qubit_inplace(self, qubitNum):
         Measures the desired qubit in the standard basis. This returns the classical outcome. The quantum register
         is in the post-measurment state corresponding to the obtained outcome.
 
-        Arguments:
-        qubitNum	qubit to be measured
-        :return: The meaurement outcome
+        :param qubitNum: Qubit to be measured
+        :type qubitNum: int
+        :return: The measurement outcome
         :rtype: int
         """
         pass
@@ -246,9 +286,9 @@ def measure_qubit(self, qubitNum):
         """
         Measures the desired qubit in the standard basis. This returns the classical outcome and deletes the qubit.
 
-        Arguments:
-        qubitNum	qubit to be measured
-        :return: The meaurement outcome
+        :param qubitNum: Qubit to be measured
+        :type qubitNum: int
+        :return: The measurement outcome
         :rtype: int
         """
         pass
@@ -257,6 +297,11 @@ def measure_qubit(self, qubitNum):
     def replace_qubit(self, qubitNum, state):
         """
         Replaces the qubit at position qubitNum with the one given by state.
+
+        :param qubitNum: Qubit to be replaced
+        :type qubitNum: int
+        :param state: New state to write in the place of the old qubit.
+        :type state: Any
         :rtype: None
         """
         pass
@@ -265,6 +310,9 @@ def replace_qubit(self, qubitNum, state):
     def absorb(self, other):
         """
         Absorb the qubits from the other engine into this one. This is done by tensoring the state at the end.
+
+        :param other: The other qubit to absorb.
+        :type other: int
         :rtype: None
         """
         pass
@@ -274,10 +322,11 @@ def absorb_parts(self, R, I, activeQ):
         """
         Absorb the qubits, given in pieces
 
-        Arguments:
-        R		real part of the qubit state as a list
-        I		imaginary part as a list
-        activeQ		active number of qubits
+        :param R: Real part of the qubit state as a list.
+        :type R: List[float]
+        :param I: Imaginary part as a list.
+        :type I: List[float]
+        :param activeQ: Active number of qubits
         :rtype: None
         """
         pass