diff --git a/learning/courses/quantum-computing-in-practice/_toc.json b/learning/courses/quantum-computing-in-practice/_toc.json
index d9c38079356..207ebd21bbf 100644
--- a/learning/courses/quantum-computing-in-practice/_toc.json
+++ b/learning/courses/quantum-computing-in-practice/_toc.json
@@ -34,6 +34,12 @@
"url": "/learning/courses/quantum-computing-in-practice/mapping",
"isNew": true,
"isNewDate": "2025-06-18"
+ },
+ {
+ "title": "Simulating nature",
+ "url": "/learning/courses/quantum-computing-in-practice/simulating-nature",
+ "isNew": true,
+ "isNewDate": "2025-06-18"
}
]
}
diff --git a/learning/courses/quantum-computing-in-practice/simulating-nature.ipynb b/learning/courses/quantum-computing-in-practice/simulating-nature.ipynb
new file mode 100644
index 00000000000..b13691c6c47
--- /dev/null
+++ b/learning/courses/quantum-computing-in-practice/simulating-nature.ipynb
@@ -0,0 +1,360 @@
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "id": "0c3d10c9",
+ "metadata": {},
+ "source": [
+ "# Simulating nature\n",
+ "\n",
+ "Video link\n",
+ "Link to tutorial https://quantum.cloud.ibm.com/docs/en/tutorials/probabilistic-error-amplification"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "29091c37",
+ "metadata": {},
+ "source": [
+ "## Introduction\n",
+ "\n",
+ "One of the most compelling applications of quantum computers is their ability to simulate natural phenomena. In this lesson, we will explore how quantum computers are used to tackle quantum dynamics problems—specifically, how they help us understand the time-evolution of a quantum system.\n",
+ "\n",
+ "First, we will take a broad look at the general steps involved in conducting these simulations. Then, we will examine a concrete example: IBM’s 2023 experiment that showcased the concept of quantum utility. This experiment serves as an excellent case study for understanding the practical steps and implications of simulating quantum dynamics with real quantum hardware.\n",
+ "By the end, you will have a clearer picture of how researchers approach these challenges and why quantum simulation holds such promise for advancing our understanding of the natural world.\n",
+ "\n",
+ "Richard Feynman gave a highly-influential lecture at Caltech in 1959. It was famously titled “There’s Plenty of Room at the Bottom,” in playful allusion to the vast, unexplored possibilities at the microscopic scale. Feynman argued that much of physics at the atomic and subatomic levels had yet to be uncovered.\n",
+ "\n",
+ "The significance of the talk grew in the 1980s as technology progressed. During this period, Feynman revisited these ideas in another important lecture at Caltech, presenting a paper called “Simulating Nature with Computers.” There, he posed a bold question: could computers be used to perform exact simulations that replicate nature’s behavior at the quantum level? Feynman suggested that, instead of relying on rough approximations to model atomic processes, we could use computers that harness the laws of quantum mechanics themselves—not merely to model nature, but to emulate it.\n",
+ "\n",
+ "It is this type of physical simulation that we will examine today.\n",
+ "\n",
+ "Recall this timeline graphic introduced in a previous episode. At one end of the spectrum, we see problems that are straightforward to solve and do not require the enhanced speed quantum computing might bring.\n",
+ "\n",
+ "\n",
+ "\n",
+ "At the opposite end are extremely challenging problems that demand fully fault-tolerant quantum machines — technology that is not yet available. Fortunately, many simulation problems are believed to fall somewhere in the middle of this timeline, within the range where today’s quantum computers can already be effectively applied. There are many reasons to be excited and intrigued by this prospect, as simulating nature forms the foundation for a wide range of promising applications.\n",
+ "\n",
+ "In what follows we will cover the general workflow in nature simulations and then a specific instance of the workflow to replicate results from a well-known study."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "796f3125",
+ "metadata": {},
+ "source": [
+ "## General workflow\n",
+ "\n",
+ "Before anyone can apply quantum computing to these exciting areas, it’s important to first understand the basic steps in a typical simulation workflow:\n",
+ "\n",
+ "1. Identify system Hamiltonian\n",
+ "2. Hamiltonian encoding\n",
+ "3. State preparation\n",
+ "4. State evolution circuit\n",
+ "5. Circuit optimization\n",
+ "6. Circuit execution\n",
+ "7. Post-processing\n",
+ "\n",
+ "The process begins by identifying a quantum system of interest. This helps determine the Hamiltonian that governs its time evolution, as well as a meaningful description of its initial properties, or its state. Next, you need to select an appropriate method to implement the time evolution of this state. Note that the first four steps in this workflow are all part of the *Mapping* step in the Qiskit patterns framework.\n",
+ "\n",
+ "After setting up the time-evolution circuit, the subsequent stages involve performing the actual experiment. This typically includes optimizing the quantum circuit that implements the time-evolution algorithm, running the circuit on quantum hardware, and post-processing the results. These are the same as the last three steps in the Qiskit patterns framework.\n",
+ "\n",
+ "Now lets walk through what these steps mean before we move on to coding.\n",
+ "\n",
+ "__1. Identify the system Hamiltonian__\n",
+ "\n",
+ "The first essential step in performing a simulation experiment is to identify the Hamiltonian that describes the system. In many cases, the Hamiltonian is well established. However, sometimes we need to construct it by understanding the energy contributions of smaller parts within the full system. For example, this might involve representing the Hamiltonian as a sum of terms,\n",
+ "\n",
+ "$$\n",
+ "H=\\sum_i^N {h_i}\n",
+ "$$\n",
+ "\n",
+ "where each term $h_i$ acts on one of the $N$ local subsystems of the total Hamiltonian $H$. In the case of indistinguishable elementary particles, it is important to determine whether the system involves fermions or bosons, as this affects the system's statistics and how it must be modeled. In practice, people are often interested in physical systems in which the elements are presumed to be well-separated or labeled, and thus distinguishable, as in spins on a lattice.\n",
+ "\n",
+ "\n",
+ "\n",
+ "__2. Hamiltonian encoding__\n",
+ "\n",
+ "The next step is to encode the Hamiltonian and translate it into a form that a quantum computer can process. Typically, these Hamiltonians are composed of elementary particles or distinguishable spin systems (sometimes simply called \"spin systems\" for short, though technically fermions and bosons are also systems of objects with spin). When simulating identical fermions or bosons, it is necessary to apply an encoding transformation, such as the Jordan-Wigner or Bravyi-Kitaev transformation. These methods provide a systematic way to convert the Hamiltonian, originally expressed in terms of fermionic or bosonic operators on indistinguishable particles, into Pauli operators acting on distinguishable qubits. Pauli operators are especially convenient because they can be directly translated into quantum gates on a quantum computer. For instance, the Jordan-Wigner transformation maps fermionic operators to Pauli operators in a clear and well-defined manner. On the other hand, if the system already involves distinguishable spin-1/2 particles, then the Hamiltonian is already in a suitable form for quantum computation and no additional encoding is required.\n",
+ "\n",
+ "\n",
+ "\n",
+ "__3. State preparation__\n",
+ "\n",
+ "After encoding the desired Hamiltonian into the quantum computer’s gate set, the next important step is to select an appropriate initial quantum state to begin the simulation. Ideally, this state should represent a physically meaningful configuration of the system under study. For instance, if the goal is to investigate the ground state energy of a molecule, one might start with a Hartree-Fock approximation or another easily-prepared ansatz that has significant overlap with the true ground state. The choice of initial state influences not only the convergence of variational algorithms such as the Variational Quantum Eigensolver (VQE) but also affects the accuracy and efficiency of time evolution and sampling. Essentially, the initial state serves as the starting point for the computation, laying the groundwork for extracting useful observables from the quantum system being modeled.\n",
+ "\n",
+ "We can write an arbitrary $n$-qubit state as a superposition of computational basis states $∣c_i\\rangle$ with coefficients $a_i$, satisfying normalization conditions. Preparing such a state can generally be approached by applying a specific operator $\\hat{O}$ to the initial state, which is typically the all-zero standard basis state by convention.\n",
+ "\n",
+ "$$\n",
+ "|\\psi\\rangle = \\sum_{i=0}^{2^n-1}{a_i |c_i\\rangle}=\\hat{O}|0\\rangle^{\\otimes n}\\\\\n",
+ "\\text{with} \\qquad \\sum_{i=0}^{2^n-1}{|a_i^2|}=1\n",
+ "$$\n",
+ "\n",
+ "\n",
+ "However, this process often requires an exponential number of CNOT gates, making it generally resource-intensive. We often focus on preparing initial states for which implementation resource demands are more modest. For example, product states, where qubits are not entangled, can be prepared using only single-qubit operations, significantly reducing complexity."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "140c1668",
+ "metadata": {},
+ "source": [
+ "__4. Time-evolution of the state__\n",
+ "\n",
+ "In simple terms, trotterization is a technique for approximating the exponentiation of a matrix (here the Hamiltonian, $H$), especially when the exponent contains non-commuting operators. The exponentiation is very important because the quantum mechanical time-evolution operator is\n",
+ "\n",
+ "$$\n",
+ "e^{-iHt}\n",
+ "$$\n",
+ "\n",
+ "where we have set $\\hbar=1$ by convention.\n",
+ "\n",
+ "Often the Hamiltonian $H$ consists of multiple operators that do not commute. Let us explicitly consider the simple case $H=H_A+H_B$ where $H_A$ and $H_B$, do not commute. A useful approach is to alternately apply their time-evolution exponentials over small durations $t/n$ a total of $n$ times. In the case of two these two non-commuting contributions, we would write\n",
+ "\n",
+ "$$\n",
+ "e^{−i H t}\\approx \\left(e^{−i H_A t/n}e^{−i H_B t/n}\\right)^n\n",
+ "$$\n",
+ "\n",
+ "\n",
+ "\n",
+ "This is a first-order treatment, but second-order and other variants also exist. We won't go into the details here. Simply be aware that there are multiple ways to implement this.\n",
+ "\n",
+ "$$\n",
+ "\\begin{aligned}\n",
+ "\\text{First order:} & \\qquad e^{-iHt}\\approx \\left(\\prod_j{e^{-iH_i t/n}}\\right)^n\\\\\n",
+ "\\text{Second order:} & \\qquad e^{-iHt}\\approx \\left(\\prod_{j=1}^N{e^{-iH_j t/2n}}\\right)^n\\left(\\prod_{k=N}^1{e^{-iH_k t/2n}}\\right)^n\n",
+ "\\end{aligned}\n",
+ "$$\n",
+ "\n",
+ "Here $N$ is the number of non-commuting terms $H_j$ in the Hamiltonian to be broken up in this way, and $n$ is the number of small time steps into which this evolution is broken. Note the reverse order of operators in the second product in the second-order treatment.\n",
+ "\n",
+ "See the section on trotterization in the course [Quantum Diagonalization Algorithms](https://quantum.cloud.ibm.com/learning/en/courses/quantum-diagonalization-algorithms/krylov#31-time-evolution) for more details."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "81c9e236",
+ "metadata": {},
+ "source": [
+ "__5. Circuit optimization__\n",
+ "\n",
+ "After generating the trotterized circuit, the mapping step is complete, and we can proceed to circuit optimization. This process involves several key tasks:\n",
+ "\n",
+ "- __Establishing a qubit layout__ that maps the abstract qubits of the circuit to the physical qubits on the hardware. This step is necessary because the hardware’s architecture often has specific connectivity constraints, while quantum circuit designs typically assume any qubit can interact with any other.\n",
+ "- __Inserting swap gates__ as needed to enable interactions between qubits that are not directly connected on the device.\n",
+ "- __Translating the circuit’s gates into Instruction Set Architecture (ISA) instructions__ that the hardware can execute directly.\n",
+ "- __Performing circuit optimizations__ to reduce the circuit depth and gate count. This optimization can also be applied earlier, on the virtual circuit before the qubits are assigned to specific hardware connections.\n",
+ "\n",
+ "It is important to note that much of this optimization process is handled automatically by tools in Qiskit. We will explore exactly how this works later in this lesson.\n",
+ "\n",
+ "__6. Circuit execution__\n",
+ "\n",
+ "After completing the optimization step, we are ready to execute the circuit using a primitive. We are considering a simulation experiment in which the goal is to understand how certain properties of the system change over time. For this purpose, the Estimator primitive is the most appropriate choice, as it allows you to measure the expectation values of observables that correspond to these properties.\n",
+ "\n",
+ "Next, we configure the Estimator with the best available options, including error suppression and mitigation techniques, to improve accuracy. Finally, we run the experiment to collect the results.\n",
+ "\n",
+ "__7. Post-process__\n",
+ "\n",
+ "The final step is to post-process all the collected data. This involves extracting the measured expectation values, or, if the Sampler primitive was used, the sampled probability distribution in the computational basis. When only the expectation values of the relevant observables are needed, these can be directly obtained from the Estimator primitive, available both as raw results and with error mitigation applied. Often, these measured expectation values serve as the starting point for additional calculations involving other quantities of interest. Such additional calculations typically do not require quantum computation and can be efficiently performed on a classical computer."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "e1dc04ee",
+ "metadata": {},
+ "source": [
+ "## Replicating the \"Utility\" paper\n",
+ "\n",
+ "We will now examine a concrete example from a highly influential paper published by IBM a few years ago, titled [Evidence for the Utility of Quantum Computing Before Fault Tolerance](https://www.nature.com/articles/s41586-023-06096-3), often referred to as the \"Utility paper\".\n",
+ "\n",
+ "\n",
+ "\n",
+ "Upon its release, this work quickly became a landmark study within the quantum computing community. Its central thesis is that a noisy quantum computer, utilizing 127 qubits and 2,880 gates, can produce accurate expectation values for quantum circuits that lie beyond the reach of brute-force classical simulation methods, which attempt exact simulation of the same circuits.\n",
+ "\n",
+ "This study was particularly significant because it demonstrated that quantum computers can be used to verify or compare results with approximate classical simulation methods, such as tensor network algorithms—especially in scenarios where the exact solution is unknown beforehand.\n",
+ "\n",
+ "Another remarkable aspect of this work is that it has been widely reproduced: researchers and users now have the ability to replicate and verify the experiment using IBM’s cloud-accessible quantum systems and the Qiskit software framework. In the following, we will guide you through the steps to perform this replication yourself.\n",
+ "\n",
+ "For this example, we will dive deeper into the specific steps required to translate the problem into inputs that a quantum device can process. Here, we focus on simulating the dynamics of the total magnetization in a system of magnetic dipole spins arranged on a lattice, subjected to an external magnetic field. This system can be described by an Ising model with a transverse magnetic field. We represent it using a parametrized quantum circuit, where the parameters correspond to the tunable values of the spin-spin (ZZ) interactions and the strength of the external, transverse magnetic field ($B_x$, parametrized using X).\n",
+ "\n",
+ "\n",
+ "\n",
+ "Since this series is titled Quantum Computing in Practice, we will also cover the experimental techniques used to improve the quality of the results. One important procedure involves identifying and removing \"bad\" qubits—those with low gate fidelities or short decoherence times—that could significantly impact the experiment’s outcome. Such problematic qubits may arise from poor calibration or interactions with two-level systems (TLS). Removing these qubits alters the hardware’s native topology, effectively changing the lattice on which the system is simulated.\n",
+ "\n",
+ "Additionally, we will discuss how to construct the parametrized quantum circuit that implements the system’s time-evolution using trotterization. A key part of this process is identifying entangling layers within the circuit, which play a crucial role in the main error mitigation technique we will introduce later.\n",
+ "\n",
+ "### Qiskit patterns step 1: Mapping\n",
+ "\n",
+ "The tutorial accomplishes the mapping step very much in line with the general approach described above. Specific to this problem, the tutorial\n",
+ "\n",
+ "* Creates a parameterized Ising model circuit\n",
+ "* Creates entangling layers and removes bad qubits\n",
+ "* Generates a trotterized version of the circuit\n",
+ "\n",
+ "In the tutorial, you will notice that we begin by creating a series of helper functions early in the notebook. These functions are designed to simplify the process as we proceed. These are not a required part of the procedure, but this is good common practice when working on similar experiments: break down the problem into manageable components. The functions include\n",
+ "\n",
+ "- Remove qubit couplings\n",
+ "- Define qubit couplings\n",
+ "- Construct the layer couplings\n",
+ "- Construct the entangling layer\n",
+ "- Define the trotterized circuit\n",
+ "\n",
+ "Let us explore topics related to these functions a bit more."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "fe166a67",
+ "metadata": {},
+ "source": [
+ "__Layer couplings__\n",
+ "\n",
+ "Layer couplings define how qubits interact with their neighbors during the simulation. Our quantum devices utilize a heavy-hexagonal layout, a distinctive pattern for connecting qubits. Within this layout, the connections between qubits—known as \"edges\"—can be divided into three distinct sets. Importantly, no two connections in the same set share a qubit. This organization addresses a key hardware constraint: on a real quantum computer, a qubit can participate in only one two-qubit gate at any given time.\n",
+ "\n",
+ "\n",
+ "\n",
+ "By structuring all connections into three separate layers, two-qubit gates can be applied across the entire device in three successive rounds. This ensures that no qubit is involved in more than one gate per layer. These gates implement the ZZ interaction in the Ising model, and they are repeated at each time step of the simulation (each Trotter step).\n",
+ "\n",
+ "Additionally, a technique called twirling is employed to modify noise characteristics in the device. Twirling transforms the noise such that even simple noise models become more accurate representations of the physical errors. This refinement enables more precise characterization of the noise, which can then be leveraged to improve error mitigation strategies."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "f706adfb",
+ "metadata": {},
+ "source": [
+ "__Removing \"bad\" qubits__\n",
+ "\n",
+ "The next step involves removing the “bad” qubits from the list of physical qubits available for the experiment. A qubit can become “bad” for various reasons. Sometimes it’s simply a matter of poor calibration, which can be fixed by recalibrating. In other cases, the issue is more complex and related to what’s known as a two-level system (TLS) defect. These TLS defects cause fluctuations in qubit parameters and relaxation. Resolving this often requires warming up the entire system and then cooling it down again—a process that can take some time and isn’t feasible when accessing quantum hardware remotely via the cloud.\n",
+ "\n",
+ "For now, the simplest approach is to exclude these problematic qubits from the pool of physical qubits that will be used in the experiment. The IBM Quantum platform makes it easy to identify which qubits are underperforming. You can either visualize their characteristics directly on the platform or download the data as a CSV file. From there, you create a list of qubits to exclude and remove them from the total set of physical qubits on the device.\n",
+ "\n",
+ "\n",
+ "\n",
+ "Removing unreliable qubits ensures that the system’s behavior is more predictable, which improves the accuracy of the experiment. It also allows for better noise modeling, which is essential for implementing effective error mitigation strategies."
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "1547fe81",
+ "metadata": {},
+ "source": [
+ "__Trotterized circuit__\n",
+ "\n",
+ "It is now time to construct our trotterized circuit. As discussed earlier, trotterization breaks down the time evolution into discrete steps, and we need to choose how many steps to use. For this example, we will select six steps. Generally, the approach involves balancing the trotter error—an approximation error introduced by the algorithm—with errors caused by decoherence. Increasing the number of trotter steps reduces the approximation error but requires deeper quantum circuits, which are more susceptible to decoherence noise.\n",
+ "\n",
+ "The circuit will be defined using several parameters: the theta parameter representing the strength of the external magnetic field, the couplings between layers, the number of steps, the number of qubits, and, of course, the choice of the device backend. Since the magnetization of the system depends on the external magnetic field’s strength, it is valuable to run the simulation at different magnetic field values. This variation corresponds to different rotation angles for the RX gate in the circuit.\n",
+ "\n",
+ "```\n",
+ "from qiskit.circuit import Parameter\n",
+ "\n",
+ "num_steps = 6 #Trotter steps\n",
+ "theta = Parameter(\"theta\")\n",
+ "circuit = trotter_circuit(\n",
+ " theta, layer_couplings, num_steps, qubits = good_qubits, backend = backend\n",
+ ")\n",
+ "num_params = 12\n",
+ "\n",
+ "# 12 parameter values for Rx between [0,p/2].\n",
+ "# Reshape to out product broadcast with observables\n",
+ "\n",
+ "parameter_values = np.linespace(0,np.pi/2,num_params).reshape((num_params,1))\n",
+ "num_params = parameter_values.size\n",
+ "```\n",
+ "\n",
+ "### Qiskit patterns step 2: optimize\n",
+ "\n",
+ "Now that we have generated our circuit, the next step is to optimize it. The first part of this process involves defining a pass manager. In the context of the Qiskit SDK, transpilation is the process of transforming an input circuit into a form that is suitable for execution on a quantum device. This transformation happens through a sequence of steps known as transpiler passes.\n",
+ "A pass manager is an object that holds a list of these transpiler passes and can apply them to a circuit. To create one, you initialize a PassManager with the desired list of transpiler passes. Ultimately, the pass manager produces an ISA circuit—a circuit expressed in terms of the backend’s Instruction Set Architecture (ISA). This means the circuit is represented using gates that are native to the backend hardware, although it does not yet include the timing information required to run the circuit on the device.\n",
+ "\n",
+ "### Qiskit patterns step 3: execute using primitives\n",
+ "\n",
+ "We will use the Estimator as our primary tool for this experiment because our goal is to measure the total magnetization of the system. The Estimator is specifically designed to estimate the expectation values of observables, making it the ideal choice here.\n",
+ "At this stage, it is also essential to configure our error mitigation settings. We will apply Zero Noise Extrapolation (ZNE) to improve the accuracy of our results. In the tutorial, you will see that we specify two or more noise factor values at which to evaluate the extrapolated models, and we select “Probabilistic Error Amplification” (PEA) as our amplification method. PEA is preferred for this experiment because it scales significantly better than other options, which is crucial when working with systems of 100 or more qubits.\n",
+ "\n",
+ "This is all that is required to run the experiment.\n",
+ "\n",
+ "__Error mitigation interlude__\n",
+ "\n",
+ "Before we proceed to post-processing, let’s take a brief moment to clarify what is meant by Zero Noise Extrapolation (ZNE). We have touched on this concept in earlier episodes, but it’s worth reviewing briefly. ZNE is an error mitigation technique designed to reduce the impact of unknown noise that occurs during the execution of quantum circuits, provided that this noise can be scaled in a controlled way. The method relies on the assumption that expectation values scale with noise according to a known function:\n",
+ "\n",
+ "$$\n",
+ "\\langle A(\\lambda)\\rangle = \\langle A(0)\\rangle + \\sum_{k=0}^m {a_k \\lambda^k}+R,\n",
+ "$$\n",
+ "\n",
+ "where $λ$ represents the noise strength, which can be intentionally amplified.\n",
+ "\n",
+ "The process of implementing ZNE consists of the following steps:\n",
+ "1.\tAmplify the circuit noise for various noise factors $λ_1$, $λ_2$, … .\n",
+ "2.\tExecute each noise-amplified circuit to measure the corresponding expectation values $\\langle A(\\lambda_1)\\rangle$, $\\langle A(\\lambda_2)\\rangle$, ….\n",
+ "3.\tExtrapolate these results back to the zero-noise limit \\langle $A(\\lambda_0)\\rangle$.\n",
+ "\n",
+ "\n",
+ "\n",
+ "This technique allows us to estimate what the outcome would be if there were no noise, improving the accuracy of quantum computations.\n",
+ "\n",
+ "The primary challenge in effectively implementing Zero-Noise Extrapolation (ZNE) lies in developing an accurate noise model for the expectation value and amplifying the noise in a controlled and well-understood manner. Common techniques for error amplification in ZNE include scaling pulse duration through calibration, repeating gates using identity cycles, and adding noise via sampling Pauli channels—a method known as Probabilistic Error Amplification (PEA).\n",
+ "\n",
+ "Among these, PEA is often the preferred choice for several reasons:\n",
+ "\n",
+ "* Pulse stretching incurs a high computational cost.\n",
+ "* Gate folding, which uses identity insertions, lacks strong theoretical guarantees for preserving the noise bias.\n",
+ "* PEA is applicable to any circuit executed with a native noise factor, although it requires learning the noise model in advance.\n",
+ "\n",
+ "\n",
+ "\n",
+ "PEA operates under the assumption of a layer-based noise model similar to that used in probabilistic error cancellation (PEC). However, unlike PEC, it avoids the exponential sampling overhead that typically grows with circuit noise. This efficiency makes PEA a practical and robust approach for noise amplification in ZNE, facilitating more reliable quantum error mitigation"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "id": "17f2210f",
+ "metadata": {},
+ "source": [
+ "To characterize the noise model, we first need to identify the distinct layers of two-qubit operations within the circuit. For each of these layers, we apply a Pauli twirling procedure to the two-qubit gates, which helps ensure that the noise can be accurately described by a damping noise model. Next, we repeat pairs of identity layers at various depths, and finally, we fit the fidelity values to determine the error rates for each noise channel.\n",
+ "\n",
+ "While it is beneficial to understand this method conceptually, implementing it manually in Qiskit is much simpler, as demonstrated in the accompanying tutorial.\n",
+ "\n",
+ "\n",
+ "\n",
+ "### Qiskit patterns step 4: post-processing\n",
+ "\n",
+ "The dotted gray line in the plotted data represents the results obtained using approximate classical methods, with the approximation error reduced to a low threshold. The raw data points for the various noise factors, selected at the outset, are clearly offset from this dotted line. In contrast, the solid blue line displays the data after applying our Zero-Noise Extrapolation (ZNE) processing, which noticeably brings the results much closer to the exact values.\n",
+ "In summary, the values obtained under normal noise conditions (noise factor nf=1.0nf=1.0) show significant deviation from the exact results. Meanwhile, the mitigated values align closely with the exact ones, demonstrating the effectiveness of the Phase Estimation Algorithm (PEA)-based noise mitigation technique.\n",
+ "\n",
+ "\n",
+ "\n",
+ "## Summary\n",
+ "\n",
+ "To quickly summarize what we have learned:\n",
+ "* Quantum simulation is one of the most promising application areas in the short to mid term.\n",
+ "* It has wide-ranging applications, from pharmaceuticals to high-energy physics, materials science, and more.\n",
+ "* The Utility paper from IBM, published in 2023 pointed the way towards being able to use quantum computers for scientific discovery and we worked through the associated tutorial that goes along with that paper.\n",
+ "* The steps to work through a simulation problem from start to finish are relatively straightforward, especially once you get the hang of it, and we hope that you can now use this video + tutorial as a guide for even more simulation problems."
+ ]
+ }
+ ],
+ "metadata": {
+ "description": "A review of methods in simulating natural systems as was done in the 2023 utility paper.",
+ "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"
+ },
+ "title": "Simulating nature"
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/bad-qubits.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/bad-qubits.svg
new file mode 100644
index 00000000000..099d7e02bc8
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/bad-qubits.svg
@@ -0,0 +1,1399 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/data.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/data.svg
new file mode 100644
index 00000000000..acc7fbd3ba6
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/data.svg
@@ -0,0 +1,4970 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/ham-encoding.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/ham-encoding.svg
new file mode 100644
index 00000000000..0a5c92ed477
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/ham-encoding.svg
@@ -0,0 +1,626 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/layers.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/layers.svg
new file mode 100644
index 00000000000..ae2220c3dca
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/layers.svg
@@ -0,0 +1,4726 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/lindblad.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/lindblad.svg
new file mode 100644
index 00000000000..0bd1577f892
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/lindblad.svg
@@ -0,0 +1,3964 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/noise-amp.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/noise-amp.svg
new file mode 100644
index 00000000000..e8b1f961de7
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/noise-amp.svg
@@ -0,0 +1,2471 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/prob-scale.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/prob-scale.svg
new file mode 100644
index 00000000000..466be2dc01c
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/prob-scale.svg
@@ -0,0 +1,404 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/spins-fermions.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/spins-fermions.svg
new file mode 100644
index 00000000000..00e75956128
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/spins-fermions.svg
@@ -0,0 +1,1304 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/spins-lattice.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/spins-lattice.svg
new file mode 100644
index 00000000000..0f81f34cb18
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/spins-lattice.svg
@@ -0,0 +1,115 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/trotter.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/trotter.svg
new file mode 100644
index 00000000000..73167aabb3d
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/trotter.svg
@@ -0,0 +1,143 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/utility.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/utility.svg
new file mode 100644
index 00000000000..5d1b6459265
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/utility.svg
@@ -0,0 +1,7261 @@
+
+
diff --git a/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/zne.svg b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/zne.svg
new file mode 100644
index 00000000000..904ebc06fb7
--- /dev/null
+++ b/public/learning/images/courses/quantum-computing-in-practice/simulating-nature/zne.svg
@@ -0,0 +1,1291 @@
+
+
diff --git a/qiskit_bot.yaml b/qiskit_bot.yaml
index 4f8c9454a82..6c08c2283e2 100644
--- a/qiskit_bot.yaml
+++ b/qiskit_bot.yaml
@@ -710,6 +710,8 @@ notifications:
- "@livlanes"
"learning/courses/quantum-computing-in-practice/utility-scale-qaoa":
- "@livlanes"
+ "learning/courses/quantum-computing-in-practice/simulating-nature":
+ - "@livlanes"
"learning/courses/quantum-computing-in-practice/index":
- "@livlanes"
"learning/courses/quantum-diagonalization-algorithms/index":
diff --git a/scripts/config/notebook-testing.toml b/scripts/config/notebook-testing.toml
index bf19bfcdce8..60f8ea3176a 100644
--- a/scripts/config/notebook-testing.toml
+++ b/scripts/config/notebook-testing.toml
@@ -200,6 +200,7 @@ notebooks = [
"learning/courses/quantum-computing-in-practice/mapping.ipynb",
"learning/courses/quantum-computing-in-practice/applications-of-qc.ipynb",
"learning/courses/quantum-computing-in-practice/utility-scale-qaoa.ipynb",
+ "learning/courses/quantum-computing-in-practice/simulating-nature.ipynb",
"learning/courses/quantum-diagonalization-algorithms/sqd-overview.ipynb",
"learning/courses/quantum-diagonalization-algorithms/skqd.ipynb",
"learning/courses/quantum-diagonalization-algorithms/krylov.ipynb",