Adaptive Genetic Algorithms for Pulse Level Quantum Error Mitigation

A Genetic Algorithm proposal for Optimizing Deutsch-Jozsa and Grover Circuits Under Noise

---

Table of Contents

1. Overview
2. Features
3. Project Structure
4. Installation
5. Usage
   • Command-Line Arguments
   • Running the Project
   • Viewing Results
6. Algorithms and Noise Model
7. Genetic Algorithm Details
8. Diversity Control
9. Testing
10. Results and Figures
11. Workflow
12. Example Output
13. FAQ
14. Citation
15. Contributing
16. License
17. Contact

---

Overview

This project implements a genetic algorithm to optimize Deutsch-Jozsa and Grover quantum circuits at the pulse level under realistic noise conditions. The aim is to maximize fidelity of the final quantum state by tweaking gate parameters. This code was developed for research purposes and supports pulse-level error mitigation in noisy quantum environments.

Technologies:

• QuTiP for quantum simulations.
• QuTiP-QIP for quantum information processing and circuit modeling.
• DEAP for the genetic algorithm.
• SCOOP for parallelization of the genetic algorithm.
• Python 3.12 for development.

---

Features

• Quantum Circuit Simulation: Implements Deutsch-Jozsa and Grover algorithms.
• Genetic Algorithm Optimization: Optimizes quantum gate parameters to mitigate noise.
• Noise Model: Realistic noise models (T1, T2, bit-flip, and phase-flip).
• Parallel Execution: Accelerated using SCOOP for multi-core parallelization.
• Visualization: Generates plots for pulse sequences, fidelities, and parameter correlations.
• Reproducible Results: Stores results in timestamped directories for detailed analysis.

---

Project Structure

quantum_optimization/
├── circuits/                     # Quantum circuit definitions
│   ├── __init__.py
│   ├── deutsch_jozsa_circuit.py   # Deutsch-Jozsa circuit implementation
│   ├── grover_circuit.py          # Grover circuit implementation       
├── output_circuits/
│   ├── (Long Runs)               # Results for extended runs
│   ├── (Short Runs)              # Results for short runs
├── output_experiments/
│   └── executionlogfiles.log     # Logs for experiment executions
├── src/                          # Source code for core functionality
│   ├── csv_logger.py
│   ├── evaluator.py
│   ├── gate_config.py
│   ├── genetic_optimizer.py
│   ├── noise_model.py
│   ├── quantum_circuit.py
│   ├── quantum_utils.py
│   └── visualizer.py
├── tests/                        # Unit tests
│   ├── test_evaluator.py
│   ├── test_genetic_optimizer.py
│   ├── test_noise_model.py
│   ├── test_quantum_circuit.py
│   └── test_visualizer.py
├── .github/                      # CI/CD workflows
│   └── workflows/
│       └── test.yml
├── requirements.txt              # Python dependencies
├── main.py                       # Main script
└── README.md                     # Project documentation

---

Installation

Prerequisites

• Python 3.12 or later.
• Git installed on your machine.

Steps

1. Clone the repository:

   git clone https://github.com/Universidad-Cenfotec/Adaptive-Genetic-Algorithms-for-Pulse-Level-Quantum-Error-Mitigation.git

2. Create and activate a virtual environment:

   python3 -m venv venv
   source venv/bin/activate    # On Windows: venv\Scripts\activate

3. Install dependencies:

   pip install -r requirements.txt

---

Usage

Command-Line Arguments

Argument	Description	Example
--algorithm	Specify which circuit to run (grover or deutsch-jozsa).	--algorithm grover
--num_qubits	Set the number of qubits for the circuit.	--num_qubits 4
--population_size	Set the population size for the genetic algorithm.	--population_size 50
--generations	Set the number of generations for optimization.	--generations 100
--t1	T1 relaxation time constant (noise model).	--t1 50.0
--t2	T2 dephasing time constant (noise model).	--t2 30.0
--bit_flip_prob	Bit-flip error probability.	--bit_flip_prob 0.02
--phase_flip_prob	Phase-flip error probability.	--phase_flip_prob 0.02

Running the Project

Run the project with default parameters:

python main.py --algorithm deutsch-jozsa

Run the project with SCOOP for parallelization:

python -m scoop -n 6 main.py --algorithm deutsch-jozsa --num_generations 20 --population_size 30 --t1 50.0 --t2 30.0 --bit_flip_prob 0.02 --phase_flip_prob 0.02 --num_qubits 4

Specify advanced configuration:

python -m scoop -n 8 main.py \
    --algorithm grover \
    --num_qubits 3 \
    --population_size 100 \
    --generations 200 \
    --t1 60.0 \
    --t2 40.0 \
    --bit_flip_prob 0.01 \
    --phase_flip_prob 0.01

Viewing Results

Results are stored in output_circuits/, organized by timestamped folders. Typical files include:

• fidelity_evolution.png: Fidelity over generations.
• pulses_optimized.png: Visualized optimized pulse shapes.
• results.csv: Numerical logs for analysis.
• correlation_matrix.png: Correlation matrix for optimized parameters.
• histogram_fidelities.png: Distribution of fidelity values over generations.
• histogram_parameters.png: Histograms for optimized gate parameters (e.g., CNOT, SNOT, X gates).
• parameter_evolution.png: Evolution of individual gate parameters over generations.
• fidelity_comparison.csv: Comparison of fidelities before and after optimization.
• summary_optimization.csv: Summary statistics for optimized runs.
• summary_no_optimization.csv: Summary statistics for runs without optimization.

---

Algorithms and Noise Model

1. Deutsch-Jozsa Algorithm:

   • Determines if a given function ( f(x) ) is constant or balanced in a single query.

2. Grover's Algorithm:

   • Searches an unstructured database of ( N ) items in ( O(\sqrt{N}) ) queries.

Noise Model

• T1 Relaxation: Simulates energy loss from qubits.
• T2 Dephasing: Models phase decoherence.
• Bit-Flip & Phase-Flip: Introduces random discrete errors.

---

Genetic Algorithm Details

The genetic algorithm optimizes pulse parameters:

1. Initialization: Randomly generates an initial population.
2. Evaluation: Computes fidelity for each individual.
3. Selection & Crossover: Combines top-performing individuals.
4. Mutation: Applies small random changes.
5. Elitism: Retains best solutions across generations.
6. Diversity Control: To ensure the genetic algorithm maintains a diverse population and avoids premature convergence.

---

Testing

Run unit tests to verify functionality:

python -m unittest discover -s tests

---

Workflow

Below is a diagram summarizing the workflow of this project:

1. Initialize genetic algorithm with random population.
2. Simulate quantum circuit under noisy conditions.
3. Evaluate fidelity and fitness of each individual.
4. Perform selection, crossover, and mutation to generate a new population.
5. Repeat until desired fidelity is achieved or maximum generations reached.
6. Store results and generate visualizations.

---

Below are enhanced visualizations and results generated during the optimization process, offering insights into the performance of the genetic algorithm and the impact of noise mitigation:

1. Fidelity Evolution Over Generations\ This graph demonstrates how the fidelity improves over successive generations, showcasing the effectiveness of the genetic algorithm in optimizing gate parameters under noise conditions.\

   

2. Optimized Pulse Sequence\ Visual representation of the optimized pulse sequence for the Deutsch-Jozsa circuit after applying the genetic algorithm. Notice the distinct modulation patterns designed to counteract noise.\

   

3. Parameter Correlation Matrix\ A heatmap illustrating the correlation between optimized parameters, providing insights into their interdependence and the genetic algorithm’s exploration of the parameter space.\

   

4. Distribution of Fidelity Values\ Histogram showing the distribution of fidelity values across individuals in the population during the final generation, reflecting the diversity and robustness of the optimization.\

   

5. Gate Parameter Evolution\ A dynamic plot tracking the evolution of key gate parameters (e.g., CNOT, SNOT) across generations, highlighting how the genetic algorithm fine-tunes each parameter.\

   

These results collectively illustrate the power of pulse-level optimization in mitigating quantum noise, underscoring the potential of genetic algorithms in quantum computing research.

---

FAQ

How do I modify noise parameters?

Change T1, T2, and error probabilities in noise_model.py or pass them via command-line arguments.

What hardware can run this?

Designed for Python 3.12, runs efficiently on any modern laptop with >8GB RAM.

---

Citation

If you use this code for academic purposes, please cite:

@misc{aguilarcalvo2025adaptivegeneticalgorithmspulselevel,
      title={Adaptive Genetic Algorithms for Pulse-Level Quantum Error Mitigation}, 
      author={William Aguilar-Calvo and Santiago Núñez-Corrales},
      year={2025},
      eprint={2501.14007},
      archivePrefix={arXiv},
      primaryClass={quant-ph},
      url={https://arxiv.org/abs/2501.14007}, 
}

---

License

Distributed under the MIT License. See LICENSE for more details.

---

Contact

William Aguilar-Calvo
GitHub: @thewill-i-am
Email: wil-20-01@live.com