ran tox

Author: christopherporter1

docs/guides/algorithmiq-tem.ipynb

@@ -52,7 +52,7 @@
     "\n",
     "As an advantage, TEM leverages informationally complete measurements to give\n",
     "access to a vast set of mitigated expectation values of observables and has\n",
-    "optimal sampling overhead on the quantum hardware, as described in Filippov et \n",
+    "optimal sampling overhead on the quantum hardware, as described in Filippov et\n",
     "al. (2023), [arXiv:2307.11740](https://arxiv.org/abs/2307.11740), and  Filippov\n",
     "et al. (2024), [arXiv:2403.13542](https://arxiv.org/abs/2403.13542). The\n",
     "measurement overhead refers to the number of additional measurements required to\n",

docs/guides/functions.ipynb

@@ -2,6 +2,7 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "id": "eaf5b38b-a6e3-4494-95b0-8a43934aa435",
    "metadata": {},
    "source": [
     "{/* cspell:ignore Jarman, HIVQE, Cadavid, Chandarana, Leclerc, Sachdeva, HUBO, Filippov, Downfolding, Aharonov, Mundada, Yamauchi, supersymmetric, Paterakis, Gharibyan, Jaffali, Pellow */}"
@@ -62,7 +63,7 @@
    "id": "5e5b0531-f286-4573-8b1e-664ca5496d2d",
    "metadata": {},
    "source": [
-    "Functions are provided by IBM® and third-party partners. Each is performant for specific workload characteristics and has unique performance-tuning options. \n",
+    "Functions are provided by IBM® and third-party partners. Each is performant for specific workload characteristics and has unique performance-tuning options.\n",
     "\n",
     "## Overview of available functions\n",
     "\n",
@@ -487,6 +488,7 @@
   {
    "cell_type": "code",
    "execution_count": 1,
+   "id": "872b0563-6f88-4e0f-b318-29deb193b0f6",
    "metadata": {},
    "outputs": [
     {

docs/guides/kipu-optimization.ipynb

@@ -771,7 +771,7 @@
     "- Try the [Solve the Market Split problem with Kipu Quantum's Iskay Quantum Optimizer](/docs/tutorials/solve-market-split-problem-with-iskay-quantum-optimizer) tutorial.\n",
     "- Review [Romero, S. V., et al. (2025).  Bias-Field Digitized Counterdiabatic Quantum Algorithm for Higher-Order Binary Optimization. arXiv preprint arXiv:2409.04477.](https://arxiv.org/abs/2409.04477)\n",
     "- Review [Cadavid, A. G., et al. (2024).  Bias-field digitized counterdiabatic quantum optimization. arXiv preprint arXiv:2405.13898.](https://arxiv.org/abs/2405.13898)\n",
-    "- Review [Chandarana, P., et al. (2025).  Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.](https://arxiv.org/abs/2505.08663)\n"
+    "- Review [Chandarana, P., et al. (2025).  Runtime Quantum Advantage with Digital Quantum Optimization. arXiv preprint arXiv:2505.08663.](https://arxiv.org/abs/2505.08663)"
    ]
   },
   {

learning/courses/integrating-quantum-and-high-performance-computing/compute-resources.ipynb

@@ -2,9 +2,10 @@
  "cells": [
   {
    "cell_type": "markdown",
+   "id": "4dbd4656-5e40-4d5a-a29b-b13817c19cf2",
    "metadata": {},
    "source": [
-    "# Compute resources and resource management \n",
+    "# Compute resources and resource management\n",
     "\n",
     "\n",
     "## Resource Model and Classical Resources\n",
@@ -35,9 +36,9 @@
     "\n",
     "For memory, the unit of measure would be Mega/Giga/Terabytes.\n",
     "\n",
-    "For graphics cards and other accelerators, the unit of measure depends on the context. While their true computing capabilitiy is measured by fine-grained matrics - number of processing cores, memory size, and memory bandwidth, in high level discussions of cluster resources or job schedulings, GPUs and similar accelerators are can be quantifed at the device-level by the number of whole devices assigned (e.g. 3 GPUs). \n",
+    "For graphics cards and other accelerators, the unit of measure depends on the context. While their true computing capabilitiy is measured by fine-grained matrics - number of processing cores, memory size, and memory bandwidth, in high level discussions of cluster resources or job schedulings, GPUs and similar accelerators are can be quantifed at the device-level by the number of whole devices assigned (e.g. 3 GPUs).\n",
     "\n",
-    "Network/connectivity/busses are crucial aspect of any compute infrastructure as they dictate how fast data is transferred between compute components. From LPU to cache of CPU, to RAM, to PCI cards, to network connected devices; all of it is communication and it is crucial to have an accurate mental model of it to design highly optimized algorithms for HPC. \n",
+    "Network/connectivity/busses are crucial aspect of any compute infrastructure as they dictate how fast data is transferred between compute components. From LPU to cache of CPU, to RAM, to PCI cards, to network connected devices; all of it is communication and it is crucial to have an accurate mental model of it to design highly optimized algorithms for HPC.\n",
     "\n",
     "![An image showing that each computing node may include many types of resources.](/learning/images/courses/integrating-quantum-and-high-performance-computing/compute-resources/resources.svg)\n",
     "\n",
@@ -72,6 +73,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "b9c79070-17a8-42cc-98ff-27f351df80d9",
    "metadata": {},
    "source": [
     "## New Type of Resource: QPU (Quantum Processing Unit)\n",
@@ -80,9 +82,9 @@
     "\n",
     "### Definition of QPU\n",
     "\n",
-    "* Quantum processing unit (QPU): A QPU includes all of the hardware responsible for accepting an executable quantum instruction set, or a quantum circuit, and returning an accurate answer.  \n",
+    "* Quantum processing unit (QPU): A QPU includes all of the hardware responsible for accepting an executable quantum instruction set, or a quantum circuit, and returning an accurate answer.\n",
     "\n",
-    "That means the QPU includes one or more quantum chips (e.g. Heron), the multiple additional components in the dilution refrigerator such as the quantum amplifiers, the control electronics, and the classical compute required for tasks such as holding the instructions and waveforms in memory, accumulating results, and future error correction decoding. While a dilution refrigerator is required to perform these tasks, we exclude the dilution refrigerator from this definition to allow for the case of multiple QPUs in the same fridge.  \n",
+    "That means the QPU includes one or more quantum chips (e.g. Heron), the multiple additional components in the dilution refrigerator such as the quantum amplifiers, the control electronics, and the classical compute required for tasks such as holding the instructions and waveforms in memory, accumulating results, and future error correction decoding. While a dilution refrigerator is required to perform these tasks, we exclude the dilution refrigerator from this definition to allow for the case of multiple QPUs in the same fridge.\n",
     "\n",
     "* Quantum computer: A quantum computer is comprised of the QPU plus the classical compute which hosts the runtime environment.\n",
     "\n",
@@ -140,10 +142,10 @@
     "\n",
     "### Scaling quantum resources\n",
     "\n",
-    "Scaling of quantum resources can also be categorized into vertical and horizontal.  \n",
+    "Scaling of quantum resources can also be categorized into vertical and horizontal.\n",
     "\n",
-    "* Vertical scaling would be increasing the number of qubits per chiplet or improving the fidelity of devices.  \n",
-    "* Horizontal scaling would be connecting chips with couplers or with classical interconnect.   \n",
+    "* Vertical scaling would be increasing the number of qubits per chiplet or improving the fidelity of devices.\n",
+    "* Horizontal scaling would be connecting chips with couplers or with classical interconnect.\n",
     "\n",
     "![An image showing vertical scaling of quantum resources as more qubits on a chip, and horizontal scaling of quanum resources as connecting many chips together with couplers.](/learning/images/courses/integrating-quantum-and-high-performance-computing/compute-resources/quantum-scaling.svg)\n",
     "\n",
@@ -166,6 +168,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "dc79a919-7936-4ed1-b957-f4046f8fca6d",
    "metadata": {},
    "source": [
     "## Resource Management\n",
@@ -188,7 +191,7 @@
     "There are analogs of all these processes for quantum computers.\n",
     "* Jobs are submitted by the user, leveraging Qiskit runtime, and typically using a Qiskit runtime primitive, like `Sampler`, `Estimator`, or others.\n",
     "* The user selects from a list of backends to which they have access. The complete list of available backends can be seen [here](https://quantum.cloud.ibm.com/computers). It is common to simply use the least busy quantum computer. But there are cases where it might be important to use a specific one because of device layout considerations, replication of previous calculations, etc.\n",
-    "* The execution of quantum jobs is similar to the HPC case. Although some differences have already been outlined, a few are worth repeating here. QPUs are currently not generally located on the same node as classical compute resources but are connected through a network. This may have scheduling implications. Further, quantum computers may have substantial queue times, and these queue times vary, making precising control of timing difficult. This situation may be different for dedicated systems; that depends on the quantum computer's internal administration. \n",
+    "* The execution of quantum jobs is similar to the HPC case. Although some differences have already been outlined, a few are worth repeating here. QPUs are currently not generally located on the same node as classical compute resources but are connected through a network. This may have scheduling implications. Further, quantum computers may have substantial queue times, and these queue times vary, making precising control of timing difficult. This situation may be different for dedicated systems; that depends on the quantum computer's internal administration.\n",
     "\n",
     "### Controlling/Managing - Workload Management\n",
     "\n",
@@ -197,7 +200,7 @@
     "* Job scheduling: The activity of the scheduler software in deciding which jobs run, when, and on which resources, managing priorities and queues to efficiently utilize the HPC system. Although this broad statement applies to quantum resources, there may be less control over timing than with other resources.\n",
     "\n",
     "![An image showing workloads (shown as boxes) being organized and arranged to fit optimally into a two dimensional grid with one axis representing time and the other representing resources.](/learning/images/courses/integrating-quantum-and-high-performance-computing/compute-resources/resource-manage.svg)\n",
-    "**Example:** \n",
+    "**Example:**\n",
     "\n",
     "Consider a well-known task as a context for understanding resource management: finding the prime factors of large numbers. Let us further assume that the algorithm being used relies on brute force checking of every potential divisor. While this is ofen not the most efficient method, it is easy to understand how the workload might be managed.\n",
     "\n",
@@ -218,7 +221,7 @@
     "\n",
     "High performance computing environments use special software to carry out these steps and manage resources. In the next section, we will learn about a widely-adopted resource management software systems: Slurm.\n",
     "\n",
-    "**Example with quantum resources:** \n",
+    "**Example with quantum resources:**\n",
     "\n",
     "A workflow that will be the subject of other lessons in this course is determining chemical ground states and energies using sample-based quantum diagonalization (SQD). This is covered in more detail in Lesson 4, and you can also visit [this course on SQD](https://quantum.cloud.ibm.com/learning/en/courses/quantum-diagonalization-algorithms) and related methods on [IBM Quantum Learning](https://quantum.cloud.ibm.com/learning/). All we need to know for this discussion is that the workflow involves:\n",
     "* preparing a quantum circuit\n",
@@ -264,14 +267,15 @@
     "\n",
     "(a) Planning\n",
     "(b) Controlling/managing\n",
-    "(c) Allocating/scheduling, \n",
+    "(c) Allocating/scheduling,\n",
     "\n",
     "\n",
     "</details>"
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "7ff27439-296e-4dba-98e4-8cae2cc8c9d6",
    "metadata": {},
    "source": [
     "## Software: Slurm\n",
@@ -300,6 +304,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "4fea8c6e-a32e-45b6-ad8d-eb349e6cecc3",
    "metadata": {},
    "source": [
     "```shell\n",
@@ -320,14 +325,15 @@
     "Gres=qpu:1\n",
     "NodeAddr=q1 NodeHostName=q1 Version=21.08.6\n",
     "...\n",
-    "  \n",
+    "\n",
     "```\n",
     "\n",
     "We have 2 partitions or node groups: normal and quantum. The normal partition is composed of nodes that have access to classical resources only. The quantum partition has access to quantum resources. You can see the details of each node by executing `scontrol show nodes`."
    ]
   },
   {
    "cell_type": "markdown",
+   "id": "20932bac-88de-49bd-9f58-eea29c31df45",
    "metadata": {},
    "source": [
     "### Running simple hello world example in Slurm.\n",
@@ -346,6 +352,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "cc826674-d703-4765-ab30-ecd0b9035007",
    "metadata": {},
    "source": [
     "Now we need to tell the resource manager what resources we need to execute this program. Slurm provides a way to specify all metadata for the job via a submission script, which is just a shell script with Slurm-specific annotations. These annotations allow you to specify resource requirements, schedule parameters, and more. Let's create a `hello_world.sh` shell script for this.\n",
@@ -433,6 +440,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "1f32cef4-3b71-49ea-b11b-70c19250bb9e",
    "metadata": {},
    "source": [
     "### Running simple Qiskit hello world example in Slurm.\n",
@@ -446,6 +454,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "7fc48590-2dca-4568-b729-6ae09dc41f81",
    "metadata": {},
    "source": [
     "```python\n",
@@ -455,13 +464,13 @@
     "from qiskit.quantum_info import SparsePauliOp\n",
     "from qiskit.transpiler import generate_preset_pass_manager\n",
     "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
-    " \n",
+    "\n",
     "# Create a new circuit with two qubits\n",
     "qc = QuantumCircuit(2)\n",
-    " \n",
+    "\n",
     "# Add a Hadamard gate to qubit 0\n",
     "qc.h(0)\n",
-    " \n",
+    "\n",
     "# Perform a controlled-X gate on qubit 1, controlled by qubit 0\n",
     "qc.cx(0, 1)\n",
     "\n",
@@ -470,30 +479,30 @@
     "\n",
     "# switch to QRMI service\n",
     "from qiskit_ibm_runtime import QiskitRuntimeService\n",
-    " \n",
+    "\n",
     "service = QiskitRuntimeService()\n",
-    " \n",
+    "\n",
     "backend = service.backend(\"...\")\n",
-    " \n",
+    "\n",
     "# Convert to an ISA circuit and layout-mapped observables.\n",
     "pm = generate_preset_pass_manager(backend=backend, optimization_level=1)\n",
     "isa_circuit = pm.run(qc)\n",
-    " \n",
+    "\n",
     "# Construct the Estimator instance.\n",
-    " \n",
+    "\n",
     "estimator = Estimator(mode=backend)\n",
     "estimator.options.resilience_level = 1\n",
     "estimator.options.default_shots = 5000\n",
-    " \n",
+    "\n",
     "mapped_observables = [\n",
     "    observable.apply_layout(isa_circuit.layout) for observable in observables\n",
     "]\n",
-    " \n",
+    "\n",
     "# One pub, with one circuit to run against five different observables.\n",
     "job = estimator.run([(isa_circuit, mapped_observables)])\n",
     "\n",
     "job_result = job.result()\n",
-    " \n",
+    "\n",
     "pub_result = job.result()[0]\n",
     "\n",
     "print(\"Result\", pub_result)\n",
@@ -503,6 +512,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "3462d06f-767d-4586-8c95-99426df9c3b1",
    "metadata": {},
    "source": [
     "Here we will use the quantum resource management interface (QRMI),  a Slurm Spank plugin for Quantum resources and jobs support which was developed jointly by IBM, Pasqal, the The Hartree Center and RPI. We made a simple pauli-2-design circuit with random initial values and a simple observable and run it using Estimator to get the expectation value.  To run it we will again need the submission script `hello_qiskit.sh`, which will have quantum resources as a requirement.\n",
@@ -539,7 +549,7 @@
     "#                 1 main          hello_qiskit  root R        0:01      1 q1\n",
     "```\n",
     "\n",
-    "And we will be able to explore logs and results after the job is finished. \n",
+    "And we will be able to explore logs and results after the job is finished.\n",
     "\n",
     "```shell\n",
     "$ cat hello_qiskit.out | grep Exp\n",
@@ -550,6 +560,7 @@
   },
   {
    "cell_type": "markdown",
+   "id": "5a394dfb-17ce-41a9-85e1-7e4dcff4ef6c",
    "metadata": {},
    "source": [
     "### Recap\n",
@@ -563,18 +574,12 @@
     "All the code and scripts used in this chapter are available for you within our Github repository. [TempLink](https://github.ibm.com/Christopher-Porter1/hpc-course-demos/blob/main/source/updates.patch)\n",
     "</div>"
    ]
-  },
-  {
-   "cell_type": "markdown",
-   "metadata": {},
-   "source": []
   }
  ],
  "metadata": {
   "description": "This lesson introduces classical and quantum computing resources and discusses their scaling.",
-  "title": "Computing resources",
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -588,8 +593,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.11.11"
+   "version": "3"
   },
+  "title": "Computing resources",
   "widgets": {
    "application/vnd.jupyter.widget-state+json": {
     "state": {},

learning/courses/integrating-quantum-and-high-performance-computing/introduction.ipynb

@@ -139,17 +139,15 @@
     "\n",
     "## About this course\n",
     "\n",
-    "By the end of this course, you will be able to do more than just repeat technical terms—you will understand how to manage a modern hybrid workflow that assigns specific sub-tasks to a quantum processor while CPUs and GPUs handle the remaining work. You will learn how to write scripts for jobs that transition smoothly between classical nodes and QPUs, interpret the results with accuracy, and recognize where quantum acceleration can truly improve calculations (and where it cannot). Equally important, you will practice maintaining a growth mindset: in a new and rapidly evolving field, no one learns everything at once, and real progress comes from iterating, experimenting, and asking questions.\n",
-    "\n",
-    "\n"
+    "By the end of this course, you will be able to do more than just repeat technical terms—you will understand how to manage a modern hybrid workflow that assigns specific sub-tasks to a quantum processor while CPUs and GPUs handle the remaining work. You will learn how to write scripts for jobs that transition smoothly between classical nodes and QPUs, interpret the results with accuracy, and recognize where quantum acceleration can truly improve calculations (and where it cannot). Equally important, you will practice maintaining a growth mindset: in a new and rapidly evolving field, no one learns everything at once, and real progress comes from iterating, experimenting, and asking questions."
    ]
   },
   {
    "cell_type": "markdown",
    "id": "12ff300a-d0e1-4890-811d-1fdaacb71ef0",
    "metadata": {},
    "source": [
-    "This course is broken down into 5 chapters, which are as follows: \n",
+    "This course is broken down into 5 chapters, which are as follows:\n",
     "\n",
     "### Course Outline\n",
     "\n",
@@ -173,9 +171,8 @@
  ],
  "metadata": {
   "description": "This lesson introduces the course in integrating quantum and high-performance computing and includes a course outline.",
-  "title": "Introduction",
   "kernelspec": {
-   "display_name": "Python 3 (ipykernel)",
+   "display_name": "Python 3",
    "language": "python",
    "name": "python3"
   },
@@ -189,8 +186,9 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.12.10"
-  }
+   "version": "3"
+  },
+  "title": "Introduction"
  },
  "nbformat": 4,
  "nbformat_minor": 5