dbac 0.1.0__tar.gz

dbac-0.1.0/.github/workflows/docs.yml

@@ -0,0 +1,38 @@
+name: docs
+on:
+  push:
+    branches: [main]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+concurrency:
+  group: pages
+  cancel-in-progress: true
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - run: pip install -e ".[docs]"
+      - run: make -C docs html
+      - uses: actions/upload-pages-artifact@v3
+        with:
+          path: docs/_build/html
+
+  deploy:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    steps:
+      - id: deployment
+        uses: actions/deploy-pages@v4

dbac-0.1.0/.github/workflows/publish.yml

@@ -0,0 +1,43 @@
+name: Publish to PyPI
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+
+      - name: Build sdist and wheel
+        run: |
+          python -m pip install --upgrade build twine
+          python -m build
+          python -m twine check dist/*
+
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment:
+      name: pypi
+      url: https://pypi.org/project/dbac/
+    permissions:
+      id-token: write  # for PyPI trusted publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+      - uses: pypa/gh-action-pypi-publish@release/v1

dbac-0.1.0/.gitignore

@@ -0,0 +1,9 @@
+__pycache__/
+*.pyc
+.ipynb_checkpoints/
+.venv/
+.history/
+dist/
+build/
+*.egg-info/
+_build/

dbac-0.1.0/CITATION.cff

@@ -0,0 +1,20 @@
+cff-version: 1.2.0
+message: If you use this software, please cite the accompanying paper.
+title: dbac
+type: software
+repository-code: https://github.com/khanhuyengiang/dbac
+preferred-citation:
+  type: article
+  title: Double-Bracket Algorithmic Cooling
+  authors:
+    - {family-names: Alghadeer, given-names: Mohammed}
+    - {family-names: Giang, given-names: Khanh Uyen}
+    - {family-names: Cao, given-names: Shuxiang}
+    - {family-names: Fasciati, given-names: Simone D.}
+    - {family-names: Piscitelli, given-names: Michele}
+    - {family-names: Ng, given-names: Nelly}
+    - {family-names: Leek, given-names: Peter J.}
+    - {family-names: Gluza, given-names: Marek}
+    - {family-names: Bakr, given-names: Mustafa}
+  journal: arXiv preprint arXiv:2510.00302
+  year: 2025

dbac-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.5
+Name: dbac
+Version: 0.1.0
+Summary: Double-Bracket Algorithmic Cooling: simulation, DME, HBAC baseline and plotting code.
+Project-URL: Homepage, https://github.com/khanhuyengiang/dbac
+Project-URL: Paper, https://arxiv.org/abs/2510.00302
+Author-email: Khanh Uyen Giang <khanh.giang@tu-darmstadt.de>
+Keywords: QITE,algorithmic cooling,density matrix exponentiation,double-bracket flow,quantum
+Classifier: Intended Audience :: Science/Research
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering :: Physics
+Requires-Python: >=3.10
+Requires-Dist: matplotlib>=3.9
+Requires-Dist: numpy>=1.26
+Requires-Dist: qibo>=0.3
+Requires-Dist: qutip>=5.0
+Requires-Dist: scipy>=1.11
+Provides-Extra: docs
+Requires-Dist: furo; extra == 'docs'
+Requires-Dist: myst-nb>=1.0; extra == 'docs'
+Requires-Dist: sphinx>=7.3; extra == 'docs'
+Provides-Extra: notebooks
+Requires-Dist: jupyter>=1.1; extra == 'notebooks'
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == 'test'
+Description-Content-Type: text/markdown
+
+# Double-Bracket Algorithmic Cooling (dbac) package
+
+Code accompanying the paper **[Double-Bracket Algorithmic Cooling](https://arxiv.org/abs/2510.00302)**
+(M. Alghadeer, K. U. Giang, S. Cao, S. D. Fasciati, M. Piscitelli, N. Ng, P. J. Leek,
+M. Gluza, M. Bakr).
+
+## Background
+
+Algorithmic cooling lowers the entropy of a qubit using only local operations and a
+"colder" ancilla, and is the basis of established techniques like heat-bath algorithmic
+cooling (HBAC). This paper introduces **double-bracket algorithmic cooling (DBAC)**, which
+instead removes *coherence* from an already-pure qubit state, extending algorithmic
+cooling from a thermodynamic (entropy) notion of cooling to a genuinely quantum one.
+
+DBAC simulates quantum imaginary-time evolution (QITE) by recursively synthesizing
+unitaries that implement Riemannian steepest-descent ("double-bracket") flows towards the
+ground state, one small step at a time. Each step needs an extra copy of the current state
+to act as a **quantum instruction**: that copy is consumed via **density matrix
+exponentiation (DME)**, a protocol that uses repeated partial SWAPs to approximate the
+unitary $e^{-it\rho}$ generated by a state $\rho$, without ever synthesizing $\rho$ as a
+gate. Because the resulting circuit does not depend on the input state and needs no
+measurements or feedback, cooling performance is governed entirely by *how many* quantum
+instructions (copies of the state) are available -- a trade-off the paper relates to the
+Nernst principle ("cooling to absolute zero costs infinite resources").
+
+## Repository layout
+
+```
+src/dbac/          Physics and numerics: DME, DB-QITE/GCI recursion, HBAC, state utilities.
+src/dbac/plotting/ All plotting code, factored out of the physics and shared across scripts/notebooks.
+scripts/           The three DBAC scripts (computation + plotting), runnable standalone.
+notebooks/ Narrated walkthroughs that call scripts/ and dbac.plotting and explain the physics.
+figures/           All generated figures (PDF).
+docs/              Sphinx documentation (`pip install -e ".[docs]" && make -C docs html`).
+```
+
+### `src/dbac/` -- physics and numerics (no plotting)
+
+| File | Contents |
+|---|---|
+| `dme.py` | Density matrix exponentiation: exact (`dme_expm`), SWAP+numpy (`dme_channel`), analytical equivalent (`dme_channel_equivalent`), and qibo-circuit (`dme_qibo`) implementations. |
+| `dbqite.py` | A single-qubit DB-QITE step built on top of Trotterized DME (`QITE_GCI_dme`) or on the exact unitary (`ideal_DME`). |
+| `gci.py` | `GCI`: runs and tracks a DB-QITE/"group commutator iteration" recursion (energy, fidelity, states) for a fixed number of steps or by greedily picking the best step size at each round. |
+| `hbac.py` | Heat-bath algorithmic cooling (reset + compress), the classical baseline DBAC is compared against. |
+| `utils.py` | Shared helpers: fidelity with the ground state, depolarizing noise, thermal states, the $R_X(\theta)$ initial-state sweep used throughout. |
+
+### `src/dbac/plotting/` -- all plotting
+
+| File | Contents |
+|---|---|
+| `style.py` | Shared journal figure sizes and matplotlib `rcParams`. |
+| `bloch.py` | Bloch-sphere rendering of single-qubit states and DB-QITE recursion trajectories. |
+| `ptm.py` | Pauli-transfer-matrix heatmaps and a hue/size process-matrix plot. |
+| `gci.py` | Energy/fidelity vs. evolution-duration plots for `GCI.execute_gci` output. |
+| `cooling.py` | The cooling-performance figures: fidelity-fidelity plots, energy-vs-$\theta$ plots, grid layouts, and the ideal-DME summary figure. |
+| `dme.py` | DME-channel-implementation benchmark plots. |
+
+### `scripts/` -- one script per result, runnable from the command line
+
+The three DBAC scripts do the computation (calling into `dbac`), calls `dbac.plotting` to
+plot it, and saves the resulting figures to `figures/`:
+
+```bash
+pip install -e .
+python scripts/sup_figure_S2.py      # DME channel implementation benchmark
+python scripts/sup_figure_S4.py       # DBAC with ideal (M -> infinity) DME, sweep over k
+python scripts/figure_4.py           # Main result: cooling vs. number of quantum instructions (Fig. 4)
+python scripts/sup_figure_S5.py       # Bloch-sphere illustration of the DBAC recursion
+```
+
+### `notebooks/` -- narrated walkthroughs
+
+| Notebook | Figure(s) | What it shows |
+|---|---|---|
+| [`dme_ptm_plot.ipynb`](notebooks/dme_ptm_plot.ipynb) | `ptm_*.pdf` | Pauli-transfer-matrix view of the ideal $ZZ$ interaction, the DME unitary, and the two hardware circuits (A, B). |
+| [`hbac.ipynb`](notebooks/hbac.ipynb) | `hbac_3_qubits.pdf` | Heat-bath algorithmic cooling baseline on a 3-qubit chain, pure vs. depolarized input. |
+| [`sup_figure_S4.ipynb`](notebooks/sup_figure_S4.ipynb) | `S4_QITE_ideal_DME_merged.pdf` (Fig. 7) | DBAC in the ideal-DME limit, sweeping the recursion depth $k$. |
+| [`docs/index.ipynb`](docs/index.ipynb) | `F4_*.pdf` (Fig. 4) | **Main result** (also the front page of the docs): Trotterized-DME DBAC cooling performance vs. number of quantum instructions, compared to hardware experiment data. |
+
+`notebooks/not_in_use/` holds earlier exploratory notebooks kept for reference;
+they are not part of the maintained code path.
+
+## Setup
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[notebooks]"
+jupyter notebook notebooks/
+```
+
+Figures that use LaTeX-rendered labels require a local LaTeX installation (`matplotlib`'s
+`text.usetex`); without one, either install `texlive` or disable it via
+`dbac.plotting.use_paper_style(use_tex=False)`.
+
+## Citation
+
+If you use this code, please cite:
+
+```bibtex
+@article{alghadeer2025dbac,
+  title   = {Double-Bracket Algorithmic Cooling},
+  author  = {Alghadeer, Mohammed and Giang, Khanh Uyen and Cao, Shuxiang and
+             Fasciati, Simone D. and Piscitelli, Michele and Ng, Nelly and
+             Leek, Peter J. and Gluza, Marek and Bakr, Mustafa},
+  journal = {arXiv preprint arXiv:2510.00302},
+  year    = {2025}
+}
+```
+
+Notebooks only save their plots when `SAVE_PLOTS = True` in [`notebooks/config.py`](notebooks/config.py) (off by default); PDFs then go to `figures/`.

dbac-0.1.0/README.md

@@ -0,0 +1,111 @@
+# Double-Bracket Algorithmic Cooling (dbac) package
+
+Code accompanying the paper **[Double-Bracket Algorithmic Cooling](https://arxiv.org/abs/2510.00302)**
+(M. Alghadeer, K. U. Giang, S. Cao, S. D. Fasciati, M. Piscitelli, N. Ng, P. J. Leek,
+M. Gluza, M. Bakr).
+
+## Background
+
+Algorithmic cooling lowers the entropy of a qubit using only local operations and a
+"colder" ancilla, and is the basis of established techniques like heat-bath algorithmic
+cooling (HBAC). This paper introduces **double-bracket algorithmic cooling (DBAC)**, which
+instead removes *coherence* from an already-pure qubit state, extending algorithmic
+cooling from a thermodynamic (entropy) notion of cooling to a genuinely quantum one.
+
+DBAC simulates quantum imaginary-time evolution (QITE) by recursively synthesizing
+unitaries that implement Riemannian steepest-descent ("double-bracket") flows towards the
+ground state, one small step at a time. Each step needs an extra copy of the current state
+to act as a **quantum instruction**: that copy is consumed via **density matrix
+exponentiation (DME)**, a protocol that uses repeated partial SWAPs to approximate the
+unitary $e^{-it\rho}$ generated by a state $\rho$, without ever synthesizing $\rho$ as a
+gate. Because the resulting circuit does not depend on the input state and needs no
+measurements or feedback, cooling performance is governed entirely by *how many* quantum
+instructions (copies of the state) are available -- a trade-off the paper relates to the
+Nernst principle ("cooling to absolute zero costs infinite resources").
+
+## Repository layout
+
+```
+src/dbac/          Physics and numerics: DME, DB-QITE/GCI recursion, HBAC, state utilities.
+src/dbac/plotting/ All plotting code, factored out of the physics and shared across scripts/notebooks.
+scripts/           The three DBAC scripts (computation + plotting), runnable standalone.
+notebooks/ Narrated walkthroughs that call scripts/ and dbac.plotting and explain the physics.
+figures/           All generated figures (PDF).
+docs/              Sphinx documentation (`pip install -e ".[docs]" && make -C docs html`).
+```
+
+### `src/dbac/` -- physics and numerics (no plotting)
+
+| File | Contents |
+|---|---|
+| `dme.py` | Density matrix exponentiation: exact (`dme_expm`), SWAP+numpy (`dme_channel`), analytical equivalent (`dme_channel_equivalent`), and qibo-circuit (`dme_qibo`) implementations. |
+| `dbqite.py` | A single-qubit DB-QITE step built on top of Trotterized DME (`QITE_GCI_dme`) or on the exact unitary (`ideal_DME`). |
+| `gci.py` | `GCI`: runs and tracks a DB-QITE/"group commutator iteration" recursion (energy, fidelity, states) for a fixed number of steps or by greedily picking the best step size at each round. |
+| `hbac.py` | Heat-bath algorithmic cooling (reset + compress), the classical baseline DBAC is compared against. |
+| `utils.py` | Shared helpers: fidelity with the ground state, depolarizing noise, thermal states, the $R_X(\theta)$ initial-state sweep used throughout. |
+
+### `src/dbac/plotting/` -- all plotting
+
+| File | Contents |
+|---|---|
+| `style.py` | Shared journal figure sizes and matplotlib `rcParams`. |
+| `bloch.py` | Bloch-sphere rendering of single-qubit states and DB-QITE recursion trajectories. |
+| `ptm.py` | Pauli-transfer-matrix heatmaps and a hue/size process-matrix plot. |
+| `gci.py` | Energy/fidelity vs. evolution-duration plots for `GCI.execute_gci` output. |
+| `cooling.py` | The cooling-performance figures: fidelity-fidelity plots, energy-vs-$\theta$ plots, grid layouts, and the ideal-DME summary figure. |
+| `dme.py` | DME-channel-implementation benchmark plots. |
+
+### `scripts/` -- one script per result, runnable from the command line
+
+The three DBAC scripts do the computation (calling into `dbac`), calls `dbac.plotting` to
+plot it, and saves the resulting figures to `figures/`:
+
+```bash
+pip install -e .
+python scripts/sup_figure_S2.py      # DME channel implementation benchmark
+python scripts/sup_figure_S4.py       # DBAC with ideal (M -> infinity) DME, sweep over k
+python scripts/figure_4.py           # Main result: cooling vs. number of quantum instructions (Fig. 4)
+python scripts/sup_figure_S5.py       # Bloch-sphere illustration of the DBAC recursion
+```
+
+### `notebooks/` -- narrated walkthroughs
+
+| Notebook | Figure(s) | What it shows |
+|---|---|---|
+| [`dme_ptm_plot.ipynb`](notebooks/dme_ptm_plot.ipynb) | `ptm_*.pdf` | Pauli-transfer-matrix view of the ideal $ZZ$ interaction, the DME unitary, and the two hardware circuits (A, B). |
+| [`hbac.ipynb`](notebooks/hbac.ipynb) | `hbac_3_qubits.pdf` | Heat-bath algorithmic cooling baseline on a 3-qubit chain, pure vs. depolarized input. |
+| [`sup_figure_S4.ipynb`](notebooks/sup_figure_S4.ipynb) | `S4_QITE_ideal_DME_merged.pdf` (Fig. 7) | DBAC in the ideal-DME limit, sweeping the recursion depth $k$. |
+| [`docs/index.ipynb`](docs/index.ipynb) | `F4_*.pdf` (Fig. 4) | **Main result** (also the front page of the docs): Trotterized-DME DBAC cooling performance vs. number of quantum instructions, compared to hardware experiment data. |
+
+`notebooks/not_in_use/` holds earlier exploratory notebooks kept for reference;
+they are not part of the maintained code path.
+
+## Setup
+
+```bash
+python3 -m venv .venv
+source .venv/bin/activate
+pip install -e ".[notebooks]"
+jupyter notebook notebooks/
+```
+
+Figures that use LaTeX-rendered labels require a local LaTeX installation (`matplotlib`'s
+`text.usetex`); without one, either install `texlive` or disable it via
+`dbac.plotting.use_paper_style(use_tex=False)`.
+
+## Citation
+
+If you use this code, please cite:
+
+```bibtex
+@article{alghadeer2025dbac,
+  title   = {Double-Bracket Algorithmic Cooling},
+  author  = {Alghadeer, Mohammed and Giang, Khanh Uyen and Cao, Shuxiang and
+             Fasciati, Simone D. and Piscitelli, Michele and Ng, Nelly and
+             Leek, Peter J. and Gluza, Marek and Bakr, Mustafa},
+  journal = {arXiv preprint arXiv:2510.00302},
+  year    = {2025}
+}
+```
+
+Notebooks only save their plots when `SAVE_PLOTS = True` in [`notebooks/config.py`](notebooks/config.py) (off by default); PDFs then go to `figures/`.

dbac-0.1.0/docs/Makefile

@@ -0,0 +1,5 @@
+html:
+	sphinx-build -b html . _build/html
+
+clean:
+	rm -rf _build

dbac-0.1.0/docs/api/dbqite.md

@@ -0,0 +1,63 @@
+# dbac.dbqite
+
+One step of DBAC, called a *DB-QITE step* (double-bracket quantum imaginary-time evolution) in
+the code. A step takes the current state of the data qubit and a duration $s$ and returns a
+colder state:
+
+$$
+\rho \mapsto e^{is\rho'}\,\rho\,e^{-is\rho'}, \qquad \rho' = e^{is\hat H}\rho\, e^{-is\hat H},
+\qquad \hat H = -Z .
+$$
+
+All step functions share the signature `step(psi, s) -> density matrix`, so any of them can be
+handed to `dbac.gci.GCI` to run several steps. They differ only in how $e^{is\rho'}$ is applied.
+
+See [One DBAC step](../guide/dbac-step.md) for a walkthrough with plots.
+
+```{eval-rst}
+.. currentmodule:: dbac.dbqite
+
+.. autosummary::
+
+   QITE_dme_select_M
+   ideal_DME
+   initial_psi
+   QITE_GCI_dme
+   DME
+   H
+   target_energy
+```
+
+## Step functions
+
+```{eval-rst}
+.. autofunction:: QITE_dme_select_M
+
+.. autofunction:: ideal_DME
+
+.. autofunction:: initial_psi
+
+.. autofunction:: QITE_GCI_dme
+```
+
+## DME inside the step
+
+```{eval-rst}
+.. autofunction:: DME
+```
+
+## The Hamiltonian
+
+```{eval-rst}
+.. autodata:: H
+   :no-value:
+
+.. autodata:: eigs
+   :no-value:
+
+.. autodata:: target_energy
+   :no-value:
+
+.. autodata:: H_sh
+   :no-value:
+```

dbac-0.1.0/docs/api/dme.md

@@ -0,0 +1,50 @@
+# dbac.dme
+
+Density matrix exponentiation (DME): applying $e^{it\rho}$ to a data state $\sigma$ using
+copies of $\rho$ instead of knowledge of $\rho$. This is the subroutine inside every DBAC step.
+
+The module offers the same channel four ways, so the implementations can be checked against
+each other. All take `(data, instruction, t, M)`: the data and instruction density matrices, the
+total duration, and the number of Trotter steps (instruction copies used).
+
+See [Density matrix exponentiation](../guide/dme.md) for how DME works and which
+implementation to pick.
+
+:::{note}
+DBAC steps do not call this module: they use `dbac.dbqite.DME`, which takes the arguments in
+the order `(instruction, data, t, M)`.
+:::
+
+```{eval-rst}
+.. currentmodule:: dbac.dme
+
+.. autosummary::
+
+   dme_channel
+   dme_channel_equivalent
+   dme_qibo
+   dme_expm
+   ptrace
+```
+
+## Approximate DME (Trotterized)
+
+```{eval-rst}
+.. autofunction:: dme_channel
+
+.. autofunction:: dme_channel_equivalent
+
+.. autofunction:: dme_qibo
+```
+
+## Exact reference
+
+```{eval-rst}
+.. autofunction:: dme_expm
+```
+
+## Helpers
+
+```{eval-rst}
+.. autofunction:: ptrace
+```

dbac-0.1.0/docs/api/gci.md

@@ -0,0 +1,32 @@
+# dbac.gci
+
+Runs the DBAC recursion. `GCI` (group commutator iteration) applies a step function from
+`dbac.dbqite` again and again, each time to the previous output, and records the energy,
+fidelity and state after every step.
+
+See [Running the recursion](../guide/recursion.md) for both modes of `GCI` and a guide to its
+output.
+
+```{eval-rst}
+.. currentmodule:: dbac.gci
+
+.. autosummary::
+
+   GCI
+   GCI.execute_gci
+   max_excitation
+```
+
+## Running the recursion
+
+```{eval-rst}
+.. autoclass:: GCI
+   :members: execute_gci, compute_moments, fidelity_with_0
+   :member-order: bysource
+```
+
+## Summarizing a cooling curve
+
+```{eval-rst}
+.. autofunction:: max_excitation
+```

dbac-0.1.0/docs/api/hbac.md

@@ -0,0 +1,32 @@
+# dbac.hbac
+
+Heat-bath algorithmic cooling (HBAC), the standard entropy-based protocol, implemented
+minimally so DBAC can be compared with it. Each round resets the last qubit to a thermal state
+and sorts the populations of the joint state; `hbac` runs several rounds and returns the first
+qubit.
+
+See [HBAC baseline](../guide/hbac.md) for how HBAC differs from DBAC and a side-by-side comparison.
+
+```{eval-rst}
+.. currentmodule:: dbac.hbac
+
+.. autosummary::
+
+   hbac
+   refresh_reset_qubit
+   compress_density_matrix
+```
+
+## Running HBAC
+
+```{eval-rst}
+.. autofunction:: hbac
+```
+
+## The two parts of a round
+
+```{eval-rst}
+.. autofunction:: refresh_reset_qubit
+
+.. autofunction:: compress_density_matrix
+```

dbac-0.1.0/docs/api/index.md

@@ -0,0 +1,38 @@
+# API reference
+
+The package has two halves: the physics in `dbac`, and the plotting in `dbac.plotting`. The
+physics modules never import matplotlib.
+
+If you are new to the package, the [guide](../guide/conventions.md) explains each module with
+runnable examples. These pages list every public function and its arguments.
+
+| module | what it is for | guide |
+|---|---|---|
+| [`dbac.utils`](utils.md) | building initial states, fidelity, noise | [States and conventions](../guide/conventions.md) |
+| [`dbac.dme`](dme.md) | density matrix exponentiation, four implementations | [Density matrix exponentiation](../guide/dme.md) |
+| [`dbac.dbqite`](dbqite.md) | one DBAC step, the Hamiltonian | [One DBAC step](../guide/dbac-step.md) |
+| [`dbac.gci`](gci.md) | running several steps, reading the results | [Running the recursion](../guide/recursion.md) |
+| [`dbac.hbac`](hbac.md) | heat-bath algorithmic cooling, for comparison | [HBAC baseline](../guide/hbac.md) |
+| [`dbac.plotting`](plotting.md) | every figure: cooling curves, circuits, Bloch sphere, PTMs | [Plotting](../guide/plotting.md) |
+
+## How the pieces fit together
+
+A typical calculation touches the modules in this order:
+
+1. `dbac.utils.rx_sweep` builds the initial states;
+2. `dbac.dbqite.QITE_dme_select_M` makes a DBAC step function, which uses
+   [DME](dme.md) internally;
+3. `dbac.gci.GCI` runs that step $k$ times and records energy and fidelity;
+4. `dbac.plotting` draws the result.
+
+```python
+import numpy as np
+from dbac.utils import rx_sweep
+from dbac.dbqite import QITE_dme_select_M
+from dbac.gci import GCI
+
+psi = rx_sweep([0.5])[0]                                    # 1. initial state
+step = QITE_dme_select_M(1)                                 # 2. step with M = 1
+results = GCI(step, psi, None, [np.pi / 4] * 2).execute_gci()  # 3. k = 2 steps
+print(results[-1])                                          # fidelity after 0, 1, 2 steps
+```