diff --git a/public/images/qiskit-patterns/pattern-1.svg b/public/images/qiskit-patterns/pattern-1.svg
new file mode 100644
index 00000000000..601e0244d78
--- /dev/null
+++ b/public/images/qiskit-patterns/pattern-1.svg
@@ -0,0 +1,66 @@
+
diff --git a/public/images/qiskit-patterns/pattern-2.svg b/public/images/qiskit-patterns/pattern-2.svg
new file mode 100644
index 00000000000..8abb9dc6cce
--- /dev/null
+++ b/public/images/qiskit-patterns/pattern-2.svg
@@ -0,0 +1,67 @@
+
diff --git a/public/images/qiskit-patterns/pattern-3.svg b/public/images/qiskit-patterns/pattern-3.svg
new file mode 100644
index 00000000000..c03ca5e52eb
--- /dev/null
+++ b/public/images/qiskit-patterns/pattern-3.svg
@@ -0,0 +1,68 @@
+
diff --git a/public/images/qiskit-patterns/pattern-4.svg b/public/images/qiskit-patterns/pattern-4.svg
new file mode 100644
index 00000000000..1dd50d8f314
--- /dev/null
+++ b/public/images/qiskit-patterns/pattern-4.svg
@@ -0,0 +1,67 @@
+
diff --git a/public/images/qiskit-patterns/patterns.svg b/public/images/qiskit-patterns/patterns.svg
new file mode 100644
index 00000000000..92a772d4346
--- /dev/null
+++ b/public/images/qiskit-patterns/patterns.svg
@@ -0,0 +1,65 @@
+
diff --git a/scripts/patterns-reorg/entries.py b/scripts/patterns-reorg/entries.py
index 21137839b16..f555832ce13 100644
--- a/scripts/patterns-reorg/entries.py
+++ b/scripts/patterns-reorg/entries.py
@@ -516,7 +516,7 @@
),
Entry(
"Post-process results",
- slug="/postprocess-results",
+ slug="/post-process-results",
page_content=postprocess_index_content(
entries_as_markdown_list((RETRIEVE_RESULTS_PAGE, VISUALIZE_RESULTS_PAGE))
),
diff --git a/scripts/patterns-reorg/page_content.py b/scripts/patterns-reorg/page_content.py
index 9a0ca5c7635..43d51d5f7de 100644
--- a/scripts/patterns-reorg/page_content.py
+++ b/scripts/patterns-reorg/page_content.py
@@ -17,29 +17,31 @@ def map_content(index: str) -> str:
intro = dedent(
"""\
---
-title: Map problem to circuits
+title: Map problem to quantum circuits and operators
description: Take a classical problem and map it to run on a quantum computer.
---
-# Map problem to circuits
+# Map problem to quantum circuits and operators
-The "map problem to circuits" step of a Qiskit pattern describes how a user starts with a classical
+
+
+The "map problem to quantum circuits and operators" step of a Qiskit pattern describes how a user starts with a classical
problem and figures out how to map it to a quantum computer.
For example, in applications such as chemistry and quantum simulation, this step generally involves
constructing a quantum circuit representing the Hamiltonian you are attempting to solve.
-During this step, for certain problems, it may also be desirable to specify the mapping of
-the problem onto qubits in the heavy-hex (or gross) lattice of IBM Hardware from the
+During this step, for certain problems, it might also be desirable to specify the mapping of
+the problem onto qubits in the heavy-hex (or gross) lattice of IBM® hardware from the
outset if the structure of the problem lends itself to optimization earlier.
It is also worth considering at this point what the outcome of the particular algorithm will be
-in preparation for the later execute step, e.g. if the desired outcome involves
-inferring correlation functions using Hadamard tests, you might prepare to use `Sampler` whereas
+in preparation for the later execute step - for example, if the desired outcome involves
+inferring correlation functions using Hadamard tests, you might prepare to use `Sampler`, whereas
specifying observables would use the `Estimator` and could provide many error mitigation options.
The output of this step in a Qiskit pattern is normally a collection of circuits or quantum operators.
-## Guides
+## Guides for mapping problems to quantum circuits and operators
"""
)
return f"{intro}{index}\n"
@@ -55,14 +57,16 @@ def postprocess_index_content(index: str) -> str:
# Post-process results
+
+
This final "post-process results" step of a Qiskit pattern involves stitching the outputs from
the prior step back together to obtain the desired result. This can involve a range of classical
-data processing steps such as visualizing results, readout error mitigation techniques, marginalizing
-quasi-probability distributions to ascertain results on smaller sets of qubits or post-selection on inherent
+data-processing steps such as visualizing results, readout error mitigation techniques, marginalizing
+quasi-probability distributions to ascertain results on smaller sets of qubits, or post-selection on inherent
properties of the problem, such as total spin, parity, or particle conservation by removing
unphysical observables.
-## Guides
+## Guides for post-processing results
"""
)
return f"{intro}{index}\n"
@@ -78,19 +82,21 @@ def optimize_content(index: str) -> str:
# Optimize for target hardware
+
+
In the "optimize for target hardware" step of a Qiskit pattern, you take the abstract circuits
(or operators) produced from the map step and perform a series of optimizations on them. This
-may include mapping the route and layout of the circuit to physical qubit hardware, converting
+can include mapping the route and layout of the circuit to physical qubit hardware, converting
to basis gates of the hardware, and reducing the number of operations, all designed to optimize
-the likelihood of success in the later execute step. At this point you may also wish to debug
+the likelihood of success in the later execute step. At this point you might also wish to debug
your circuits with a simulator before executing on real hardware in the next step.
During this step, abstract circuits must be transpiled to Instruction Set Architecture (ISA) circuits.
An ISA circuit is one that only consists of gates understood by the target hardware (basis gates), and
any multi-qubit gates needed to obey any connectivity constraints (coupling map). Only ISA circuits
-can be run on IBM hardware using IBM Qiskit Runtime.
+can be run on IBM® hardware using IBM Qiskit Runtime.
-## Guides
+## Guides for optimizing for target hardware
"""
)
return f"{intro}{index}\n"
@@ -100,18 +106,20 @@ def execute_index_content(index: str) -> str:
intro = dedent(
"""\
---
-title: Execute on hardware
+title: Execute on target hardware
description: Run circuits on hardware and return output from a quantum computer.
---
-# Execute on hardware
+# Execute on target hardware
+
+
The "execute on hardware" step of a Qiskit pattern involves running your circuits on hardware
and produces the outputs of the quantum computation. The ISA circuits produced in
-the previous step, can be executed using either a Sampler or Estimator Primitive from
-Qiskit Runtime, initialised locally on your computer or from a cluster or other
-heterogeneous compute environment. These may be executed in a Batch, which allows
-parallel transpilation for classical computational efficiency, or a Session,
+the previous step can be executed using either a Sampler or Estimator primitive from
+Qiskit Runtime, initialized locally on your computer or from a cluster or other
+heterogeneous compute environment. These can be executed in a Batch, which allows
+parallel transpilation for classical computational efficiency - or a Session,
which allows iterative tasks to be implemented efficiently without queuing delays.
During this step, there is also the option to configure certain error suppression and
@@ -122,7 +130,7 @@ def execute_index_content(index: str) -> str:
in the form of bitstrings. If using the Estimator, the output will be
expectation values of observables corresponding to physical quantities or cost functions.
-## Guides
+## Guides for executing on hardware
"""
)
return f"{intro}{index}\n"
@@ -138,49 +146,61 @@ def patterns_index_content() -> str:
# Introduction to Qiskit patterns
-A Qiskit pattern is a general framework for breaking down domain-specific problems and contextualizing required capabilities in stages. This allows for the seamless composability of new capabilities developed by IBM Quantum researchers (and others) and enables a future in which quantum computing tasks are performed by powerful heterogenous (CPU/GPU/QPU) computing infrastructure. Blocks or groups of blocks perform the steps of a pattern, with the Qiskit SDK providing an important foundational layer, supported by other tools or services developed by IBM Quantum or the quantum open-source community. Qiskit patterns allow domain experts to specify a problem and compose the tooling (blocks) that achieves a Qiskit pattern, then that pattern could be executed locally, through cloud services, or deployed with Quantum Serverless.
+A Qiskit pattern is a general framework for breaking down domain-specific problems and contextualizing required capabilities in stages. This allows for the seamless composability of new capabilities developed by IBM Quantum™ researchers (and others) and enables a future in which quantum computing tasks are performed by powerful heterogenous (CPU/GPU/QPU) computing infrastructure. Blocks or groups of blocks perform the steps of a pattern, with the Qiskit SDK providing an important foundational layer, supported by other tools or services developed by IBM Quantum or the quantum open-source community. Qiskit patterns allow domain experts to specify a problem and compose the tooling (blocks) that achieves a Qiskit pattern. That pattern can then be executed locally, through cloud services, or deployed with Quantum Serverless.
The four steps of a Qiskit pattern are as follows:
-- **Map** problem to quantum circuits and operators
-- **Optimize** for target hardware
-- **Execute** on target hardware
-- **Postprocess** results
+- [**Map** problem to quantum circuits and operators](./map-problem-to-circuits)
+- [**Optimize** for target hardware](./optimize-for-hardware)
+- [**Execute** on target hardware](./execute-on-hardware)
+- [**Post-process** results](./post-process-results)
+
+
-Let's review each of these steps in more detail:
+Each step is detailed in the sections below.
## Map problem to quantum circuits and operators
-This step describes how a user starts with a classical problem and figures out how to map it to a quantum computer. For example, in applications such as chemistry and quantum simulation, this step generally involves constructing a quantum circuit representing the Hamiltonian you are attempting to solve. During this step, for certain problems, it may also be desirable to specify the mapping of the problem onto qubits in the heavy-hex (or gross) lattice of IBM Hardware from the outset if the structure of the problem lends itself to optimization earlier. It is also worth considering at this point what the outcome of the particular algorithm will be in prepartion for the later execute step, e.g. if the desired outcome involves inferring correlation functions using Hadamard tests, you might prepare to use `Sampler` whereas specifying observables would use the `Estimator` and could provide many error mitigation options.
+This step describes how a user starts with a classical problem and figures out how to map it to a quantum computer. For example, in applications such as chemistry and quantum simulation, this step generally involves constructing a quantum circuit representing the Hamiltonian you are attempting to solve. During this step, for certain problems, it might also be desirable to specify the mapping of the problem onto qubits in the heavy-hex (or gross) lattice of IBM;reg; hardware from the outset if the structure of the problem lends itself to optimization earlier. It is also worth considering at this point what the outcome of the particular algorithm will be in prepartion for the later execute step - for example, if the desired outcome involves inferring correlation functions using Hadamard tests, you might prepare to use `Sampler`, whereas specifying observables would use the `Estimator` and could provide many error mitigation options.
The output of this step is normally a collection of circuits or quantum operators that can be optimized for hardware in the next step.
## Optimize for target hardware
-In this step you take the abstract circuits (or operators) produced from the map step and perform a series of optimizations on them. This may include mapping the route and layout of the circuit to physical qubit hardware, converting to basis gates of the hardware, and reducing the number of operations, all designed to optimize the likelihood of success in the later execute step. At this point you may also wish to test out your circuits with a simulator before executing on real hardware in the next step
+In this step you take the abstract circuits (or operators) produced from the map step and perform a series of optimizations on them. This can include mapping the route and layout of the circuit to physical qubit hardware, converting to basis gates of the hardware, and reducing the number of operations, all designed to optimize the likelihood of success in the later execute step. At this point you might also wish to test out your circuits with a simulator before executing on real hardware in the next step.
+
-During this step abstract circuits must be transpiled to Instruction Set Architecture (ISA) circuits. An ISA circuit is one that only consists of gates understood by the target hardware (basis gates), and any multi-qubit gates needed to obey any connectivity constraints (coupling map). Only ISA circuits can be run on IBM hardware using IBM Qiskit Runtime.
+During this step, abstract circuits must be transpiled to Instruction Set Architecture (ISA) circuits. An ISA circuit is one that only consists of gates understood by the target hardware (basis gates), and any multi-qubit gates needed to obey any connectivity constraints (coupling map). Only ISA circuits can be run on IBM hardware using IBM Qiskit Runtime.
## Execute on target hardware
-This step involes running you circuits on hardware and produces the outputs of the quantum computation. The ISA circuits produced in the previous step, can be executed using either a Sampler or Estimator Primitive from Qiskit Runtime, initialised locally on your computer or from a cluster or other heterogeneous compute environment. These may be executed in a Batch, which allows parallel transpilation for classical computational efficiency, or a Session, which allows iterative tasks to be implemented efficiently without queuing delays. During this step there is also the option to configure certain error suppression and mitigation techniques provided by Qiskit Runtime.
+This step involes running your circuits on hardware and produces the outputs of the quantum computation. The ISA circuits produced in the previous step can be executed using either a Sampler or Estimator primitive from Qiskit Runtime, initialized locally on your computer or from a cluster or other heterogeneous compute environment. These can be executed in a Batch, which allows parallel transpilation for classical computational efficiency - or a Session, which allows iterative tasks to be implemented efficiently without queuing delays. During this step, there is also the option to configure certain error suppression and mitigation techniques provided by Qiskit Runtime.
-Depending on whether you are using the Sampler or Estimator primitive, the outcome of this step will be different. If using the Sampler the output will be per-shot measurements in the form of bitstrings. If using the Estimator the output will be expectation values of observables corresponding to physical quantities or cost functions.
+Depending on whether you are using the Sampler or Estimator primitive, the outcome of this step will be different. If using the Sampler, the output will be per-shot measurements in the form of bitstrings. If using the Estimator, the output will be expectation values of observables corresponding to physical quantities or cost functions.
## Post-process results
-This final step involves stitching the outputs from the prior step back together to obtain the desired result. This can involve a range of classical data processing steps such as visualizing results, readout error mitigation techniques, marginalizing quasi-probability distributions to ascertain results on smaller sets of qubits or post-selection on inherent properties of the problem, such as total spin, parity, or particle conservation by removing unphysical observables.
+This final step involves stitching the outputs from the prior step back together to obtain the desired result. This can involve a range of classical data-processing steps such as visualizing results, readout error mitigation techniques, marginalizing quasi-probability distributions to ascertain results on smaller sets of qubits, or post-selection on inherent properties of the problem, such as total spin, parity, or particle conservation by removing unphysical observables.
+
---
-As we move from bespoke circuit construction to utility-scale workflows, the flexibility and ease with which Qiskit Patterns allows one to compose the different steps of the pattern opens quantum computing to a wide variety of applications and techniques for easy use by quantum computational scientists.
+As the field moves from bespoke circuit construction to utility-scale workflows, the flexibility and ease with which Qiskit patterns allow users to compose the different steps of the pattern opens quantum computing to a wide variety of applications and techniques for easy use by quantum computational scientists.
+
+## Next steps
+
+
+ - Explore each step in a Qiskit pattern in more detail, starting with [Map problem to quantum circuits and operators](/map-problem-to-circuits).
+ - Run a full example of a Qiskit pattern in the [CHSH Inequality tutorial](https://learning.quantum.ibm.com/tutorial/chsh-inequality).
+
+
"""
)
@@ -190,17 +210,17 @@ def index_page_content() -> str:
"""\
---
title: Introduction to Qiskit
-description: TODO - 50+ characters long to ignore metadata check for now!
+description: What is Qiskit? This document provides an introduction to the Qiskit stack.
---
# Introduction to Qiskit
-[INSERT BIG PATTERNS AND TOOLS IMAGE]
+The name "Qiskit" is a general term referring to a collection of software for executing programs on quantum computers. Most notably among these software tools is the open-source Qiskit SDK, and the runtime environment (accessed using Qiskit Runtime) through which you can execute workloads on IBM® quantum computers. As quantum technology evolves, so does Qiskit, with new capabilities released every year that expand this core collection of quantum software.
-The name "Qiskit" is a general term referring to a collection of software for executing programs on quantum computers. Most notably among these software tools is the open-source Qiskit SDK, and the runtime environment (accessed using Qiskit Runtime) through which you can execute workloads on IBM® quantum computers. As quantum technology evolves, so does Qiskit, with new capabilities released every year which expand this core collection of quantum software.
+In addition, many open-source projects are part of the broader Qiskit ecosystem. These software tools are not part of Qiskit itself, but rather interface with Qiskit and can provide valuable additional functionality.
-In addition, there are many open-source projects that are part of the broader Qiskit ecosystem. These software tools are not part of Qiskit itself, but rather interface with Qiskit and can provide valuable additional functionality.
+
## The Qiskit SDK
@@ -209,25 +229,15 @@ def index_page_content() -> str:
Some of the most useful features of the Qiskit SDK include:
-### Circuit building tools
-([`qiskit.circuit`](/api/qiskit/circuit))
-For initializing and manipulating registers, circuits, instructions, gates, parameters, and control flow objects.
+- **Circuit-building tools** ([`qiskit.circuit`](/api/qiskit/circuit)) - For initializing and manipulating registers, circuits, instructions, gates, parameters, and control flow objects.
-### Circuit library
-([`qiskit.circuit.library`](/api/qiskit/circuit_library))
-A vast range of circuits, instructions, and gates - key building blocks for circuit-based quantum computations.
+- **Circuit library** ([`qiskit.circuit.library`](/api/qiskit/circuit_library)) - A vast range of circuits, instructions, and gates - key building blocks for circuit-based quantum computations.
-### Quantum Information
-([`qiskit.quantum_info`](/api/qiskit/quantum_info))
-A toolkit for working with quantum states, operators and channels, using exact calculations (no sampling noise). Use this module to specify input observables and analyse fidelity of outputs from primitives queries.
+- **Quantum info library** ([`qiskit.quantum_info`](/api/qiskit/quantum_info)) - A toolkit for working with quantum states, operators and channels, using exact calculations (no sampling noise). Use this module to specify input observables and analyse fidelity of outputs from primitives queries.
-### Transpiler
-([`qiskit.transpiler`](/api/qiskit/transpiler))
-For transforming and adapting quantum circuits to suit specific device topology and/or optimizing for execution on real quantum systems.
+- **Transpiler** ([`qiskit.transpiler`](/api/qiskit/transpiler)) - For transforming and adapting quantum circuits to suit specific device topology, and optimizing for execution on real quantum systems.
-### Primitives
-([`qiskit.primitives`](/api/qiskit/primitives))
-The module that contains the base definitions and reference implementations of the `Sampler` and `Estimator` primitives, from which different quantum hardware providers can derive their own implementations. See more information about the Qiskit Runtime primitives [in the documentation](./primitives).
+- **Primitives** ([`qiskit.primitives`](/api/qiskit/primitives)) - The module that contains the base definitions and reference implementations of the `Sampler` and `Estimator` primitives, from which different quantum hardware providers can derive their own implementations. See more information about the Qiskit Runtime primitives [in the documentation](./primitives).
## Qiskit Runtime
@@ -253,7 +263,7 @@ def index_page_content() -> str:
The Qiskit transpiler service ([package name `qiskit-transpiler-service`](https://pypi.org/project/qiskit-transpiler-service/)) is a new experimental service that provides remote transpilation capabilities on the cloud to IBM Quantum Premium Plan users. In addition to the local Qiskit SDK transpiler capabilities, your transpilation tasks can benefit from both IBM Quantum cloud resources and AI-powered transpiler passes using this service. To learn more about how to integrate cloud-based transpilation into your Qiskit workflow you can [check out the documentation](./qiskit-transpiler-service).
-## The Qiskit Ecosystem
+## The Qiskit ecosystem
Beyond Qiskit there are many open-source projects that use the "Qiskit" name but are not part of Qiskit itself; rather, they interface with Qiskit and can provide valuable additional functionality to supplement the core Qiskit workflow. Some of these projects are maintained by IBM Quantum teams, whereas others are supported by the broader open-source community. The Qiskit SDK is designed in a modular, extensible way to make it easy for developers to create projects like these that extend its capabilities.
@@ -265,5 +275,12 @@ def index_page_content() -> str:
- **Qiskit TOQM** `qiskit-toqm` - a transpiler plugin for a routing method that uses the Time-Optimal Qubit Mapping (TOQM) algorithm. Maintained by IBM Quantum.
You can find a catalog of projects in the [Qiskit ecosystem page](https://qiskit.github.io/ecosystem/), as well as information about how to nominate your own project.
+
+## Next steps
+
+
+ - [Install the Qiskit SDK and Qiskit Runtime](/guides/install-qiskit).
+ - Run your first quantum program with the [Hello World](/guides/hello-world) guide.
+
"""
)