add documentation

Author: rochisha0

doc/guide/guide-control.rst

@@ -310,6 +310,102 @@ Eventually, the optimization for a desired `fid_err_targ` can be started by call
     },
   )
 
+The Genetic Algorithm (GA)
+==========================
+
+The Genetic Algorithm (GA) is a global optimization technique inspired by natural selection. 
+Unlike gradient-based methods like GRAPE or CRAB, GA explores the solution space stochastically, 
+making it robust against local minima and suitable for problems with non-differentiable or noisy objectives.
+
+In QuTiP, the GA-based optimizer evolves a population of candidate control pulses across multiple 
+generations to minimize the infidelity between the system's final and target states.
+
+The GA optimization consists of the following components:
+
+**Population**:
+    A collection of candidate solutions (chromosomes), where each chromosome encodes a full set 
+    of control amplitudes over time for the given control Hamiltonians.
+
+**Fitness Function**:
+    The fitness of each candidate is evaluated using a fidelity-based measure, such as:
+
+    - **PSU (Projective State Overlap)**: 
+      :math:`1 - |\langle \psi_{\text{target}} | \psi_{\text{final}} \rangle|`
+    - **TRACEDIFF**: 
+      Trace distance between final and target density matrices.
+
+**Genetic Operations**:
+
+- **Selection**:
+  A subset of the best-performing candidates (based on fitness) are chosen to survive.
+  
+- **Crossover (Mating)**:
+  New candidates are generated by combining genes from selected parents using arithmetic crossover.
+  
+- **Mutation**:
+  Random perturbations are added to the new candidates' genes to maintain diversity and escape local minima.
+
+This process continues until either a target fidelity error is reached or a fixed number of generations 
+have passed without improvement (stagnation criterion).
+
+Each generation represents a full evaluation of the population, making the method inherently parallelizable 
+and effective in high-dimensional control landscapes.
+
+In QuTiP, the GA optimization is implemented via the ``_GENETIC`` class, and can be invoked using the 
+standard ``optimize_pulses`` interface by setting the algorithm to ``"GENETIC"``.
+
+Optimal Quantum Control in QuTiP (Genetic Algorithm)
+====================================================
+
+Defining a control problem in QuTiP using the Genetic Algorithm follows the same pattern as with other algorithms.
+
+.. code-block:: python
+
+    import qutip as qt
+    import qutip_qoc as qoc
+    import numpy as np
+
+    # state to state transfer
+    initial = qt.basis(2, 0)
+    target = qt.basis(2, 1)
+
+    # define the drift and control Hamiltonians
+    drift = qt.sigmaz()
+    controls = [qt.sigmax(), qt.sigmay()]
+
+    H = [drift] + controls
+
+    # define the objective
+    objective = qoc.Objective(initial, H, target)
+
+    # discretized time grid (e.g., 100 steps over 10 units of time)
+    tlist = np.linspace(0, 10, 100)
+
+    # define control parameter bounds (same for all controls in GA)
+    control_parameters = {
+        "p": {"bounds": [(-1.0, 1.0)]}
+    }
+
+    # set genetic algorithm hyperparameters
+    algorithm_kwargs = {
+        "alg": "GENETIC",
+        "population_size": 50,
+        "generations": 100,
+        "mutation_rate": 0.2,
+        "fid_err_targ": 1e-3,
+    }
+
+    # run the optimization
+    result = qoc.optimize_pulses(
+        objectives=[objective],
+        control_parameters=control_parameters,
+        tlist=tlist,
+        algorithm_kwargs=algorithm_kwargs,
+    )
+
+    print("Final infidelity:", result.infidelity)
+    print("Best control parameters:", result.optimized_params)
+
 .. TODO: add examples
 
 Examples for Liouvillian dynamics and multi-objective optimization will follow soon.

src/qutip_qoc/_genetic.py

@@ -4,6 +4,14 @@
 from qutip_qoc.result import Result
 
 class _GENETIC:
+    """
+    Genetic Algorithm-based optimizer for quantum control problems.
+
+    This class implements a global optimization routine using a Genetic Algorithm
+    to optimize control pulses that drive a quantum system from an initial state 
+    to a target state (or unitary). 
+    """
+
     def __init__(
         self,
         objectives,