[WIP] Adds Qiskit addon prose content pipeline

README.md

@@ -139,6 +139,13 @@ API docs authors can preview their changes to one of the APIs by using the `-a`
 1. Run `npm run gen-api -- -p <pkg-name> -v <version> -a <path/to/docs/_build/html>`.
 2. Execute `./start` and open up `http://localhost:3000`, as explained in the prior section.
 
+### Addon docs authors: How to preview your changes
+
+Addon docs authors can preview guide and how-to changes by pointing the addon pipeline at a local Sphinx build:
+
+1. Run `npm run gen-addon -- -p <pkg-name> --sphinx-artifact-folder <path/to/docs/_build/html>`.
+2. Execute `./start` and navigate to `http://localhost:3000/docs/addons/<pkg-name>`.
+
 ## Run quality checks
 
 We use multiple tools to ensure that documentation meets high standards. These tools will run automatically in your PR through CI, but it is much faster to run the checks locally.
@@ -320,6 +327,36 @@ Additionally, If you are regenerating a dev version, then you can add `--dev` as
 
 In this case, no commit will be automatically created.
 
+## Generate or update addon docs
+
+Addon docs (guides, how-tos, explanations, and notebook-based tutorials) for packages like `qiskit-addon-cutting`, `qiskit-addon-obp`, `pauli-prop`, etc., are generated by a separate pipeline from the API stubs pipeline. Content is published to `docs/addons/{pkg}/` rather than `docs/api/{pkg}/`.
+
+### Generate addon docs for a new release
+
+1. Download the Sphinx HTML artifact from the package's GitHub Actions workflow (see the [CI artifact links](#initial-steps) in the API docs section).
+2. Rename the zip to its minor version, e.g. `0.5.zip`, and upload it to the Box folder.
+3. Run:
+   ```sh
+   npm run gen-addon -- -p <pkg-name>
+   ```
+   For example:
+   ```sh
+   npm run gen-addon -- -p qiskit-addon-cutting
+   npm run gen-addon -- -p pauli-prop
+   ```
+   To regenerate all addon packages at once:
+   ```sh
+   npm run gen-addon -- --all
+   ```
+4. Open a pull request with the generated changes.
+
+### Add a new addon package
+
+1. Add the package name to `Pkg.ADDON_NAMES` in `scripts/js/lib/api/Pkg.ts` and add a `fromArgs` branch that returns a `new Pkg(...)` with the correct `title`, `githubSlug`, and `language`.
+2. Add the package's Box artifact URL to `scripts/config/api-html-artifacts.json`.
+3. If the package ships tutorials that live in `docs/tutorials/`, list their slugs in the `tutorials` array of the `Pkg` constructor call.
+4. Run the pipeline once with a local artifact using `-a <path>` to verify output before uploading to Box.
+
 ## Generate new API docs
 
 Use this process when we want to publish new API docs, such as when we release a new version of a package like Qiskit SDK.
@@ -357,12 +394,17 @@ All release types start with the following steps:
       - Qiskit SDK: https://github.com/Qiskit/qiskit/actions/workflows/docs_deploy.yml
       - Runtime: https://github.com/Qiskit/qiskit-ibm-runtime/actions/workflows/docs.yml
       - Transpiler Service: https://github.com/Qiskit/qiskit-ibm-transpiler/actions/workflows/upload-docs.yml
-      - qiskit-addon-acq-tensor: https://github.com/Qiskit/qiskit-addon-aqc-tensor/actions/workflows/docs.yml
+      - qiskit-addon-aqc-tensor: https://github.com/Qiskit/qiskit-addon-aqc-tensor/actions/workflows/docs.yml
       - qiskit-addon-obp: https://github.com/Qiskit/qiskit-addon-obp/actions/workflows/docs.yml
       - qiskit-addon-mpf: https://github.com/Qiskit/qiskit-addon-mpf/actions/workflows/docs.yml
       - qiskit-addon-sqd: https://github.com/Qiskit/qiskit-addon-sqd/actions/workflows/docs.yml
+      - qiskit-addon-sqd-hpc: https://github.com/Qiskit/qiskit-addon-sqd-hpc/actions/workflows/docs.yml
       - qiskit-addon-cutting: https://github.com/Qiskit/qiskit-addon-cutting/actions/workflows/docs.yml
       - qiskit-addon-utils: https://github.com/Qiskit/qiskit-addon-utils/actions/workflows/docs.yml
+      - qiskit-addon-pna: https://github.com/Qiskit/qiskit-addon-pna/actions/workflows/docs.yml
+      - qiskit-addon-slc: https://github.com/Qiskit/qiskit-addon-slc/actions/workflows/docs.yml
+      - qiskit-addon-opt-mapper: https://github.com/Qiskit/qiskit-addon-opt-mapper/actions/workflows/docs.yml
+      - pauli-prop: https://github.com/Qiskit/pauli-prop/actions/workflows/docs.yml
    2. Find the run for the release by looking at the middle column with the blue text; look for the version number, like `0.45.2`. For the `rc1` release, look for `main` in blue text and a run description like "Prepare 2.3.0rc1".
    3. Click the CI run name. (Not the middle column with the blue link!)
    4. In the left navbar, it should show as selected the "Summary" page with the house.

docs/addons/pauli-prop/_toc.json

@@ -0,0 +1,45 @@
+{
+  "parentUrl": "/docs/guides/addons",
+  "parentLabel": "Documentation",
+  "title": "Pauli propagation 0.2",
+  "collapsed": true,
+  "children": [
+    {
+      "title": "",
+      "children": [
+        {
+          "title": "Documentation Home",
+          "url": "/docs/addons/pauli-prop"
+        },
+        {
+          "title": "Installation Instructions",
+          "url": "/docs/addons/pauli-prop/install"
+        },
+        {
+          "title": "How-To Guides",
+          "children": [
+            {
+              "title": "How to do something",
+              "url": "/docs/addons/pauli-prop/how_tos/do-something"
+            }
+          ]
+        },
+        {
+          "title": "GitHub",
+          "url": "https://github.com/qiskit/pauli-prop"
+        }
+      ],
+      "collapsible": false
+    },
+    {
+      "title": "API reference",
+      "collapsible": false,
+      "children": [
+        {
+          "title": "Pauli propagation API reference",
+          "url": "/docs/api/pauli-prop"
+        }
+      ]
+    }
+  ]
+}

docs/addons/pauli-prop/how_tos/do-something.ipynb

@@ -0,0 +1,44 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "id": "frontmatter",
+   "metadata": {},
+   "source": [
+    "---\n",
+    "title: \"How to do something\"\n",
+    "description: \"How to do something for the latest version of Pauli propagation\"\n",
+    "---"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0b915b9c-2673-4e05-9891-fcd72795cf8d",
+   "metadata": {},
+   "source": [
+    "# How to do something"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

docs/addons/pauli-prop/how_tos/index.mdx

@@ -0,0 +1,13 @@
+---
+title: "How-To Guides"
+description: "How-To Guides for the latest version of Pauli propagation"
+---
+
+# How-To Guides
+
+This page summarizes the available how-to guides.
+
+[![](/docs/images/addons/pauli-prop/nbsphinx-no-thumbnail.svg)](do-something)
+
+[How to do something](do-something)
+

docs/addons/pauli-prop/index.mdx

@@ -0,0 +1,91 @@
+---
+title: "Pauli Prop"
+description: "Documentation for the latest version of Pauli propagation"
+---
+
+# Pauli Prop
+
+## About
+
+Pauli propagation is a framework for approximating the evolution of operators in the Pauli basis under the action of other operators, such as quantum circuit gates and noise channels \[1] - \[5]. This approach can be effective when the operators involved are expected to remain sparse in the Pauli basis. The technique has been used to classically estimate expectation values of quantum systems and also to reduce the depths of quantum circuits to be run on a quantum processor \[6]. To learn how to use this package to simulate expectation values of quantum systems, check out the tutorial.
+
+This package provides a Rust-accelerated Python interface for performing Pauli propagation. The subroutines in this package may be used to implement:
+
+*   Lightcone shading \[7] and other novel error mitigation techniques
+*   Operator backpropagation (OBP) \[6]
+*   Classical simulation of expectation values \[[tutorials](https://qiskit.github.io/pauli-prop/tutorials/index.html)]
+
+### Technical details
+
+*   Rust-accelerated Python interface
+*   Support for noisy simulations \[[tutorial 3](https://qiskit.github.io/pauli-prop/tutorials/03_simulate_noisy_expectation_values.html)]
+*   Ability to truncate terms during evolution based on an absolute coefficient tolerance, a fixed number of terms in the evolving operator, or a combination of both.
+*   Ability to perform Pauli propagation in both the Schrödinger and Heisenberg frameworks.
+*   Novel technique for approximating the conjugation of a Pauli-sum operator by another Pauli operator. This heuristic implementation greedily generates contributions to the product expected to be most significant.
+*   Single-threaded
+
+### Computational requirements
+
+Both the memory and time cost for Pauli propagation routines generally scale with the size to which the evolved operator is allowed to grow.
+
+`propagate_through_rotation_gates`: As the Pauli operator is propagated in the Pauli basis under the action of a sequence of $N$ Pauli rotation gates of an $M$-qubit circuit, the number of terms will grow as $\mathcal{O}(2^N)$ towards a maximum of $4^M$ unique Pauli components. To control memory usage, the operator is truncated after application of each gate, which introduces some error proportional to the magnitudes of the truncated terms’ coefficients. The memory requirements are linear in the size of the evolved operator and runtime scales linearly in both the operator size and the number of gates.
+
+`propagate_through_operator`: Conjugates one operator in the Pauli basis by another by greedily accumulating terms in the sum, $\sum_{i,j,k}G^{\dagger}_iO_jG_k$, where $i,j,k$ are sparse indices over the Pauli basis. This implementation sorts the coefficients in each operator by descending magnitude then searches the 3D index space for the terms with the largest coefficients, starting with the origin $(0,0,0)$, and accumulating $(i,j,k)$ triplets up to a specified cutoff. The time spent searching can often be made negligible by increasing the search step size in $(i,j,k)$ space, which provides a cubic speedup for this subroutine. In our profiling, significant time can be spent sorting the operators and performing Pauli multiplication to generate the terms in the new operator.
+
+## Installation
+
+We encourage installing this package via `pip`, when possible:
+
+```bash
+pip install pauli-prop
+```
+
+For more installation information refer to the [installation instructions](install) in the documentation.
+
+## Citing this project
+
+If you use this package in your research, please cite it according to `CITATON.bib` file included in this repository:
+
+```bibtex
+@software{pauli-prop,
+  author = {Qiskit addons team},
+  title = {{Pauli prop}},
+  howpublished = {\url{https://github.com/Qiskit/pauli-prop}},
+  year = {2025}
+}
+```
+
+## Deprecation Policy
+
+We follow [semantic versioning](https://semver.org/) and are guided by the principles in [Qiskit’s deprecation policy](https://github.com/Qiskit/qiskit/blob/main/DEPRECATION.md). We may occasionally make breaking changes in order to improve the user experience. When possible, we will keep old interfaces and mark them as deprecated, as long as they can co-exist with the new ones. Each substantial improvement, breaking change, or deprecation will be documented in the release notes.
+
+## Contributing
+
+The source code is available [on GitHub](https://github.com/Qiskit/pauli-prop).
+
+The developer guide is located at [CONTRIBUTING.md](https://github.com/Qiskit/pauli-prop/blob/main/CONTRIBUTING.md) in the root of this project’s repository. By participating, you are expected to uphold Qiskit’s [code of conduct](https://github.com/Qiskit/qiskit/blob/main/CODE_OF_CONDUCT.md).
+
+We use [GitHub issues](https://github.com/Qiskit/pauli-prop/issues/new/choose) for tracking requests and bugs.
+
+## License
+
+[Apache License 2.0](https://github.com/Qiskit/pauli-prop/blob/main/LICENSE.txt)
+
+<span id="id1" />
+
+## References
+
+\[1] Tomislav Begušić, Johnnie Gray, Garnet Kin-Lic Chan, [Fast and converged classical simulations of evidence for the utility of quantum computing before fault tolerance](https://arxiv.org/abs/2308.05077), arXiv:2308.05077 \[quant-ph].
+
+\[2] Nicolas Loizeau, et al., [Quantum many-body simulations with PauliStrings.jl](https://arxiv.org/abs/2410.09654), arXiv:2410.09654 \[quant-ph].
+
+\[3] Manuel S. Rudolph, et al., [Pauli Propagation: A Computational Framework for Simulating Quantum Systems](https://arxiv.org/abs/2505.21606), arXiv:2505.21606 \[quant-ph].
+
+\[4] Hrant Gharibyan, et al., [A Practical Guide to using Pauli Path Simulators for Utility-Scale Quantum Experiments](https://arxiv.org/abs/2507.10771), arXiv:2507.10771 \[quant-ph].
+
+\[5] Lukas Broers, et al., [Scalable Simulation of Quantum Many-Body Dynamics with Or-Represented Quantum Algebra](https://arxiv.org/abs/2506.13241), arXiv:2506.13241 \[quant-ph].
+
+\[6] Bryce Fuller, et al., [Improved Quantum Computation using Operator Backpropagation](https://arxiv.org/abs/2502.01897), arXiv:2502.01897 \[quant-ph].
+
+\[7] Andrew Eddins, Minh C. Tran, Patrick Rall, [Lightcone shading for classically accelerated quantum error mitigation](https://arxiv.org/abs/2409.04401), arXiv:2409.04401 \[quant-ph].
+

docs/addons/pauli-prop/install.mdx

@@ -0,0 +1,64 @@
+---
+title: "Installation Instructions"
+description: "Installation Instructions for the latest version of Pauli propagation"
+---
+
+# Installation Instructions
+
+Let’s see how to install the package. The first thing to do is ensure your Python environment is set up correctly. To create a new environment:
+
+## Pre-Installation
+
+First, create a minimal environment with only Python installed in it. We recommend using [Python virtual environments](https://docs.python.org/3.10/tutorial/venv.html).
+
+```sh
+python3 -m venv /path/to/virtual/environment
+```
+
+Activate your new environment.
+
+```sh
+source /path/to/virtual/environment/bin/activate
+```
+
+There are two primary ways to install this package – from PyPI or source. The preferred method is to install from PyPI:
+
+## Install from PyPI
+
+```sh
+pip install pauli-prop
+```
+
+## Install from Source
+
+Users who wish to develop in the repository or run the notebooks locally may want to install from source.
+
+If so, the first step is to clone the `pauli-prop` repository.
+
+```sh
+git clone git@github.com:Qiskit/pauli-prop.git
+```
+
+Next, install the Rust toolchain, upgrade pip, and enter the repository. Refer to the [Rust documentation](https://www.rust-lang.org/tools/install) for instructions on installing the toolchain.
+
+```sh
+### <INSTALL RUST HERE> ###
+pip install --upgrade pip
+cd pauli-prop
+```
+
+The next step is to install `pauli-prop` to the virtual environment. If you plan on running the notebooks, install the notebook dependencies in order to run all the visualizations in the notebooks. If you plan on developing in the repository, you may want to install the `dev` dependencies.
+
+Adjust the options below to suit your needs.
+
+```sh
+pip install tox notebook -e '.[notebook-dependencies,dev]'
+```
+
+If you installed the notebook dependencies, you can get started by running the notebooks in the docs.
+
+```python
+cd docs/
+jupyter lab'
+```
+

docs/addons/qiskit-addon-aqc-tensor/_toc.json

@@ -0,0 +1,59 @@
+{
+  "parentUrl": "/docs/guides/addons",
+  "parentLabel": "Documentation",
+  "title": "Approximate quantum compilation (AQC-Tensor) 0.3",
+  "collapsed": true,
+  "children": [
+    {
+      "title": "",
+      "children": [
+        {
+          "title": "Documentation Home",
+          "url": "/docs/addons/qiskit-addon-aqc-tensor"
+        },
+        {
+          "title": "Installation Instructions",
+          "url": "/docs/addons/qiskit-addon-aqc-tensor/install"
+        },
+        {
+          "title": "Explanatory Material",
+          "url": "/docs/addons/qiskit-addon-aqc-tensor/explanation/index"
+        },
+        {
+          "title": "How-To Guides",
+          "children": [
+            {
+              "title": "How to use quimb.tensor.TNOptimizer directly",
+              "url": "/docs/addons/qiskit-addon-aqc-tensor/how-tos/01-quimb-tnoptimizer"
+            }
+          ]
+        },
+        {
+          "title": "GitHub",
+          "url": "https://github.com/Qiskit/qiskit-addon-aqc-tensor"
+        }
+      ],
+      "collapsible": false
+    },
+    {
+      "title": "Tutorials",
+      "collapsible": false,
+      "children": [
+        {
+          "title": "Approximate quantum compilation for time evolution circuits",
+          "url": "/docs/tutorials/approximate-quantum-compilation-for-time-evolution"
+        }
+      ]
+    },
+    {
+      "title": "API reference",
+      "collapsible": false,
+      "children": [
+        {
+          "title": "Approximate quantum compilation (AQC-Tensor) API reference",
+          "url": "/docs/api/qiskit-addon-aqc-tensor"
+        }
+      ]
+    }
+  ]
+}