diff --git a/docs/start/hello-world.ipynb b/docs/start/hello-world.ipynb
index 11d6200582f..54fa81f2f95 100644
--- a/docs/start/hello-world.ipynb
+++ b/docs/start/hello-world.ipynb
@@ -7,23 +7,42 @@
    "source": [
     "# Hello world\n",
     "\n",
-    "This Hello world example creates a simple quantum program and runs it on a quantum system. Begin with following the [Install and set up](install) instructions if you haven't already, including the steps to [Set up to use IBM Quantum™ Platform](setup-channel#set-up-to-use-ibm-quantum-platform).\n",
+    "This example contains two parts. You will first create a simple quantum program and run it on a quantum system.  Because actual quantum research requires much more robust programs, in the second section ([Scale to large numbers of qubits](#scale-to-large-numbers-of-qubits)), you will scale the simple program up to utility level.  You can also follow along with the Hello World episode of the Coding with Qiskit 1.0 video series.\n",
     "\n",
-    "We recommend that you use the [Jupyter](https://jupyter.org/install) development environment to interact with quantum computers. Be sure to install the recommended extra visualization support (`pip install qiskit[visualization]`), and note that zsh users need to put `'qiskit[visualization]'` in single quotes.\n",
+    "<iframe width=\"100%\" height=\"450\" src=\"https://www.youtube.com/embed/93-zLTppFZw?si=whJzB_FrpuorerTv\" title=\"Hello World\" frameborder=\"0\" allow=\"accelerometer; clipboard-write; encrypted-media; gyroscope; picture-in-picture\" referrerpolicy=\"strict-origin-when-cross-origin\" allowfullscreen></iframe>"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "7b65f7e0",
+   "metadata": {},
+   "source": [
+    "## Before you begin\n",
+    "\n",
+    "Follow the [Install and set up](install) instructions if you haven't already, including the steps to [Set up to use IBM Quantum&trade; Platform](setup-channel#set-up-to-use-ibm-quantum-platform).\n",
     "\n",
-    "To learn about quantum computing in general, check out the [Basics of quantum information course](https://learning.quantum.ibm.com/course/basics-of-quantum-information) in IBM Quantum Learning.\n",
+    "It is recommended that you use the [Jupyter](https://jupyter.org/install) development environment to interact with quantum computers. Be sure to install the recommended extra visualization support (`pip install qiskit[visualization]`), and note that zsh users need to put `'qiskit[visualization]'` in single quotes. You'll also need the `matplotlib` package for the second part of this example.\n",
     "\n",
-    "The four steps to writing a quantum program are\n",
     "\n",
-    "1.  Map the problem to a quantum-native format\n",
+    "To learn about quantum computing in general, visit the [Basics of quantum information course](https://learning.quantum.ibm.com/course/basics-of-quantum-information) in IBM Quantum Learning.\n",
     "\n",
-    "2.  Optimize the circuits and operators\n",
+    "The four steps to writing a quantum program using Qiskit Patterns are:\n",
     "\n",
-    "3.  Execute using a quantum primitive function\n",
+    "1.  Map the problem to a quantum-native format.\n",
     "\n",
-    "4.  Analyze the results\n",
+    "2.  Optimize the circuits and operators.\n",
     "\n",
-    "## Step 1. Map the problem to a quantum-native format"
+    "3.  Execute using a quantum primitive function.\n",
+    "\n",
+    "4.  Analyze the results."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "80471a0a",
+   "metadata": {},
+   "source": [
+    "## Create and run a simple quantum program"
    ]
   },
   {
@@ -33,6 +52,8 @@
     "raw_mimetype": "text/restructuredtext"
    },
    "source": [
+    "### Step 1. Map the problem to a quantum-native format\n",
+    "\n",
     "In a quantum program, *quantum circuits* are the native format in which to represent quantum instructions, and *operators* represent the observables to be measured. When creating a circuit, you'll usually create a new [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit#quantumcircuit) object, then add instructions to it in sequence."
    ]
   },
@@ -41,10 +62,10 @@
    "id": "21f7a26c",
    "metadata": {},
    "source": [
-    "The following code cell creates a circuit that produces a *Bell state,* which is a specific two-qubit entangled state.\n",
+    "The following code cell creates a circuit that produces a *Bell state,* which is a state wherein two (or more) qubits are fully entangled with each other.\n",
     "\n",
     "<Admonition type=\"note\" title=\"Note: bit ordering\">\n",
-    "  The Qiskit SDK uses the LSb 0 bit numbering where the $n^{th}$ digit has value $1 \\ll n$ or $2^n$. Because we usually write numbers on paper with the most significant digits to the left and the least significant digits to the right (in the Hindu-Arabic system used in most of the world), this has the consequence that the bits are labeled with indices increasing <b>from right to left</b>. This LSb 0 convention makes mathematics easier and is the most commonly used for modern digital electronics, although the opposite convention MSb 0 is also found in some domains. Converting the $i^{th}$ index between LSb 0 and MSb 0 conventions on an $n$-bit register is as simple as $i \\rightarrow n-i-1$. This differs across authors and software packages, so be aware! For more details, see the [Bit-ordering in the Qiskit SDK](../build/bit-ordering) topic.\n",
+    "  The Qiskit SDK uses the LSb 0 bit numbering where the $n^{th}$ digit has value $1 \\ll n$ or $2^n$. For more details, see the [Bit-ordering in the Qiskit SDK](../build/bit-ordering) topic.\n",
     "</Admonition>"
    ]
   },
@@ -72,7 +93,7 @@
     "from qiskit import QuantumCircuit\n",
     "from qiskit.quantum_info import SparsePauliOp\n",
     "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
-    "from qiskit_ibm_runtime import QiskitRuntimeService, EstimatorV2 as Estimator\n",
+    "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
     "\n",
     "# Create a new circuit with two qubits\n",
     "qc = QuantumCircuit(2)\n",
@@ -96,7 +117,9 @@
     "raw_mimetype": "text/restructuredtext"
    },
    "source": [
-    "See [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit#quantumcircuit) in the documentation for all available operations."
+    "See [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit#quantumcircuit) in the documentation for all available operations.\n",
+    "\n",
+    "---"
    ]
   },
   {
@@ -104,7 +127,9 @@
    "id": "f3ef4248-7938-44c1-85f1-edc997f0edcd",
    "metadata": {},
    "source": [
-    "The following code cell uses the `quantum_info` package to create six two-qubit Pauli operators. The ZZ operator means Z on qubit 0 and Z on qubit 1. If the state is entangled, then the correlation between qubit 0 and qubit 1 is one."
+    "When creating quantum circuits, you must also consider what type of data you want returned after execution. Qiskit provides two ways to return data: you can obtain a probability distribution for a set of qubits you choose to measure, or you can obtain the expectation value of an observable. Prepare your workload to measure your circuit in one of these two ways with [Qiskit primitives](../run/primitives-get-started) (explained in detail in [Step 3](#step-3-execute-using-the-quantum-primitives)).\n",
+    "\n",
+    "This example measures expectation values by using the `qiskit.quantum_info` submodule, which is specified by using operators (mathematical objects used to represent an action or process that changes a quantum state). The following code cell creates six two-qubit Pauli operators: `IZ`, `IX`, `ZI`, `XI`, `ZZ`, and `XX`."
    ]
   },
   {
@@ -117,24 +142,31 @@
    "outputs": [],
    "source": [
     "# Set up six different observables.\n",
-    "observables_labels = [\"ZZ\", \"ZI\", \"IZ\", \"XX\", \"XI\"]\n",
+    "from qiskit.quantum_info import Pauli\n",
+    "\n",
+    "ZZ = Pauli('ZZ')\n",
+    "ZI = Pauli('ZI')\n",
+    "IZ = Pauli('IZ')\n",
+    "XX = Pauli('XX')\n",
+    "XI = Pauli('XI')\n",
+    "IX = Pauli('IX')\n",
+    "\n",
+    "observables = [IZ, IX, ZI, XI, ZZ, XX]\n",
+    "observables_labels = [\"IZ\", \"IX\", \"ZI\", \"XI\", \"ZZ\", \"XX\"]\n",
     "observables = [SparsePauliOp(label) for label in observables_labels]"
    ]
   },
   {
    "cell_type": "markdown",
-   "id": "674b4019",
+   "id": "47150779",
    "metadata": {},
    "source": [
-    "<Admonition type=\"note\" title=\"Important\">\n",
-    "  To ensure faster and more efficient results, as of 1 March 2024, circuits and observables need to be transformed to only use instructions supported by the system (referred to as *instruction set architecture (ISA)* circuits and observables) before being submitted to the Qiskit Runtime primitives.  See the [transpilation documentation](../transpile) for instructions to transform circuits.  Due to this change, the primitives will no longer perform layout or routing operations.  Consequently, transpilation options referring to those tasks will no longer have any effect. By default, all primitives except Sampler V2 still optimize the input circuits. To bypass all optimization, set `optimization_level=0`.\n",
+    "<Admonition type=\"note\" title=\"Operator Notation\">\n",
     "\n",
-    "*Exception*: When you initialize the Qiskit Runtime Service with the Q-CTRL channel strategy (example below), abstract circuits are still supported.\n",
+    "Here, something like the `ZZ` operator is a shorthand for the tensor product $Z\\otimes Z$, which means measuring Z on qubit 0 and Z on qubit 1 together, and obtaining information about the correlation between qubit 0 and qubit 1. Expectation values like this are also typically written as $\\langle Z_0 Z_1 \\rangle$.\n",
+    "\n",
+    "If the state is entangled, then the measurement of $\\langle Z_0 Z_1 \\rangle$ should be 1.\n",
     "\n",
-    "> ``` python\n",
-    "> service = QiskitRuntimeService(channel=\"ibm_cloud\", channel_strategy=\"q-ctrl\")\n",
-    "> ```\n",
-    ">\n",
     "</Admonition>"
    ]
   },
@@ -143,14 +175,16 @@
    "id": "83bf9151-3bc9-40d2-8615-31570238b08e",
    "metadata": {},
    "source": [
-    "## Step 2. Optimize the circuits and operators\n",
+    "### Step 2. Optimize the circuits and operators\n",
+    "\n",
+    "When executing circuits on a device, it is important to optimize the set of instructions that the circuit contains and minimize the overall depth (roughly the number of instructions) of the circuit. This ensures that you obtain the best results possible by reducing the effects of error and noise. Additionally, the circuit's instructions must conform to a backend device's [Instruction Set Architecture (ISA)](../transpile/#instruction-set-architecture) and must consider the device's basis gates and qubit connectivity.\n",
     "\n",
-    "Even though the circuit and operators for this example are quite simple, we still need to convert its instructions into those of a backend device's [Instruction Set Architecture (ISA)](../transpile/#instruction-set-architecture).  This ensures the circuit complies with the constraints of a device (namely its native basis gates and qubit connectivity)."
+    "The following code instantiates a real device to submit a job to and transforms the circuit and observables to match that backend's ISA."
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "9a901271",
    "metadata": {},
    "outputs": [
@@ -161,21 +195,18 @@
        "<Figure size 506.997x200.667 with 1 Axes>"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     }
    ],
    "source": [
+    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
+    "\n",
     "# If you did not previously save your credentials, use the following line instead:\n",
     "# service = QiskitRuntimeService(channel=\"ibm_quantum\", token=\"<MY_IBM_QUANTUM_TOKEN>\")\n",
     "service = QiskitRuntimeService()\n",
     "\n",
-    "# Use the following code instead if you want to run on a simulator:\n",
-    "# from qiskit_ibm_runtime.fake_provider import FakeCairoV2\n",
-    "# backend = FakeCairoV2()\n",
-    "\n",
-    "# Run on the least-busy backend you have access to\n",
     "backend = service.least_busy(simulator=False, operational=True)\n",
     "\n",
     "# Convert to an ISA circuit and layout-mapped observables.\n",
@@ -190,44 +221,64 @@
    "id": "9acac1d4",
    "metadata": {},
    "source": [
-    "## Step 3. Execute using a quantum primitive function\n",
+    "### Step 3. Execute using the quantum primitives\n",
     "\n",
-    "Quantum computers can produce random results, so you'll often want to collect a sample of the outputs by running the circuit many times. You can estimate the value of the observable using the `Estimator` class. `Estimator` is one of our two [primitives](../run/primitives-get-started); the other is `Sampler`, which can be used to get data from a quantum computer.  These objects possess a `run()` method that executes the selection of circuits, observables, and parameters (if applicable), using what's known as a [primitive unified bloc (PUB)](../run/primitives#sampler-v2)."
+    "Quantum computers can produce random results, so you usually collect a sample of the outputs by running the circuit many times. You can estimate the value of the observable by using the `Estimator` class. `Estimator` is one of two [primitives](../run/primitives-get-started); the other is `Sampler`, which can be used to get data from a quantum computer.  These objects possess a `run()` method that executes the selection of circuits, observables, and parameters (if applicable), using what's known as a [primitive unified bloc (PUB).](../run/primitives#sampler-v2)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 3,
+   "execution_count": 5,
    "id": "62c4ca44",
    "metadata": {
     "tags": []
    },
    "outputs": [
     {
-     "name": "stderr",
+     "name": "stdout",
      "output_type": "stream",
      "text": [
-      "qiskit_runtime_service.__init__:INFO:2024-03-11 20:15:06,834: Default instance: ibm-q-internal/deployed/default\n",
-      "base_primitive._run:INFO:2024-03-11 20:15:30,536: Submitting job using options {'options': {'default_shots': 5000}, 'version': 2, 'support_qiskit': True, 'resilience_level': 1}\n",
-      "qiskit_runtime_service.run:INFO:2024-03-11 20:15:30,537: Instance selected: ibm-q-internal/live-data/live-data-demo\n"
+      ">>> Job ID: crkzbr74r70g0088t3ng\n"
      ]
     }
    ],
    "source": [
-    "# Construct the Estimator instance we want to use.\n",
+    "# Construct the Estimator instance.\n",
+    "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
     "\n",
-    "estimator = Estimator(backend)\n",
+    "estimator = Estimator(backend=backend)\n",
     "estimator.options.resilience_level = 1\n",
     "estimator.options.default_shots = 5000\n",
     "\n",
-    "observables = [\n",
+    "mapped_observables = [\n",
     "    observable.apply_layout(isa_circuit.layout) for observable in observables\n",
     "]\n",
     "\n",
     "# One pub, with one circuit to run against five different observables.\n",
-    "job = estimator.run([(isa_circuit, observables)])\n",
+    "job = estimator.run([(isa_circuit, mapped_observables)])\n",
     "\n",
-    "# This is the result of the entire submission.  We submitted one Pub,\n",
+    "# Use the job ID to retrieve your job data later\n",
+    "print(f\">>> Job ID: {job.job_id()}\")"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "47479e76",
+   "metadata": {},
+   "source": [
+    "After a job is submitted, you can wait until either the job is completed within your current python instance, or use the `job_id` to retrieve the data at a later time.  (See the [section on retrieving jobs](../run/monitor-job#retrieve-job-results-at-a-later-time) for details.)\n",
+    "\n",
+    "After the job completes, examine its output through the job's `result()` attribute."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "id": "792d2f01",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# This is the result of the entire submission.  You submitted one Pub,\n",
     "# so this contains one inner result (and some metadata of its own).\n",
     "job_result = job.result()\n",
     "\n",
@@ -238,10 +289,44 @@
   },
   {
    "cell_type": "markdown",
-   "id": "0d5ea9a0",
+   "id": "48317a25",
    "metadata": {},
    "source": [
-    "## Step 4. Analyze the results"
+    "<Admonition type=\"note\" title=\"Alternative: run the example using a simulator\">\n",
+    "\n",
+    "When you run your quantum program on a real device, your workload must wait in a queue before it runs. To save time, you can instead use the following code to run this small workload on the [`fake_provider`](../api/qiskit-ibm-runtime/fake_provider) with the Qiskit Runtime local testing mode. Note that this is only possible for a small circuit. When you scale up in the next section, you will need to use a real device.\n",
+    "\n",
+    "```python\n",
+    "# Use the following code instead if you want to run on a simulator:\n",
+    "\n",
+    "\n",
+    "from qiskit_ibm_runtime.fake_provider import FakeAlmadenV2\n",
+    "backend = FakeAlmadenV2()\n",
+    "\n",
+    "estimator = Estimator(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",
+    "mapped_observables = [\n",
+    "    observable.apply_layout(isa_circuit.layout) for observable in observables\n",
+    "]\n",
+    "\n",
+    "job = estimator.run([(isa_circuit, mapped_observables)])\n",
+    "result = job.result()\n",
+    "\n",
+    "\n",
+    "# This is the result of the entire submission.  You submitted one Pub,\n",
+    "# so this contains one inner result (and some metadata of its own).\n",
+    "job_result = job.result()\n",
+    "\n",
+    "# This is the result from our single pub, which had five observables,\n",
+    "# so contains information on all five.\n",
+    "pub_result = job.result()[0]\n",
+    "```\n",
+    "</Admonition>"
    ]
   },
   {
@@ -249,16 +334,16 @@
    "id": "d200d1f8",
    "metadata": {},
    "source": [
-    "<admonition type=\"note\">\n",
-    "  You might need to run `pip install matplotlib` if you do not already have it installed.\n",
-    "</admonition>\n",
+    "### Step 4. Analyze the results\n",
+    "\n",
+    "The analyze step is typically where you might postprocess your results using, for example, measurement error mitigation or zero noise extrapolation (ZNE). You might feed these results into another workflow for further analysis or prepare a plot of the key values and data. In general, this step is specific to your problem.  For this example, plot each of the expectation values that were measured for our circuit.\n",
     "\n",
-    "The `values` property is a list of expectation values for each of the observables we provided."
+    "The expectation values and standard deviations for the observables you specified to Estimator are accessed through the job result's `PubResult.data.evs` and `PubResult.data.stds` attributes. To obtain the results from Sampler, use the `PubResult.data.meas.get_counts()` function, which will return a `dict` of measurements in the form of bitstrings as keys and counts as their corresponding values. For more information, see [Get started with Sampler.](/run/primitives-get-started#get-started-with-sampler)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 7,
    "id": "87143fcc",
    "metadata": {
     "tags": []
@@ -266,17 +351,7 @@
    "outputs": [
     {
      "data": {
-      "text/plain": [
-       "<ErrorbarContainer object of 3 artists>"
-      ]
-     },
-     "execution_count": 4,
-     "metadata": {},
-     "output_type": "execute_result"
-    },
-    {
-     "data": {
-      "image/png": "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",
+      "image/png": "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",
       "text/plain": [
        "<Figure size 640x480 with 1 Axes>"
       ]
@@ -290,12 +365,15 @@
     "\n",
     "from matplotlib import pyplot as plt\n",
     "\n",
-    "data = observables_labels\n",
     "values = pub_result.data.evs\n",
     "\n",
-    "errors = pub_result.data.ensemble_standard_error\n",
+    "errors = pub_result.data.stds\n",
     "\n",
-    "plt.errorbar(observables_labels, values, yerr=errors, fmt=\"o\")"
+    "# plotting graph\n",
+    "plt.plot(observables_labels, values, '-o')\n",
+    "plt.xlabel('Observables')\n",
+    "plt.ylabel('Values')\n",
+    "plt.show()"
    ]
   },
   {
@@ -303,7 +381,220 @@
    "id": "e6a9ba84",
    "metadata": {},
    "source": [
-    "Here we see that for qubits 0 and 1, the independent values of both X and Z are 0, while the correlations are 1. This is a hallmark of quantum entanglement."
+    "Notice that for qubits 0 and 1, the independent expectation values of both X and Z are 0, while the correlations (`XX` and `ZZ`) are 1. This is a hallmark of quantum entanglement."
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bc582d8",
+   "metadata": {},
+   "source": [
+    "## Scale to large numbers of qubits\n",
+    "\n",
+    "In quantum computing, utility-scale work is crucial for making progress in the field. Such work requires computations to be done on a much larger scale; working with circuits that might use over 100 qubits and over 1000 gates. This example demonstrates how you can accomplish utility-scale work on IBM Quantum systems by creating and analyzing a 100-qubit GHZ state.  It uses the Qiskit Patterns workflow and ends by measuring the expectation value $\\langle Z_0 Z_i \\rangle $ for each qubit.\n",
+    "\n",
+    "### Step 1. Map the problem\n",
+    "\n",
+    "Write a function that returns a `QuantumCircuit` that prepares an $n$-qubit GHZ state (essentially an extended Bell state), then use that function to prepare a 100-qubit GHZ state and collect the observables to be measured."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 8,
+   "id": "2ac02692",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit import QuantumCircuit\n",
+    "\n",
+    "def get_qc_for_n_qubit_GHZ_state(n: int) -> QuantumCircuit:\n",
+    "    \"\"\"This function will create a qiskit.QuantumCircuit (qc) for an n-qubit GHZ state.\n",
+    "\n",
+    "    Args:\n",
+    "        n (int): Number of qubits in the n-qubit GHZ state\n",
+    "\n",
+    "    Returns:\n",
+    "        QuantumCircuit: Quantum circuit that generate the n-qubit GHZ state, assuming all qubits start in the 0 state\n",
+    "    \"\"\"\n",
+    "    if isinstance(n, int) and n >= 2:\n",
+    "        qc = QuantumCircuit(n)\n",
+    "        qc.h(0)\n",
+    "        for i in range(n-1):\n",
+    "            qc.cx(i, i+1)\n",
+    "    else:\n",
+    "        raise Exception(\"n is not a valid input\")\n",
+    "    return qc\n",
+    "\n",
+    "\n",
+    "from qiskit import QuantumCircuit\n",
+    "\n",
+    "# Create a new circuit with two qubits (first argument) and two classical\n",
+    "# bits (second argument)\n",
+    "n = 100\n",
+    "qc = get_qc_for_n_qubit_GHZ_state(n)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "5b3d0d74",
+   "metadata": {},
+   "source": [
+    "Next, map to the operators of interest. This example uses the `ZZ` operators between qubits to examine the behavior as they get farther apart.  Increasingly inaccurate (corrupted) expectation values between distant qubits would reveal the level of noise on the system."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 9,
+   "id": "863a4ec9",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "['ZZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZIII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZII', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZI', 'ZIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIIZ']\n",
+      "99\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit.quantum_info import SparsePauliOp\n",
+    "\n",
+    "# ZZII...II, ZIZI...II, ... , ZIII...ZZ\n",
+    "operator_strings = ['Z' + 'I'*i + 'Z' + 'I'*(n-2-i) for i in range(n-1)]\n",
+    "print(operator_strings)\n",
+    "print(len(operator_strings))\n",
+    "\n",
+    "operators = [SparsePauliOp(operator) for operator in operator_strings]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "a0b462ce",
+   "metadata": {},
+   "source": [
+    "### Step 2. Optimize the problem for execution on quantum hardware\n",
+    "\n",
+    "Transform the circuit and observables to match the backend's ISA."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 10,
+   "id": "428f05e7",
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager\n",
+    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
+    "\n",
+    "# If you did not previously save your credentials, use the following line instead:\n",
+    "# service = QiskitRuntimeService(channel=\"ibm_quantum\", token=\"<MY_IBM_QUANTUM_TOKEN>\")\n",
+    "service = QiskitRuntimeService()\n",
+    "\n",
+    "backend = service.least_busy(simulator=False, operational=True, min_num_qubits=100)\n",
+    "pm = generate_preset_pass_manager(optimization_level=1, backend=backend)\n",
+    "\n",
+    "isa_circuit = pm.run(qc)\n",
+    "isa_operators_list = [op.apply_layout(isa_circuit.layout) for op in operators]"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "2d2b5065",
+   "metadata": {},
+   "source": [
+    "### Step 3. Execute on hardware\n",
+    "\n",
+    "Submit the job and enable error suppression by using a technique to reduce errors called [dynamical decoupling.](../api/qiskit-ibm-runtime/qiskit_ibm_runtime.options.DynamicalDecouplingOptions) The resilience level specifies how much resilience to build against errors. Higher levels generate more accurate results, at the expense of longer processing times.  For further explanation of the options set in the following code, see [Configure error mitigation for Qiskit Runtime.](../run/configure-error-mitigation)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 11,
+   "id": "3aaa5025",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "crkzc58akhw0008exd0g\n"
+     ]
+    }
+   ],
+   "source": [
+    "from qiskit_ibm_runtime import EstimatorOptions\n",
+    "from qiskit_ibm_runtime import EstimatorV2 as Estimator\n",
+    "\n",
+    "options = EstimatorOptions()\n",
+    "options.resilience_level = 1\n",
+    "options.optimization_level = 0\n",
+    "options.dynamical_decoupling.enable = True\n",
+    "options.dynamical_decoupling.sequence_type = \"XY4\"\n",
+    "\n",
+    "# Create an Estimator object\n",
+    "estimator = Estimator(backend, options=options)\n",
+    "\n",
+    "# Submit the circuit to Estimator\n",
+    "job = estimator.run([(isa_circuit, isa_operators_list)])\n",
+    "job_id = job.job_id()\n",
+    "print(job_id)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0bc64091",
+   "metadata": {},
+   "source": [
+    "### Step 4. Post-process results\n",
+    "\n",
+    "After the job completes, plot the results and notice that $\\langle Z_0 Z_i \\rangle$ decreases with increasing $i$, even though in an ideal simulation all $\\langle Z_0 Z_i \\rangle$ should be 1."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 12,
+   "id": "de91ebd0",
+   "metadata": {},
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 640x480 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
+   "source": [
+    "import matplotlib.pyplot as plt\n",
+    "import numpy as np\n",
+    "from qiskit_ibm_runtime import QiskitRuntimeService\n",
+    "\n",
+    "# data\n",
+    "data = list(range(1, len(operators)+1)) # Distance between the Z operators\n",
+    "result = job.result()[0] # Use for EstimatorV2.\n",
+    "values = result.data.evs # Expectation value at each Z operator. Use for Estimator V2.\n",
+    "# values = job.result().values # Use for EstimatorV1\n",
+    "values = [v / values[0] for v in values] # Normalize the expectation values to evaluate how they decay with distance.\n",
+    "\n",
+    "# plotting graph\n",
+    "plt.scatter(data, values, marker='o', label='100-qubit GHZ state')\n",
+    "plt.xlabel('Distance between qubits $i$')\n",
+    "plt.ylabel(r'$\\langle Z_0 Z_i \\rangle / \\langle Z_0 Z_1 \\rangle $')\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "id": "0afc307c",
+   "metadata": {},
+   "source": [
+    "The previous plot shows that as the distance between qubits increases, the signal decays because there is noise on the system."
    ]
   },
   {
@@ -314,9 +605,8 @@
     "## Next steps\n",
     "\n",
     "<Admonition type=\"tip\" title=\"Recommendations\">\n",
-    "  *   Learn how to [build circuits](../build/) in more detail.\n",
-    "\n",
-    "  *   Try one of the [workflow example tutorials.](https://learning.quantum.ibm.com/catalog/tutorials?category=workflow-example)\n",
+    "  -   Learn how to [build circuits](../build/) in more detail.\n",
+    "  -   Try one of the [workflow example tutorials.](https://learning.quantum.ibm.com/catalog/tutorials?category=workflow-example)\n",
     "</Admonition>"
    ]
   }
diff --git a/public/images/start/hello-world/qiskit-patterns.png b/public/images/start/hello-world/qiskit-patterns.png
new file mode 100644
index 00000000000..eec6764f8d0
Binary files /dev/null and b/public/images/start/hello-world/qiskit-patterns.png differ