Merge pull request #44 from qiboteam/doc-fix

Fix the rendering issue, refine the content.

doc/source/getting-started/quickstart.rst

@@ -1,29 +1,30 @@
 Quick start
 ===========
 
+In this section, we provide an example of two qubit ciruit simulation using qibotn package in Qibo simulator. First, the backend is to be set with appropriate run card settings, followed by the circuit simulation using Qibo documentation.
+
 Setting the backend
 """""""""""""""""""
-QiboTN supports two backends cutensornet (using CuQuantum library) and Quimbbackend (using Quimb library) for tensor network based simulations. The backend can be set using the following command line.
 
-For CuQuantum library,
+QiboTN offers two backends: cutensornet (using cuQuantum library) and qutensornet (using Quimb library) for tensor network based simulations. At present, cutensornet backend works only for GPUs whereas qutensornet for CPUs.  The backend can be set using the following command line.
+
+To use cuQuantum library, cutensornet can be specified as follows::
 
-.. testcode::
-   qibo.set_backend(backend="qibotn", platform="cutensornet", runcard=computation_settings)
-..
+   qibo.set_backend(
+      backend="qibotn", platform="cutensornet", runcard=computation_settings
+   )
 
-and for Quimb library
+Similarly, to use Quimb library, qutensornet can be set as follows::
 
-.. testcode::
    qibo.set_backend(
-       backend="qibotn", platform="QuimbBackend", runcard=computation_settings
+       backend="qibotn", platform="qutensornet", runcard=computation_settings
    )
-..
 
 Setting the runcard
 """""""""""""""""""
-Basic structure of runcard is
 
-.. testcode::
+The basic structure of the runcard is as follows::
+
    computation_settings = {
        "MPI_enabled": False,
        "MPS_enabled": False,
@@ -32,21 +33,44 @@ Basic structure of runcard is
            "pauli_string_pattern": "IXZ",
        },
    }
-..
+
+
+**MPI_enabled:** Setting this option *True* results in parallel execution of circuit using MPI (Message Passing Interface). At present, only works for cutensornet platform.
+
+**MPS_enabled:** This option is set *True* for Matrix Product State (MPS) based calculations where as general tensor network structure is used for *False* value.
+
+**NCCL_enabled:** This is set *True* for cutensoret interface for further acceleration while using Nvidia Collective Communication Library (NCCL).
+
+**expectation_enabled:** This option is set *True* while calculating expecation value of the circuit. Observable whose expectation value is to be calculated is passed as a string in the dict format as {"pauli_string_pattern": "observable"}. When the option is set *False*, the dense vector state of the circuit is calculated.
+
 
 Basic example
 """""""""""""
 
-.. testcode::
-   # Construct the circuit
+The following is a basic example to execute a two qubit circuit and print the final state in dense vector form using quimb backend::
+
+   # Set the quimb backend
+   qibo.set_backend(
+       backend="qibotn", platform="qutensornet", runcard=computation_settings
+   )
+
+   # Set the runcard
+   computation_settings = {
+       "MPI_enabled": False,
+       "MPS_enabled": False,
+       "NCCL_enabled": False,
+       "expectation_enabled": False,
+   }
+
+   # Construct the circuit with two qubits
    c = Circuit(2)
-   # Add some gates
+
+   # Apply Hadamard gates on first and second qubit
    c.add(gates.H(0))
    c.add(gates.H(1))
 
    # Execute the circuit and obtain the final state
    result = c()
 
+   # Print the final state
    print(result.state())
-
-..

doc/source/index.rst

@@ -25,8 +25,8 @@ The supported HPC configurations are:
 
 Currently, the supported tensor network libraries are:
 
-- [cuQuantum](https://github.com/NVIDIA/cuQuantum), an NVIDIA SDK of optimized libraries and tools for accelerating quantum computing workflows.
-- [quimb](https://quimb.readthedocs.io/en/latest/), an easy but fast python library for ‘quantum information many-body’ calculations, focusing primarily on tensor networks.
+- `cuQuantum <https://github.com/NVIDIA/cuQuantum>`_, an NVIDIA SDK of optimized libraries and tools for accelerating quantum computing workflows.
+- `quimb <https://quimb.readthedocs.io/en/latest/>`_, an easy but fast python library for ‘quantum information many-body’ calculations, focusing primarily on tensor networks.
 
 How to Use the Documentation
 ============================
@@ -50,10 +50,10 @@ Contents
    getting-started/index
 
 .. toctree::
-    :maxdepth: 2
+    :maxdepth: 1
     :caption: Main documentation
 
-    api-reference/modules
+    api-reference/qibotn
     Developer guides <https://qibo.science/qibo/stable/developer-guides/index.html>
 
 .. toctree::
@@ -64,6 +64,9 @@ Contents
     Qibolab docs <https://qibo.science/qibolab/stable/>
     Qibocal docs <https://qibo.science/qibocal/stable/>
     Qibosoq docs <https://qibo.science/qibosoq/stable/>
+    Qibochem docs <https://qibo.science/qibochem/stable/>
+    Qibotn docs <https://qibo.science/qibotn/stable/>
+    Qibo-cloud-backends docs <https://qibo.science/qibo-cloud-backends/stable/>
 
 Indices and tables
 ==================

src/qibotn/backends/cutensornet.py

@@ -18,6 +18,7 @@
 
 class CuTensorNet(NumpyBackend):  # pragma: no cover
     # CI does not test for GPU
+    """Creates CuQuantum backend for QiboTN."""
 
     def __init__(self, runcard):
         super().__init__()
@@ -92,6 +93,14 @@ def set_precision(self, precision):
             super().set_precision(precision)
 
     def cuda_type(self, dtype="complex64"):
+        """Get CUDA Type.
+
+        Parameters:
+            dtype (str, optional): Either single ("complex64") or double (complex128) precision. Defaults to "complex64".
+
+        Returns:
+            CUDA Type: tuple of cuquantum.cudaDataType and cuquantum.ComputeType
+        """
         if dtype in CUDA_TYPES:
             return CUDA_TYPES[dtype]
         else:
@@ -100,15 +109,15 @@ def cuda_type(self, dtype="complex64"):
     def execute_circuit(
         self, circuit, initial_state=None, nshots=None, return_array=False
     ):  # pragma: no cover
-        """Executes a quantum circuit.
+        """Executes a quantum circuit using selected TN backend.
 
-        Args:
+        Parameters:
             circuit (:class:`qibo.models.circuit.Circuit`): Circuit to execute.
             initial_state (:class:`qibo.models.circuit.Circuit`): Circuit to prepare the initial state.
                 If ``None`` the default ``|00...0>`` state is used.
 
         Returns:
-            xxx.
+            QuantumState or numpy.ndarray: If `return_array` is False, returns a QuantumState object representing the quantum state. If `return_array` is True, returns a numpy array representing the quantum state.
         """
 
         import qibotn.eval as eval

src/qibotn/backends/quimb.py

@@ -59,7 +59,7 @@ def execute_circuit(
                 If ``None`` the default ``|00...0>`` state is used.
 
         Returns:
-            xxx.
+            QuantumState or numpy.ndarray: If `return_array` is False, returns a QuantumState object representing the quantum state. If `return_array` is True, returns a numpy array representing the quantum state.
         """
 
         import qibotn.eval_qu as eval

src/qibotn/circuit_convertor.py

@@ -26,6 +26,12 @@ def __init__(self, circuit, dtype="complex128"):
         self.circuit = circuit
 
     def state_vector_operands(self):
+        """Create the operands for dense vector computation in the interleave
+        format.
+
+        Returns:
+            Operands for the contraction in the interleave format.
+        """
         input_bitstring = "0" * len(self.active_qubits)
 
         input_operands = self._get_bitstring_tensors(input_bitstring)
@@ -79,11 +85,25 @@ def _parse_gates_to_mode_labels_operands(
         return mode_labels, operands
 
     def op_shape_from_qubits(self, nqubits):
-        """Modify tensor to cuQuantum shape (qubit_states,input_output) *
-        qubits_involved."""
+        """Modify tensor to cuQuantum shape.
+
+        Parameters:
+            nqubits (int): The number of qubits in quantum circuit.
+
+        Returns:
+            (qubit_states,input_output) * nqubits
+        """
         return (2, 2) * nqubits
 
     def init_intermediate_circuit(self, circuit):
+        """Initialize the intermediate circuit representation.
+
+        This method initializes the intermediate circuit representation by extracting gate matrices and qubit IDs
+        from the given quantum circuit.
+
+        Parameters:
+            circuit (object): The quantum circuit object.
+        """
         self.gate_tensors = []
         gates_qubits = []
 
@@ -105,13 +125,30 @@ def init_intermediate_circuit(self, circuit):
         self.active_qubits = np.unique(gates_qubits)
 
     def init_basis_map(self, backend, dtype):
+        """Initialize the basis map for the quantum circuit.
+
+        This method initializes a basis map for the quantum circuit, which maps binary
+        strings representing qubit states to their corresponding quantum state vectors.
+
+        Parameters:
+            backend (object): The backend object providing the array conversion method.
+            dtype (object): The data type for the quantum state vectors.
+        """
         asarray = backend.asarray
         state_0 = asarray([1, 0], dtype=dtype)
         state_1 = asarray([0, 1], dtype=dtype)
 
         self.basis_map = {"0": state_0, "1": state_1}
 
     def init_inverse_circuit(self, circuit):
+        """Initialize the inverse circuit representation.
+
+        This method initializes the inverse circuit representation by extracting gate matrices and qubit IDs
+        from the given quantum circuit.
+
+        Parameters:
+            circuit (object): The quantum circuit object.
+        """
         self.gate_tensors_inverse = []
         gates_qubits_inverse = []
 
@@ -135,7 +172,7 @@ def init_inverse_circuit(self, circuit):
     def get_pauli_gates(self, pauli_map, dtype="complex128", backend=cp):
         """Populate the gates for all pauli operators.
 
-        Args:
+        Parameters:
             pauli_map: A dictionary mapping qubits to pauli operators.
             dtype: Data type for the tensor operands.
             backend: The package the tensor operands belong to.
@@ -159,6 +196,15 @@ def get_pauli_gates(self, pauli_map, dtype="complex128", backend=cp):
         return gates
 
     def expectation_operands(self, pauli_string):
+        """Create the operands for pauli string expectation computation in the
+        interleave format.
+
+        Parameters:
+            pauli_string: A string representating the list of pauli gates.
+
+        Returns:
+            Operands for the contraction in the interleave format.
+        """
         input_bitstring = "0" * self.circuit.nqubits
 
         input_operands = self._get_bitstring_tensors(input_bitstring)

src/qibotn/circuit_to_mps.py

@@ -7,6 +7,15 @@
 
 
 class QiboCircuitToMPS:
+    """A helper class to convert Qibo circuit to MPS.
+
+    Parameters:
+        circ_qibo: The quantum circuit object.
+        gate_algo(dict): Dictionary for SVD and QR settings.
+        datatype (str): Either single ("complex64") or double (complex128) precision.
+        rand_seed(int): Seed for random number generator.
+    """
+
     def __init__(
         self,
         circ_qibo,