remove trademark from Qiskit and update readme (#946)

README.md

@@ -599,9 +599,10 @@ Some companies require a special attribution notice. View a list of the companie
 - IBM®
 - IBM Cloud®
 - IBM Quantum™
-- Qiskit®
 </details>
 
+**Note**: Although Qiskit is a registered trademark of IBM, we do not mark it as such.
+
 See the Usage section of the IBM Quantum Experience Guide for guidance on when to use IBM and when to use IBM Quantum.
 
 ### Trademark symbols
@@ -612,6 +613,4 @@ Use `&reg;` to get &reg; for registered trademarks.
 
 use `&trade;` to get &trade; for nonregistered trademarks.
 
-<Admonition type="caution">
-  Do not include trademarks in headings. The code will display rather than the symbol.
-</Admonition
+⚠️ **Note**: Do not include trademarks in headings. The code will display rather than the symbol.

docs/api/migration-guides/index.mdx

@@ -6,7 +6,7 @@ description: Migrate to using the newest from Qiskit and Qiskit Runtime
 
 # Introduction
 
-These migration guides help you more effectively use Qiskit® and Qiskit Runtime:
+These migration guides help you more effectively use Qiskit and Qiskit Runtime:
 
 * Migrate to Qiskit 1.0
    * [Qiskit 1.0 packaging changes](/api/migration-guides/qiskit-1.0-installation)

docs/api/migration-guides/qiskit-1.0-features.mdx

@@ -5,7 +5,7 @@ description: Description of feature changes introduced in Qiskit 1.0 and how to
 
 # Qiskit 1.0 feature changes
 
-This guide describes migration paths for the most important feature changes in Qiskit®  1.0, organized by module.
+This guide describes migration paths for the most important feature changes in Qiskit 1.0, organized by module.
 Use the table of contents on the right side to navigate to the module you are interested in.
 
 ## Qiskit 1.0 migration tool

docs/api/migration-guides/qiskit-1.0-installation.mdx

@@ -5,7 +5,7 @@ description: Adapt to changes in installing and depending on Qiskit 1.0
 
 # Qiskit 1.0 packaging changes
 
-Qiskit® 1.0 uses a different packaging structure than previous Qiskit versions and might cause problems in environments that use packages that are not ready for Qiskit 1.0.
+Qiskit 1.0 uses a different packaging structure than previous Qiskit versions and might cause problems in environments that use packages that are not ready for Qiskit 1.0.
 
 <Admonition type="caution">
 Do not try to upgrade an existing Python virtual environment to Qiskit 1.0 in-place.

docs/api/migration-guides/qiskit-1.0.mdx

@@ -5,7 +5,7 @@ description: How to update your project so that it works with Qiskit 1.0.
 
 # Qiskit 1.0 migration guide
 
-Qiskit® 1.0 brings new stability guarantees and performance improvements, but it
+Qiskit 1.0 brings new stability guarantees and performance improvements, but it
 does break compatibility with all previous versions of Qiskit. See the
 following guides on updating your environment and code to work with Qiskit 1.0.
 

docs/api/migration-guides/qiskit-algorithms-module.mdx

@@ -5,7 +5,7 @@ description: How to update your code to use the new interface for `qiskit.algori
 
 # Algorithms migration guide
 
-  In Qiskit® 0.44 and later releases, the `qiskit.algorithms` module has been superseded by a new standalone library, `qiskit_algorithms`,
+  In Qiskit 0.44 and later releases, the `qiskit.algorithms` module has been superseded by a new standalone library, `qiskit_algorithms`,
   available on [GitHub](https://github.com/qiskit-community/qiskit-algorithms) and 
   [PyPi](https://pypi.org/project/qiskit-algorithms). The `qiskit.algorithms` module  was migrated to a
   separate package in order to clarify the purpose of Qiskit and make a distinction between the tools and libraries built on top of it.

docs/api/migration-guides/qiskit-opflow-module.mdx

@@ -8,7 +8,7 @@ description: How to update your code to stop using the deprecated `qiskit.opflow
 The new [`qiskit.primitives`](../qiskit/primitives), in combination with the [`qiskit.quantum_info`](../qiskit/quantum_info) module, have superseded
 functionality of [`qiskit.opflow`](../qiskit/0.46/opflow), which is being deprecated.
 
-This migration guide contains instructions and code examples to migrate Qiskit® code that uses 
+This migration guide contains instructions and code examples to migrate Qiskit code that uses 
 the [`qiskit.opflow`](../qiskit/0.46/opflow) module to the [`qiskit.primitives`](../qiskit/primitives) and [`qiskit.quantum_info`](../qiskit/quantum_info) modules.
 
 <Admonition type="note">

docs/api/migration-guides/qiskit-quantum-instance.mdx

@@ -28,7 +28,7 @@ The remainder of this guide focused on the [`qiskit.utils.QuantumInstance.execut
 [`qiskit.primitives`](../qiskit/primitives) migration path.
 
 <Admonition type="caution">
-  **Background on the Qiskit&reg; primitives**
+  **Background on the Qiskit primitives**
 
   The Qiskit primitives are algorithmic abstractions that encapsulate system or simulator access for easy integration into algorithm workflows.
 

docs/api/migration-guides/qiskit-runtime-examples.mdx

@@ -6,7 +6,7 @@ description: Examples of migrating from using backend.run to using Qiskit Runtim
 
 # Migration examples
 
-Follow these examples to design a Qiskit® Runtime algorithm.
+Follow these examples to design a Qiskit Runtime algorithm.
 
 <span id="estimator-algorithm"></span>
 ## Use Estimator to design an algorithm

docs/api/migration-guides/qiskit-runtime-from-provider.mdx

@@ -5,7 +5,7 @@ description: How to migrate `backend.run()` from Qiskit IBM Provider to Qiskit I
 
 # Migrate `backend.run()` from `qiskit_ibm_provider` to `qiskit_ibm_runtime`
 
-The Qiskit® Runtime interface includes two packages:
+The Qiskit Runtime interface includes two packages:
 Qiskit IBM Provider (the [`qiskit_ibm_provider`](../qiskit-ibm-provider) package) and
 Qiskit IBM Runtime (the [`qiskit_ibm_runtime`](../qiskit-ibm-runtime) package). Until now,
 primitives (`Sampler` and `Estimator`)

docs/api/migration-guides/qiskit-runtime.mdx

@@ -11,7 +11,7 @@ in_page_toc_max_heading_level: 2
 
 This guide describes key patterns of behavior and use cases with code
 examples to help you migrate code from the legacy `qiskit-ibmq-provider`
-package to use the Qiskit® Runtime primitives.
+package to use the Qiskit Runtime primitives.
 
 ## Overview
 

docs/build/bit-ordering.mdx

@@ -11,7 +11,7 @@ these bits both in computer memory and when displayed on-screen.
 
 ## Qiskit conventions
 
-Here's how Qiskit® orders bits in different scenarios.
+Here's how Qiskit orders bits in different scenarios.
 
 ### Quantum circuits
 

docs/build/circuit-construction.ipynb

@@ -13,7 +13,7 @@
    "id": "c50d8e43-ae82-4e41-8d17-a37332d1bf6d",
    "metadata": {},
    "source": [
-    "This page takes a closer look at the [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit) class in Qiskit®, including some more advanced methods you can use to create quantum circuits."
+    "This page takes a closer look at the [`QuantumCircuit`](/api/qiskit/qiskit.circuit.QuantumCircuit) class in Qiskit, including some more advanced methods you can use to create quantum circuits."
    ]
   },
   {

docs/build/circuit-library.ipynb

@@ -14,7 +14,7 @@
    "id": "6f257ff9-15c4-48d8-9503-7f0ab16a91b2",
    "metadata": {},
    "source": [
-    "Qiskit® includes a library of popular circuits to use as building blocks in your own programs. Using pre-defined circuits saves time researching, writing code, and debugging. The library includes popular circuits in quantum computing, circuits that are difficult to simulate classically, and circuits useful for quantum hardware benchmarking.\n",
+    "Qiskit includes a library of popular circuits to use as building blocks in your own programs. Using pre-defined circuits saves time researching, writing code, and debugging. The library includes popular circuits in quantum computing, circuits that are difficult to simulate classically, and circuits useful for quantum hardware benchmarking.\n",
     "\n",
     "This page lists the different circuit categories the library provides. For a full list of circuits, see the [circuit library API documentation](/api/qiskit/circuit_library)."
    ]

docs/build/circuit-visualization.ipynb

@@ -13,7 +13,7 @@
    "id": "6cab750e-ca5d-48c0-b69b-040eee04a506",
    "metadata": {},
    "source": [
-    "A visualization is useful while working with quantum circuits. Below find options in Qiskit® for drawing circuits, plotting data from executed jobs, seeing the state of a quantum computer, and more."
+    "A visualization is useful while working with quantum circuits. Below find options in Qiskit for drawing circuits, plotting data from executed jobs, seeing the state of a quantum computer, and more."
    ]
   },
   {

docs/build/classical-feedforward-and-control-flow.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Classical feedforward and control flow\n",
     "\n",
-    "This guide demonstrates the functionality available in Qiskit® for performing classical feedforward and control flow. These features are sometimes referred to collectively as \"dynamic circuits.\" Classical feedforward refers to the ability to measure qubits in the middle of a circuit and perform additional quantum operations that depend on the measurement outcome. Qiskit supports four control flow constructs for classical feedforward, each implemented as a method on [`QuantumCircuit`](../api/qiskit/qiskit.circuit.QuantumCircuit). The constructs and their corresponding methods are:\n",
+    "This guide demonstrates the functionality available in Qiskit for performing classical feedforward and control flow. These features are sometimes referred to collectively as \"dynamic circuits.\" Classical feedforward refers to the ability to measure qubits in the middle of a circuit and perform additional quantum operations that depend on the measurement outcome. Qiskit supports four control flow constructs for classical feedforward, each implemented as a method on [`QuantumCircuit`](../api/qiskit/qiskit.circuit.QuantumCircuit). The constructs and their corresponding methods are:\n",
     "\n",
     "- If statement - [`QuantumCircuit.if_test`](../api/qiskit/qiskit.circuit.QuantumCircuit#if_test)\n",
     "- Switch statement - [`QuantumCircuit.switch`](../api/qiskit/qiskit.circuit.QuantumCircuit#switch)\n",

docs/build/index.mdx

@@ -10,7 +10,7 @@ In the build phase, you create quantum programs that represent the problem you a
 
 All tasks require building one or more [quantum circuits](circuit-construction). Some tasks additionally require constructing [quantum operators](operators-overview) to define properties of quantum states that you want to estimate or measure.
 
-Qiskit® enables working with circuits (and, to some extent, operators) at various abstraction levels: abstract, virtual, physical, scheduled, and pulse programs. At the most abstract level is a task-oriented lens in the [circuit library](circuit-library). You can also express operations in abstract mathematical terms using operators, isometries, and classical/Boolean functions. For virtual circuits, mathematical abstractions take on a concrete representation in terms of a concrete gate set. At the physical level, those instructions are mapped to specific physical qubits, and instructions are re-written to reflect the connectivity and native gate set of a target hardware platform. Scheduled circuits introduce timing information, and [pulse programs](pulse) represent signals on channels.
+Qiskit enables working with circuits (and, to some extent, operators) at various abstraction levels: abstract, virtual, physical, scheduled, and pulse programs. At the most abstract level is a task-oriented lens in the [circuit library](circuit-library). You can also express operations in abstract mathematical terms using operators, isometries, and classical/Boolean functions. For virtual circuits, mathematical abstractions take on a concrete representation in terms of a concrete gate set. At the physical level, those instructions are mapped to specific physical qubits, and instructions are re-written to reflect the connectivity and native gate set of a target hardware platform. Scheduled circuits introduce timing information, and [pulse programs](pulse) represent signals on channels.
 
 Qiskit and [OpenQASM](introduction-to-qasm) further support the notion of extended circuits, which expand the set of allowed operations to include real-time computations on classical values. Qiskit's tooling for working with this richer family of circuits is found in the section on [Classical feedforward and control flow](classical-feedforward-and-control-flow).
 

docs/build/interoperate-qiskit-qasm2.mdx

@@ -6,7 +6,7 @@ description: How to convert code between OpenQASM 2 and Qiskit.
 
 # OpenQASM 2 and Qiskit
 
-Qiskit® provides some tools for converting between OpenQASM representations of quantum programs, and the [QuantumCircuit](../api/qiskit/qiskit.circuit.QuantumCircuit) class.
+Qiskit provides some tools for converting between OpenQASM representations of quantum programs, and the [QuantumCircuit](../api/qiskit/qiskit.circuit.QuantumCircuit) class.
 
 ## Import an OpenQASM 2 program into Qiskit
 

docs/build/interoperate-qiskit-qasm3.mdx

@@ -6,7 +6,7 @@ description: How to convert code between OpenQASM 3 and Qiskit.
 
 # OpenQASM 3 and Qiskit
 
-Qiskit® provides some tools for converting between OpenQASM representations of quantum programs, and the QuantumCircuit class. Note these tools are still in an exploratory phase of development and will continue to evolve as Qiskit’s support for dynamic circuit capabilities expressed by OpenQASM 3 increases.
+Qiskit provides some tools for converting between OpenQASM representations of quantum programs, and the QuantumCircuit class. Note these tools are still in an exploratory phase of development and will continue to evolve as Qiskit’s support for dynamic circuit capabilities expressed by OpenQASM 3 increases.
 
 <Admonition type="note">
 This function is still in the exploratory phase.  Therefore, it is likely that the syntax and capabilities will evolve.

docs/build/introduction-to-qasm.mdx

@@ -15,7 +15,7 @@ OpenQASM is the choice for a variety of audiences because of its versatility. Th
 
 OpenQASM is the common interchange format among independent quantum software tools. For developers that prefer one tool for circuit construction, another for transpilation, and so forth, OpenQASM is the *lingua franca* that acts as a bridge among them.  
 
- Qiskit® provides ways to convert between OpenQASM and the [`QuantumCircuit`](../api/qiskit/qiskit.circuit.QuantumCircuit) class (see [OpenQASM 2 and Qiskit](interoperate-qiskit-qasm2) and [OpenQASM 3 and Qiskit](interoperate-qiskit-qasm3) for instructions).  
+ Qiskit provides ways to convert between OpenQASM and the [`QuantumCircuit`](../api/qiskit/qiskit.circuit.QuantumCircuit) class (see [OpenQASM 2 and Qiskit](interoperate-qiskit-qasm2) and [OpenQASM 3 and Qiskit](interoperate-qiskit-qasm3) for instructions).  
 
 For more information, view the [OpenQASM live specification.](https://openqasm.com/)
 

docs/build/operators-overview.ipynb

@@ -13,7 +13,7 @@
    "id": "8a16a455-4530-4f2e-be6c-8c0da255b1c5",
    "metadata": {},
    "source": [
-    "The `Operator` class is used in Qiskit® to represent matrix operators acting on a quantum system. It has several methods to build composite operators using tensor products of smaller operators, and to compose operators.\n",
+    "The `Operator` class is used in Qiskit to represent matrix operators acting on a quantum system. It has several methods to build composite operators using tensor products of smaller operators, and to compose operators.\n",
     "\n",
     "### Creating Operators\n",
     "\n",

docs/build/pulse.ipynb

@@ -11,7 +11,7 @@
     "\n",
     "Most quantum algorithms can be described with circuit operations alone. When you need more control over the low-level program implementation, you can use _pulse gates_. Pulse gates remove the constraint of executing circuits with basis gates only and let you override the default implementation of any basis gate.\n",
     "\n",
-    "Pulse gates let you map a logical circuit gate (for example, `X`) to a Qiskit® Pulse program, called a `ScheduleBlock`. This mapping is referred to as a _calibration_. A high-fidelity calibration is one that faithfully implements the logical operation it is mapped from (for example, whether the `X` gate calibration drives $|0\\rangle$ to $|1\\rangle$).\n",
+    "Pulse gates let you map a logical circuit gate (for example, `X`) to a Qiskit Pulse program, called a `ScheduleBlock`. This mapping is referred to as a _calibration_. A high-fidelity calibration is one that faithfully implements the logical operation it is mapped from (for example, whether the `X` gate calibration drives $|0\\rangle$ to $|1\\rangle$).\n",
     "\n",
     "A schedule specifies the exact time dynamics of the input signals across all input _channels_ to the device. There are usually multiple channels per qubit, such as drive and measure. This interface is more powerful, and requires a deeper understanding of the underlying device physics.\n",
     "\n",

docs/build/qasm-feature-table.mdx

@@ -72,7 +72,7 @@ Key:
 
 <Admonition type="tip" title="Recommendations">
     - Learn how to generate OpenQASM code in the [Explore gates and circuits with the Quantum Composer](https://learning.quantum.ibm.com/tutorial/explore-gates-and-circuits-with-the-quantum-composer) tutorial.
-    - See the [OpenQASM 3 Qiskit&reg; API](/api/qiskit/qasm3) reference.
+    - See the [OpenQASM 3 Qiskit API](/api/qiskit/qasm3) reference.
     - See the [OpenQASM 2 Qiskit API](/api/qiskit/qasm2) reference.
     - Review the [Verify your program](../verify/) topic.
     - Visit the [OpenQASM Live Specification](https://openqasm.com/).

docs/build/specify-observables-pauli.mdx

@@ -46,7 +46,7 @@ $$
 
 where the indices $\langle i, j\rangle$ run over interacting spins and the spins are subject to a transversal field in $X$.
 The subscript index indicates which qubit the Pauli operator acts on, i.e. $X_i$ applies an $X$ operator on qubit $i$ and leaves the rest unchanged.
-In Qiskit®, this Hamiltonian could be constructed as 
+In Qiskit, this Hamiltonian could be constructed as 
 
 ```python
 from qiskit.quantum_info import SparsePauliOp

docs/build/unitary-synthesis.mdx

@@ -15,7 +15,7 @@ For general unitary matrices, synthesis is a complex task with computational cos
 Therefore, if you know an efficient decomposition for the unitary you would like to implement, it will likely be better than a general synthesis.
 
 <Admonition type="note">
-    If no decomposition is available, Qiskit&reg; provides you with the tools to find one. 
+    If no decomposition is available, Qiskit provides you with the tools to find one. 
     However, note that this generally generates deep circuits that may be unsuitable to run on noisy quantum computers.
 </Admonition>
 

docs/run/advanced-runtime-options.mdx

@@ -15,7 +15,7 @@ To ensure faster and more efficient results, as of 1 March 2024, circuits and ob
 ![The image shows the top-level options categories: transpilation, resilience, execution, environment, and simulation.](/images/build/options.png "Option categories")
 
 <Admonition type="info" title="Attention">
-    This section focuses on Qiskit&reg; Runtime primitive [Options](../api/qiskit-ibm-runtime/qiskit_ibm_runtime.options.Options) (imported from `qiskit_ibm_runtime`). While most of the `primitives` interface is common across implementations, most `Options` are not. Consult the
+    This section focuses on Qiskit Runtime primitive [Options](../api/qiskit-ibm-runtime/qiskit_ibm_runtime.options.Options) (imported from `qiskit_ibm_runtime`). While most of the `primitives` interface is common across implementations, most `Options` are not. Consult the
     corresponding API references for information about the `qiskit.primitives` and `qiskit_aer.primitives` options.
 </Admonition>
 

docs/run/circuit-execution.mdx

@@ -26,4 +26,4 @@ Therefore, each circuit is equal in duration to the longest circuit in the batch
 
 ## Dynamic repetition rate execution
 
-Some IBM Quantum systems allow for dynamic repetition rate execution. These systems are identified in Qiskit® using `backend.configuration().dynamic_reprate_enabled`, and return a value of `True`. On these systems, it is possible to manually set the above idle time by setting the `rep_delay` of the submitted job. One can see from the above figures that by reducing the idle time one can potentially see a greater throughput of circuits on the systems that support dynamic repetition rates. See the the next section on conditional reset for more detailed usage examples.
+Some IBM Quantum systems allow for dynamic repetition rate execution. These systems are identified in Qiskit using `backend.configuration().dynamic_reprate_enabled`, and return a value of `True`. On these systems, it is possible to manually set the above idle time by setting the `rep_delay` of the submitted job. One can see from the above figures that by reducing the idle time one can potentially see a greater throughput of circuits on the systems that support dynamic repetition rates. See the the next section on conditional reset for more detailed usage examples.

docs/run/configure-error-mitigation.mdx

@@ -61,7 +61,7 @@ applied at each resilience level.
 </Admonition>
 
 <Admonition type="note">
-  If using an IBM Cloud&reg; Qiskit&reg; Runtime service instance with Q-CTRL performance management enabled, there is no need to specify runtime optimization or resilience levels, as the strategy includes an automatic preset.
+  If using an IBM Cloud&reg; Qiskit Runtime service instance with Q-CTRL performance management enabled, there is no need to specify runtime optimization or resilience levels, as the strategy includes an automatic preset.
   
   Setting `optimization_level` or `resilience_level` equal to 0 will result in an
   execution error. Levels 1, 2, and 3 are permitted but will not impact performance.

docs/run/dynamic-circuits-considerations.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Hardware considerations and limitations for classical feedforward and control flow\n",
     "\n",
-    "[Classical feedforward and control flow](/build/classical-feedforward-and-control-flow) shows how to use Qiskit® to build circuits that involve classical feedforward and control flow, also known as dynamic circuits. When actually running such circuits on quantum hardware, there are several considerations and limitations to be aware of. Many of these limitations exist because the underlying technology supporting these features is in an early stage of development, and we hope to be able to address them in the future.\n",
+    "[Classical feedforward and control flow](/build/classical-feedforward-and-control-flow) shows how to use Qiskit to build circuits that involve classical feedforward and control flow, also known as dynamic circuits. When actually running such circuits on quantum hardware, there are several considerations and limitations to be aware of. Many of these limitations exist because the underlying technology supporting these features is in an early stage of development, and we hope to be able to address them in the future.\n",
     "\n",
     "## Primitives do not currently support classical feedforward and control flow\n",
     "\n",

docs/run/estimate-job-run-time.mdx

@@ -12,7 +12,7 @@ Quantum time is the duration, in seconds, a quantum system is committed to fulfi
 
 <Admonition type="note" title="Notes">
     - This only applies to jobs that use primitives.
-    - This is not yet available on the Qiskit&reg; Runtime on IBM Cloud&reg; channel. 
+    - This is not yet available on the Qiskit Runtime on IBM Cloud&reg; channel. 
 </Admonition>
 
 <Admonition type="caution" title="Important">

docs/run/fair-share-queue.mdx

@@ -10,7 +10,7 @@ When you submit a job to a quantum system, it enters the scheduler for the speci
 
 ## Fair-share terms
 
-*   **Provider:** An entity providing access to quantum computing. IBM Quantum™ Platform and IBM Cloud® are providers of Qiskit® Runtime services.
+*   **Provider:** An entity providing access to quantum computing. IBM Quantum™ Platform and IBM Cloud® are providers of Qiskit Runtime services.
 *   **Instance:** A combination of hub/group/project.
 *   **Hub:** Represents the top level of an organization such as an academic, industry, or research partner.
 *   **Group:** A mid-level structure to which access shares can be allocated by the hub for one or more collections of users (projects).

docs/run/get-backend-information.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Get backend information with Qiskit\n",
     "\n",
-    "This page explains how to use Qiskit® to find information about your available backends."
+    "This page explains how to use Qiskit to find information about your available backends."
    ]
   },
   {

docs/run/manage-cost.mdx

@@ -9,7 +9,7 @@ description: How to manage costs of running jobs on systems when using the Stand
 The IBM Cloud® Quantum Standard plan is not free, except when running jobs on simulators. Use the information in this topic to help you understand how much you’re paying and how to limit your costs.
 
 <Admonition type="note">
-  The information in this topic only applies to those who are using the Standard plan for Qiskit&reg; Runtime on IBM Cloud.  There are no costs associated with IBM Quantum&trade; Platform Open plan.
+  The information in this topic only applies to those who are using the Standard plan for Qiskit Runtime on IBM Cloud.  There are no costs associated with IBM Quantum&trade; Platform Open plan.
 </Admonition>
 
 ## Set a cost limit

docs/run/max-execution-time.mdx

@@ -6,7 +6,7 @@ description: Describes how long a Qiskit Runtime job or session can run.
 
 # Maximum execution time for a Qiskit Runtime job or session
 
-To ensure fairness and help control costs, there is a maximum amount of time each Qiskit® Runtime job and session can run. If a job exceeds this time limit, it is forcibly canceled and a `RuntimeJobMaxTimeoutError` exception is raised. If a session exceeds its limits, any queued jobs are canceled but any jobs that are already running are not. 
+To ensure fairness and help control costs, there is a maximum amount of time each Qiskit Runtime job and session can run. If a job exceeds this time limit, it is forcibly canceled and a `RuntimeJobMaxTimeoutError` exception is raised. If a session exceeds its limits, any queued jobs are canceled but any jobs that are already running are not. 
 
 <span id="max-job"></span>
 ## Job maximum execution time

docs/run/minimize-time.mdx

@@ -10,7 +10,7 @@ There are several ways you can limit the amount of quantum time spent processing
 
 - Run only as many iterations and shots as you need: The time your workload takes (and therefore, its cost) depends on how many jobs you create in a session and how many shots are run in each job. Therefore, you can manage your cost by running only as many jobs and shots as you need.
 
-- Set limits on execution time:  You can limit how long each job or session runs.  For details, see [Maximum execution time for a Qiskit® Runtime job or session](max-execution-time).
+- Set limits on execution time:  You can limit how long each job or session runs.  For details, see [Maximum execution time for a Qiskit Runtime job or session](max-execution-time).
 
 - Use only the necessary settings for error suppression, error mitigation, and optimization, because higher values can cause your jobs to run longer. See [Algorithm tuning options](advanced-runtime-options), [Configure runtime compilation](configure-runtime-compilation), and [Configure error mitigation](configure-error-mitigation) for details.
 

docs/run/monitor-job.mdx

@@ -26,7 +26,7 @@ Use the job instance to check the job status or retrieve the results by calling
 Call `service.job(\<job\how_toID>)` to retrieve a job you previously submitted. If you don’t have the job ID, or if you want to retrieve multiple jobs at once; including jobs from retired systems, call `service.jobs()` with optional filters instead. See [QiskitRuntimeService.jobs](../api/qiskit-ibm-runtime/qiskit_ibm_runtime.QiskitRuntimeService#jobs).
 
 <Admonition type="note">
-  service.jobs() returns only Qiskit&reg; Runtime jobs. To retrieve other jobs, use [qiskit-ibm-provider](../api/qiskit-ibm-provider/qiskit_ibm_provider.IBMBackend#ibmbackend) instead.
+  service.jobs() returns only Qiskit Runtime jobs. To retrieve other jobs, use [qiskit-ibm-provider](../api/qiskit-ibm-provider/qiskit_ibm_provider.IBMBackend#ibmbackend) instead.
 </Admonition>
 
 ## Example

docs/run/native-gates.mdx

@@ -8,7 +8,7 @@ description: Summary of the native gates and operations supported by IBM Quantum
 
 Each [processor family](processor-types) has a native gate set. By default, the systems in each family only support running the gates and operations in the native gate set. Thus, every gate in the circuit must be translated (by the transpiler) to the elements of this set.
 
-You can view the native gates and operations for a system either [with Qiskit®](#native-gates-with-qiskit) or on the IBM Quantum™ Platform [Compute resources page](#native-gates-on-platform).
+You can view the native gates and operations for a system either [with Qiskit](#native-gates-with-qiskit) or on the IBM Quantum™ Platform [Compute resources page](#native-gates-on-platform).
 
 <Admonition type="note" title="Basis gates">
 The terms native gates and basis gates are often used interchangeably. However, you can specify a different set of basis gates to use, while the native gate set never changes. For information about changing the basis gates, see the [Represent quantum computers](../transpile/representing_quantum_computers#basis-gates) topic.

docs/run/primitives-examples.mdx

@@ -13,7 +13,7 @@ To ensure faster and more efficient results, as of 1 March 2024, circuits and ob
 </Admonition>
 
 <Admonition type="note">
-    These examples all use the primitives from Qiskit&reg; Runtime, but you could use the base primitives instead. 
+    These examples all use the primitives from Qiskit Runtime, but you could use the base primitives instead. 
 </Admonition>
 
 ## Estimator examples

docs/run/primitives-get-started.mdx

@@ -13,7 +13,7 @@ To ensure faster and more efficient results, as of 1 March 2024, circuits and ob
 </Admonition>
 
 <Admonition type="note">
-    These examples all use the primitives from Qiskit&reg; Runtime, but you could use the base primitives instead. 
+    These examples all use the primitives from Qiskit Runtime, but you could use the base primitives instead. 
 </Admonition>
 
 <span id="start-estimator"></span>

docs/run/primitives.mdx

@@ -21,7 +21,7 @@ As we move toward larger systems and more complex workflows, the focus shifts fr
 qubit signals to viewing quantum devices as systems that perform tasks we need.
 
 The two most common tasks quantum computers are used for are sampling quantum states and calculating expectation values.
-These tasks motivated the design of *the first two Qiskit® primitives: Sampler and Estimator*.
+These tasks motivated the design of *the first two Qiskit primitives: Sampler and Estimator*.
 
 In short, the computational model introduced by the Qiskit primitives moves quantum programming one step closer
 to where classical programming is today, where the focus is less on the hardware details and more on the results

docs/run/quantum-serverless.mdx

@@ -16,7 +16,7 @@ Try out the tutorials in [IBM Quantum Learning](https://learning.quantum.ibm.com
 
 ## Qiskit Patterns with Quantum Serverless
 
-Creating utility-scale quantum applications generally requires a variety of compute resource requirements. You can use Quantum Serverless to easily submit quantum workflows for remote, managed execution. These quantum workflows can typically be implemented within a common pattern, called a Qiskit® Pattern. A Qiskit Pattern is an intuitive, repeatable set of steps for implementing a quantum computing workflow.
+Creating utility-scale quantum applications generally requires a variety of compute resource requirements. You can use Quantum Serverless to easily submit quantum workflows for remote, managed execution. These quantum workflows can typically be implemented within a common pattern, called a Qiskit Pattern. A Qiskit Pattern is an intuitive, repeatable set of steps for implementing a quantum computing workflow.
 
 Steps in a Qiskit Pattern:
 

docs/run/run-jobs-in-session.mdx

@@ -10,7 +10,7 @@ There are several ways to set up and use [sessions](sessions).  It is recommende
 
 ## Set up to use sessions
 
-Before starting a session, you must [set up Qiskit® Runtime](../start/install) and initialize it as a service:
+Before starting a session, you must [set up Qiskit Runtime](../start/install) and initialize it as a service:
 
 ``` python
 from qiskit_ibm_runtime import QiskitRuntimeService, Session, Sampler, Estimator

docs/run/sessions.mdx

@@ -6,7 +6,7 @@ description: An overview of Qiskit Runtime sessions and when to use them.
 
 # Introduction to Qiskit Runtime sessions
 
-A session is a Qiskit® Runtime feature that lets you efficiently run multi-job iterative workloads on quantum computers. Using sessions helps avoid delays caused by queuing each job separately, which can be particularly useful for iterative tasks that require frequent communication between classical and quantum resources.
+A session is a Qiskit Runtime feature that lets you efficiently run multi-job iterative workloads on quantum computers. Using sessions helps avoid delays caused by queuing each job separately, which can be particularly useful for iterative tasks that require frequent communication between classical and quantum resources.
 
 <Admonition type="note">
 The queuing time does not decrease for the first job submitted within a session. Therefore, a session does not provide any benefits when running a single job. Additionally, sessions do not work on simulators because simulators do not have a queue.

docs/run/system-information.mdx

@@ -41,7 +41,7 @@ The revision version number will increment for fixes that do not break the exist
 
 ## System configuration values
 
-The following is a subset of system configuration values available in IBM Quantum and from [Qiskit®](/api/qiskit/qiskit.providers.models.BackendConfiguration).
+The following is a subset of system configuration values available in IBM Quantum and from [Qiskit](/api/qiskit/qiskit.providers.models.BackendConfiguration).
 
 These values are shown on both the Systems and Simulators tabs of the [Compute resources page](https://quantum.ibm.com/services/resources?services=systems) and the details page for each system.
 

docs/start/configure-qiskit-local.mdx

@@ -5,7 +5,7 @@ description: How to customize the configuration of a local Qiskit installation.
 ---
 # Configure Qiskit locally
 
-After Qiskit® is installed and running, there are some optional steps you can take to change the default Qiskit behavior.
+After Qiskit is installed and running, there are some optional steps you can take to change the default Qiskit behavior.
 
 ## User configuration file
 

docs/start/index.mdx

@@ -12,7 +12,7 @@ The quantum community has explored quantum computing on the cloud since 2016.  N
 
 Through IBM Quantum™, you have access to performant and utility-scale (>100-qubit) quantum systems for your work, as well as scalable and flexible quantum software. Whether you try out a no-cost plan or run your programs through a pay-as-you-go or premium plan, you can start doing useful work with quantum computing now.
 
-The sections at the core of our documentation are based on the stages of a typical quantum user’s journey: build quantum circuits and operators in Qiskit®, then transpile and run on quantum systems using Qiskit Runtime primitives, a simplified interface for circuit execution. By pairing Qiskit with Qiskit Runtime, you benefit from seamless circuit execution powered by advanced runtime compilation, error suppression, and error mitigation techniques. 
+The sections at the core of our documentation are based on the stages of a typical quantum user’s journey: build quantum circuits and operators in Qiskit, then transpile and run on quantum systems using Qiskit Runtime primitives, a simplified interface for circuit execution. By pairing Qiskit with Qiskit Runtime, you benefit from seamless circuit execution powered by advanced runtime compilation, error suppression, and error mitigation techniques. 
  
 If you’re just getting started with IBM Quantum, you are in the right place. Use the topics in this section to get ready, then proceed to [Build](../build) to create your first quantum circuit. Keep working through the sections in order, following the tabs at the top of this page.
 

docs/start/install-qiskit-source.mdx

@@ -5,7 +5,7 @@ description: Learn how to install the development version of Qiskit.
 ---
 # Install Qiskit and Qiskit Runtime from source
 
-Installing Qiskit® from source allows you to access the current development version, instead of using the version in the Python Package Index (PyPI) repository. This lets you inspect and extend the latest version of the Qiskit code more efficiently. 
+Installing Qiskit from source allows you to access the current development version, instead of using the version in the Python Package Index (PyPI) repository. This lets you inspect and extend the latest version of the Qiskit code more efficiently. 
 
 ## Create and activate a new virtual environment
 

docs/start/install.mdx

@@ -6,7 +6,7 @@ description: Install and set up Qiskit and Qiskit Runtime on various operating s
 <span id="qiskit-install"></span>
 # Install and set up Qiskit
 
-Whether you will work locally or in a cloud environment, the first step for all users is to install Qiskit&reg;. For those wanting to run on a real system, your next step is to choose one of two channels in order to access IBM Quantum&trade; systems: IBM Quantum Platform or IBM Cloud&reg;.
+Whether you will work locally or in a cloud environment, the first step for all users is to install Qiskit. For those wanting to run on a real system, your next step is to choose one of two channels in order to access IBM Quantum&trade; systems: IBM Quantum Platform or IBM Cloud&reg;.
 
 <Admonition type="caution" title="Upgrade from Qiskit 0.x to Qiskit 1.0 and beyond">
   (If you are installing Qiskit for the first time, skip ahead to the [Install and set up](#local) section. This notice is relevant only to users who have installed Qiskit previously.)

docs/start/setup-channel.mdx

@@ -11,7 +11,7 @@ You can access IBM Quantum™ systems by using the IBM Quantum Platform or I
 
 IBM Quantum Platform has Open (free access) and Premium (enterprise subscription) plans. See [IBM Quantum access plans](https://www.ibm.com/quantum/access-plans) for details.
 
-You can make requests locally (on your laptop or other device) using the `qiskit-ibm-runtime` client or use a cloud-based environment, such as [IBM Quantum Lab](https://lab.quantum.ibm.com) (a Jupyter Notebook environment) or [IBM Quantum Composer](https://quantum.ibm.com/composer/files/new) (a virtual circuit composer). To make requests from a local environment, you need to [install and set up Qiskit® with the Qiskit Runtime Client](install#local) and [set up to use IBM Quantum Platform.](#iqp)
+You can make requests locally (on your laptop or other device) using the `qiskit-ibm-runtime` client or use a cloud-based environment, such as [IBM Quantum Lab](https://lab.quantum.ibm.com) (a Jupyter Notebook environment) or [IBM Quantum Composer](https://quantum.ibm.com/composer/files/new) (a virtual circuit composer). To make requests from a local environment, you need to [install and set up Qiskit with the Qiskit Runtime Client](install#local) and [set up to use IBM Quantum Platform.](#iqp)
 
 <Admonition type="note">
     [IBM Quantum Lab](https://lab.quantum.ibm.com) and [IBM Quantum Composer](https://quantum.ibm.com/composer/files/new) are self-contained tools and require no setup.

docs/support.mdx

@@ -13,7 +13,7 @@ Members of the IBM Quantum™ Network can reach out to IBM Quantum Support i
 
 ## Qiskit
 
-For help with Qiskit®, access our Slack community: [Qiskit Slack](https://qisk.it/join-slack).
+For help with Qiskit, access our Slack community: [Qiskit Slack](https://qisk.it/join-slack).
 
 ## Qiskit Runtime
 

docs/transpile/ai-transpiler-passes.mdx

@@ -5,7 +5,7 @@ description: What are the AI transpiler passes and how to use them
 
 # AI transpiler passes
 ​
-The AI-powered transpiler passes are experimental passes that work as a drop-in replacement of "traditional" Qiskit® passes for some transpiling tasks. They often produce better results than existing heuristic algorithms (such as lower depth and CNOT count), but are also much faster than optimization algorithms such as Boolean satisfiability solvers. The AI transpiler passes run on the cloud and are available to IBM Quantum™ Premium Plan users.
+The AI-powered transpiler passes are experimental passes that work as a drop-in replacement of "traditional" Qiskit passes for some transpiling tasks. They often produce better results than existing heuristic algorithms (such as lower depth and CNOT count), but are also much faster than optimization algorithms such as Boolean satisfiability solvers. The AI transpiler passes run on the cloud and are available to IBM Quantum™ Premium Plan users.
 
 
 <Admonition type="note">

docs/transpile/custom-transpiler-pass.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Write a custom transpiler pass\n",
     "\n",
-    "Qiskit® lets you create custom transpilation passes and run them in the `PassManager` object or add them to a `StagedPassManager`. Here we will demonstrate how to write a  transpiler pass, focusing on building a pass that performs [Pauli twirling](https://arxiv.org/abs/quant-ph/0606161) on the noisy quantum gates in a quantum circuit. This example uses the DAG, which is the object manipulated by the `TransformationPass` type of pass."
+    "Qiskit lets you create custom transpilation passes and run them in the `PassManager` object or add them to a `StagedPassManager`. Here we will demonstrate how to write a  transpiler pass, focusing on building a pass that performs [Pauli twirling](https://arxiv.org/abs/quant-ph/0606161) on the noisy quantum gates in a quantum circuit. This example uses the DAG, which is the object manipulated by the `TransformationPass` type of pass."
    ]
   },
   {

docs/transpile/defaults-and-configuration-options.mdx

@@ -208,7 +208,7 @@ qiskit.compiler.transpile(unitary_synthesis_method='default', translation_method
 <Admonition type="tip" title="Recommendations">
     - Learn how to [Set the optimization level](set-optimization).
     - Review more [Commonly used parameters](common-parameters).
-    - Learn how to [Set the optimization level when using Qiskit&reg; Runtime.](../run/advanced-runtime-options)
+    - Learn how to [Set the optimization level when using Qiskit Runtime.](../run/advanced-runtime-options)
     - Visit the [Transpile with pass managers](transpile-with-pass-managers) topic.
     - For examples, see [Representing quantum computers.](representing_quantum_computers)
     - Try the [Submit transpiled circuits](https://learning.quantum.ibm.com/tutorial/submit-transpiled-circuits) tutorial.

docs/transpile/index.mdx

@@ -7,7 +7,7 @@ description: Introduction to transpiling quantum circuits in Qiskit.
 
 # Introduction
 
-Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device, and optimize the circuit instructions for execution on noisy quantum systems.  This documentation covers the tooling and workflows for local transpilation available to all Qiskit® users, as well as for the cloud-based [Qiskit transpiler service](qiskit-transpiler-service) available to Premium Plan users.  If you're using primitives and are only interested in the default transpilation options provided by the Qiskit Runtime service, read the [Configure runtime compilation for Qiskit Runtime](../run/configure-runtime-compilation) topic.
+Transpilation is the process of rewriting a given input circuit to match the topology of a specific quantum device, and optimize the circuit instructions for execution on noisy quantum systems.  This documentation covers the tooling and workflows for local transpilation available to all Qiskit users, as well as for the cloud-based [Qiskit transpiler service](qiskit-transpiler-service) available to Premium Plan users.  If you're using primitives and are only interested in the default transpilation options provided by the Qiskit Runtime service, read the [Configure runtime compilation for Qiskit Runtime](../run/configure-runtime-compilation) topic.
 
 A central component of Qiskit, the transpiler is designed for modularity and extensibility. Its central goal is to write new circuit transformations (known as transpiler **passes**), and combine them with other existing passes, greatly reducing the depth and complexity of quantum circuits.  Which passes are chained together and in which order has a major effect on the final outcome. This pipeline is determined by the [`PassManager`](/api/qiskit/qiskit.transpiler.PassManager) and [`StagedPassManager`](/api/qiskit/qiskit.transpiler.StagedPassManager) objects.  The `StagedPassManager` orchestrates the execution of one or more `PassManagers` and determines the order in which they are executed, while the `PassManager` object is merely a collection of one or more passes.  Think of the `StagedPassManager` as the conductor in an orchestra, the `PassManagers` as the different instrument sections, and the `Pass`es as the individual musicians.  In this way, you can compose hardware-efficient quantum circuits that let you execute utility-scale work while keeping noise manageable.
 

docs/transpile/qiskit-transpiler-service.mdx

@@ -5,7 +5,7 @@ description: What is the Qiskit transpiler service and how to use it
 ---
 # Transpile circuits remotely with the Qiskit transpiler service
 
-The Qiskit® transpiler service provides transpilation capabilities on the cloud. In addition to the local Qiskit transpiler capabilities, your transpilation tasks can benefit from both IBM Quantum™ cloud resources and AI-powered transpiler passes.
+The Qiskit transpiler service provides transpilation capabilities on the cloud. In addition to the local Qiskit transpiler capabilities, your transpilation tasks can benefit from both IBM Quantum™ cloud resources and AI-powered transpiler passes.
 
 The Qiskit transpiler service offers a Python library to seamlessly integrate this service and its capabilities into your current Qiskit patterns and workflows.
 

docs/transpile/representing_quantum_computers.mdx

@@ -70,7 +70,7 @@ qc_t_cm_lv0.draw('mpl', style='iqp', idle_wires=False)
 ```
 ![Ansatz transpiled to coupling map with optimization level 0](/images/transpile/representing_quantum_computers/qc_t_cm_lv0.png "Circuit transpiled with a coupling map")
 
-As shown above, several SWAP gates were inserted (each consisting of three CX gates), which will cause a lot of errors on current devices. To see which qubits are selected on the actual qubit topology, use `plot_circuit_layout` from Qiskit® Visualizations:
+As shown above, several SWAP gates were inserted (each consisting of three CX gates), which will cause a lot of errors on current devices. To see which qubits are selected on the actual qubit topology, use `plot_circuit_layout` from Qiskit Visualizations:
 
 ```python
 from qiskit.visualization import plot_circuit_layout

docs/transpile/set-optimization.mdx

@@ -14,7 +14,7 @@ Higher optimization levels generate more optimized circuits at the expense of lo
 - `optimization_level=0`: Trivial optimization, which maps the circuit to the system with no explicit optimization.
 - `optimization_level=1-3`: Increasingly complex optimization, with heuristic algorithms that are used to find a layout and insert SWAP gates, with the goal of improving the overall performance of the circuit.  The number of iterations that these algorithms run increases with higher optimization levels. 
 
-Because finding the best layout is an NP-hard problem, it is the most time-consuming part of the transpilation process.  However, Qiskit® uses stochastic algorithms that have been refactored into Rust, resulting in significant speedup.  Therefore, optimization levels 1-3 all use the same layout algorithms.  There are some slight differences in how the circuits are translated into basis gates, as described in the following table:
+Because finding the best layout is an NP-hard problem, it is the most time-consuming part of the transpilation process.  However, Qiskit uses stochastic algorithms that have been refactored into Rust, resulting in significant speedup.  Therefore, optimization levels 1-3 all use the same layout algorithms.  There are some slight differences in how the circuits are translated into basis gates, as described in the following table:
 
 
 <Table>

docs/transpile/transpile-with-pass-managers.ipynb

@@ -17,7 +17,7 @@
    "source": [
     "## What is a (staged) pass manager?\n",
     "\n",
-    "In the context of Qiskit®, transpilation refers to the process of transforming an input circuit into a form that is suitable for execution on a quantum device. Transpilation typically occurs in a sequence of steps called transpiler passes. The circuit is processed by each transpiler pass in sequence, with the output of one pass becoming the input to the next. For example, one pass could go through the circuit and merge all consecutive sequences of single-qubit gates, and then the next pass could synthesize these gates into the basis set of the target device. The transpiler passes included with Qiskit are located in the [qiskit.transpiler.passes](/api/qiskit/transpiler_passes) module.\n",
+    "In the context of Qiskit, transpilation refers to the process of transforming an input circuit into a form that is suitable for execution on a quantum device. Transpilation typically occurs in a sequence of steps called transpiler passes. The circuit is processed by each transpiler pass in sequence, with the output of one pass becoming the input to the next. For example, one pass could go through the circuit and merge all consecutive sequences of single-qubit gates, and then the next pass could synthesize these gates into the basis set of the target device. The transpiler passes included with Qiskit are located in the [qiskit.transpiler.passes](/api/qiskit/transpiler_passes) module.\n",
     "\n",
     "A pass manager is an object that stores a list of transpiler passes and can execute them on a circuit. Create a pass manager by initializing a [`PassManager`](/api/qiskit/qiskit.transpiler.PassManager) with a list of transpiler passes. To run the transpilation on a circuit, call the [run](/api/qiskit/qiskit.transpiler.PassManager#run) method with a circuit as input.\n",
     "\n",

docs/transpile/transpiler-stages.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Transpiler stages\n",
     "\n",
-    "This page describes the stages of prebuilt transpilation pipeline in Qiskit®. There are six stages:\n",
+    "This page describes the stages of prebuilt transpilation pipeline in Qiskit. There are six stages:\n",
     "\n",
     "1. `init`\n",
     "2. `layout`\n",

docs/verify/building_noise_models.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Build noise models\n",
     "\n",
-    "This page shows how to use the Qiskit® Aer [`noise`](https://qiskit.org/ecosystem/aer/apidocs/aer_noise.html) module to build noise models for simulating quantum circuits in the presence of errors. This is useful for emulating noisy quantum processors and for studying the effects of noise on the execution of quantum algorithms."
+    "This page shows how to use the Qiskit Aer [`noise`](https://qiskit.org/ecosystem/aer/apidocs/aer_noise.html) module to build noise models for simulating quantum circuits in the presence of errors. This is useful for emulating noisy quantum processors and for studying the effects of noise on the execution of quantum algorithms."
    ]
   },
   {
@@ -52,7 +52,7 @@
    "source": [
     "## Qiskit Aer `noise` module\n",
     "\n",
-    "The Qiskit® Aer `noise` module contains Python classes to build customized noise models for simulation. There are three key classes:\n",
+    "The Qiskit Aer `noise` module contains Python classes to build customized noise models for simulation. There are three key classes:\n",
     "\n",
     "1. The `NoiseModel` class which stores a noise model used for noisy simulation.\n",
     "2. The `QuantumError` class which describes CPTP gate errors. These can be applied:\n",

docs/verify/cloud-based-simulators.mdx

@@ -5,7 +5,7 @@ description: Overview of available IBM Quantum cloud-based simulators
 # Available IBM Quantum simulators
 
 <Admonition type="note">
-This page gives details about the IBM Quantum&trade; cloud-based simulators. For information about the Qiskit&reg; built-in simulator, see the [Python-based simulators page in the API reference.](/api/qiskit/providers_basic_provider) You can also use the [Qiskit reference primitives](simulate-with-qiskit-primitives) for local statevector simulation.
+This page gives details about the IBM Quantum&trade; cloud-based simulators. For information about the Qiskit built-in simulator, see the [Python-based simulators page in the API reference.](/api/qiskit/providers_basic_provider) You can also use the [Qiskit reference primitives](simulate-with-qiskit-primitives) for local statevector simulation.
 </Admonition>
 
 IBM Quantum features a collection of high-performance simulators for prototyping quantum circuits and algorithms.

docs/verify/index.mdx

@@ -11,7 +11,7 @@ Because the cost of classically simulating quantum circuits scales exponentially
 - Test smaller versions of the circuits that can be simulated classically.
 - Modify the circuits so that they become classically simulable and test these modified circuits.
 
-Stabilizer circuits are a useful tool for accomplishing this latter goal. These are a restricted class of quantum circuits that can be efficiently simulated classically. Specialized simulators can easily simulate stabilizer circuits with thousands of qubits. See [Efficient simulation of stabilizer circuits with Qiskit® Aer primitives](stabilizer-circuit-simulation) for an overview of stabilizer circuits and how to simulate them efficiently.
+Stabilizer circuits are a useful tool for accomplishing this latter goal. These are a restricted class of quantum circuits that can be efficiently simulated classically. Specialized simulators can easily simulate stabilizer circuits with thousands of qubits. See [Efficient simulation of stabilizer circuits with Qiskit Aer primitives](stabilizer-circuit-simulation) for an overview of stabilizer circuits and how to simulate them efficiently.
 
 For general quantum circuits, the following tools are available for you to verify your quantum programs:
 

docs/verify/simulate-with-qiskit-aer.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Exact and noisy simulation with Qiskit Aer primitives\n",
     "\n",
-    "[Exact simulation with Qiskit® primitives](simulate-with-qiskit-primitives) demonstrates how to use the reference primitives included with Qiskit to perform exact simulation of quantum circuits. Currently existing quantum processors suffer from errors, or noise, so the results of an exact simulation do not necessarily reflect the results you would expect when running circuits on real hardware. While the reference primitives in Qiskit do not support modeling noise, [Qiskit Aer](https://qiskit.org/ecosystem/aer/) includes implementations of the primitives that do support modeling noise. Qiskit Aer is a high-performance quantum circuit simulator that you can use in place of the reference primitives for better performance and more features. It is part of the [Qiskit Ecosystem](https://qiskit.github.io/ecosystem/). In this article, we demonstrate the use of Qiskit Aer primitives for exact and noisy simulation.\n",
+    "[Exact simulation with Qiskit primitives](simulate-with-qiskit-primitives) demonstrates how to use the reference primitives included with Qiskit to perform exact simulation of quantum circuits. Currently existing quantum processors suffer from errors, or noise, so the results of an exact simulation do not necessarily reflect the results you would expect when running circuits on real hardware. While the reference primitives in Qiskit do not support modeling noise, [Qiskit Aer](https://qiskit.org/ecosystem/aer/) includes implementations of the primitives that do support modeling noise. Qiskit Aer is a high-performance quantum circuit simulator that you can use in place of the reference primitives for better performance and more features. It is part of the [Qiskit Ecosystem](https://qiskit.github.io/ecosystem/). In this article, we demonstrate the use of Qiskit Aer primitives for exact and noisy simulation.\n",
     "\n",
     "Let's create an example circuit on eight qubits."
    ]

docs/verify/simulate-with-qiskit-primitives.mdx

@@ -5,7 +5,7 @@ description: How to perform exact simulation of quantum circuits using primitive
 
 # Exact simulation with Qiskit primitives
 
-The reference primitives in Qiskit® can perform local statevector simulations, which is useful for quickly prototyping algorithms. 
+The reference primitives in Qiskit can perform local statevector simulations, which is useful for quickly prototyping algorithms. 
 
 The `Estimator` primitive can compute an expectation value, and the `Sampler` primitive can compute circuit output probabilities. 
 

docs/verify/stabilizer-circuit-simulation.ipynb

@@ -7,7 +7,7 @@
    "source": [
     "# Efficient simulation of stabilizer circuits with Qiskit Aer primitives\n",
     "\n",
-    "This page shows how to use Qiskit® Aer primitives to efficiently simulate stabilizer circuits, including those subject to Pauli noise.\n",
+    "This page shows how to use Qiskit Aer primitives to efficiently simulate stabilizer circuits, including those subject to Pauli noise.\n",
     "\n",
     "Stabilizer circuits, also known as Clifford circuits, are an important restricted class of quantum circuits that can be efficiently simulated classically. There are several equivalent ways to define stabilizer circuits. One definition is that a stabilizer circuit is a quantum circuit that consists solely of the following gates:\n",
     "\n",

docs/verify/using-ibm-quantum-simulators.mdx

@@ -6,7 +6,7 @@ description: Set up ibmq_qasm_simulator and map a basic noise model for an IBM Q
 
 # Using IBM Quantum cloud-based simulators
 
-Set up ``ibmq_qasm_simulator`` and map a basic noise model for an IBM Quantum™ hardware device in Qiskit® Runtime, then use this noise model to perform noisy simulations of ``QuantumCircuits`` by using ``Sampler`` and ``Estimator`` to study the effects of errors that occur on real devices.
+Set up ``ibmq_qasm_simulator`` and map a basic noise model for an IBM Quantum™ hardware device in Qiskit Runtime, then use this noise model to perform noisy simulations of ``QuantumCircuits`` by using ``Sampler`` and ``Estimator`` to study the effects of errors that occur on real devices.
 
 ## Set up your local development environment
 

translations/ja/api/migration-guides/qiskit-runtime-from-provider.mdx

@@ -5,7 +5,7 @@ description: How to migrate `backend.run()` from Qiskit IBM Provider to Qiskit I
 
 # Migrate `backend.run()` from `qiskit_ibm_provider` to `qiskit_ibm_runtime`
 
-The Qiskit® Runtime interface includes two packages:
+The Qiskit Runtime interface includes two packages:
 Qiskit IBM Provider (the [`qiskit_ibm_provider`](../qiskit-ibm-provider) package) and
 Qiskit IBM Runtime (the [`qiskit_ibm_runtime`](../qiskit-ibm-runtime) package). Until now,
 primitives (`Sampler` and `Estimator`)