IBM Quantum Platform

https://quantum.cloud.ibm.com/docs/en
Admin
The IBM Quantum Platform provides documentation for using Qiskit and IBM Quantum hardware to develop...
Tokens:988,321
Snippets:9,082
Trust Score:10
Update:3 months ago
Show doc for...
Tokens:
Raw
### Install required packages

Source: https://quantum.cloud.ibm.com/docs/en/guides/q-ctrl-optimization-solver

Install necessary dependencies for the optimization example.

```python
# %pip install numpy networkx sympy
```

--------------------------------

### Install required dependencies

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/global-data-quantum-optimizer

Install the necessary libraries for the quantum portfolio optimization workflow.

```bash
!pip install qiskit-ibm-catalog
!pip install pandas
!pip install matplotlib
!pip install yfinance
```

--------------------------------

### Install Qiskit SDK

Source: https://quantum.cloud.ibm.com/docs/en/guides/install-qiskit

Install the Qiskit package using pip.

```shell
pip install qiskit
```

--------------------------------

### Install OpenCode

Source: https://quantum.cloud.ibm.com/docs/en/guides/qiskit-code-assistant

Run the installation script for the OpenCode terminal tool.

```bash
curl -fsSL https://opencode.ai/install | bash
```

--------------------------------

### Install and run Jupyter

Source: https://quantum.cloud.ibm.com/docs/en/guides/install-qiskit

Install Jupyter and launch a notebook file.

```shell
pip install jupyter
```

```shell
jupyter notebook <path/to/notebook.ipynb>
```

--------------------------------

### Install Qiskit Runtime and Jupyter

Source: https://quantum.cloud.ibm.com/docs/en/guides/hello-world

Install the required packages for running jobs on quantum hardware and local notebook environments.

```bash
pip install qiskit-ibm-runtime
```

```bash
pip install jupyter
```

--------------------------------

### Install all Qiskit MCP servers

Source: https://quantum.cloud.ibm.com/docs/en/guides/qiskit-mcp-servers

Installs the complete suite of available Qiskit MCP servers using pip.

```bash
pip install qiskit-mcp-servers[all]
```

--------------------------------

### Install Qiskit Serverless packages

Source: https://quantum.cloud.ibm.com/docs/en/guides/serverless

Install the necessary client and server-side tools for Qiskit Serverless. Requires Python 3.11 or higher.

```bash
pip install qiskit-ibm-catalog qiskit_serverless
```

--------------------------------

### Install the Python package

Source: https://quantum.cloud.ibm.com/docs/en/guides/c-extension-for-python

Use a PEP-517-compatible build tool to compile the C extension and install the package.

```bash
pip install .
```

--------------------------------

### Install Qiskit Runtime client

Source: https://quantum.cloud.ibm.com/docs/en/guides/compute-services

Use this command to install the qiskit-ibm-runtime package, which serves as the client interface for the Qiskit Runtime service.

```bash
pip install qiskit-ibm-runtime
```

--------------------------------

### Prepare for source installation

Source: https://quantum.cloud.ibm.com/docs/en/addons/qiskit-addon-paulice/install

Upgrade pip and navigate into the cloned repository directory.

```sh
### <INSTALL RUST HERE> ###
pip install --upgrade pip
cd qiskit-paulice
```

--------------------------------

### Setup and Benchmarking Utilities

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/ai-transpiler-introduction

Imports required libraries and defines helper functions for transpilation metrics, qubit remapping, mirror circuit construction, and performance visualization.

```python
from qiskit import QuantumCircuit
from qiskit.circuit.random import random_circuit
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime import QiskitRuntimeService, SamplerV2
from qiskit_ibm_transpiler import generate_ai_pass_manager
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, depolarizing_error
import matplotlib.pyplot as plt
from statistics import mean, stdev
import time
import logging

seed = 42


def transpile_with_metrics(pass_manager, circuit):
    """Transpile a circuit and return the result along with key metrics."""
    start = time.time()
    qc_out = pass_manager.run(circuit)
    elapsed = time.time() - start

    depth_2q = qc_out.depth(lambda x: x.operation.num_qubits == 2)
    gate_count = qc_out.size()

    return qc_out, {
        "depth_2q": depth_2q,
        "gate_count": gate_count,
        "time_s": round(elapsed, 3),
    }


def remap_to_contiguous(tqc):
    """Remap a transpiled circuit to use contiguous qubit indices.

    Transpiled circuits target specific physical qubits (e.g., qubit 45, 67)
    on a large backend. This remaps them to 0, 1, 2, ... so Aer only
    simulates the active qubits."""
    active = sorted(
        {tqc.find_bit(q).index for inst in tqc.data for q in inst.qubits}
    )
    qubit_map = {old: new for new, old in enumerate(active)}
    new_qc = QuantumCircuit(len(active))
    for inst in tqc.data:
        old_indices = [tqc.find_bit(q).index for q in inst.qubits]
        new_qc.append(inst.operation, [qubit_map[i] for i in old_indices])
    return new_qc


def build_mirror_circuit(tqc, simulate=True):
    """Build a mirror circuit: U followed by U-dagger, with measurements.

    The expected output is always |0...0>, so measuring the survival
    probability reveals how much noise each transpilation strategy adds.

    Args:
        tqc: A transpiled circuit.
        simulate: If True (default), remap to contiguous qubits so Aer
            only simulates the active qubits. If False, keep the full
            physical layout for hardware execution."""
    if simulate:
        tqc = remap_to_contiguous(tqc)
    mirror = tqc.compose(tqc.inverse())
    mirror.measure_all()
    return mirror


def print_summary(results):
    """Print a summary of each metric as mean +/- stdev across all circuits,
    along with the mean percentage improvement of AI over Default."""
    metrics = [
        ("Depth 2Q", "Depth 2Q (Default)", "Depth 2Q (AI)"),
        ("Gate Count", "Gate Count (Default)", "Gate Count (AI)"),
        ("Time (s)", "Time (Default)", "Time (AI)"),
    ]
    header = (
        f"{'Metric':<12}{'Default (mean +/- std)':>24}"
        f"{'AI (mean +/- std)':>22}{'AI % improvement':>22}"
    )
    print(header)
    print("-" * len(header))
    for label, col_def, col_ai in metrics:
        defaults = [r[col_def] for r in results]
        ais = [r[col_ai] for r in results]
        pct = [(d - a) / d * 100 for d, a in zip(defaults, ais)]
        default_str = f"{mean(defaults):.1f} +/- {stdev(defaults):.1f}"
        ai_str = f"{mean(ais):.1f} +/- {stdev(ais):.1f}"
        pct_str = f"{mean(pct):+.1f}% +/- {stdev(pct):.1f}%"
        print(f"{label:<12}{default_str:>24}{ai_str:>22}{pct_str:>22}")


def plot_metrics_and_pct(results, title_prefix):
    """Plot metric comparisons and percentage improvement of AI over Default."""
    qubits = [r["Qubits"] for r in results]
    metrics = [
        ("Depth 2Q (Default)", "Depth 2Q (AI)", "Two-Qubit Depth"),
        ("Gate Count (Default)", "Gate Count (AI)", "Gate Count"),
        ("Time (Default)", "Time (AI)", "Transpilation Time"),
    ]

    # Row 1: raw metric comparison
    fig, axs = plt.subplots(1, 3, figsize=(21, 5))
    fig.suptitle(
        f"{title_prefix}: Metric Comparison",
        fontsize=15,
        fontweight="bold",
        y=1.02,
    )
    for ax, (col_def, col_ai, label) in zip(axs, metrics):
        ax.plot(qubits, [r[col_def] for r in results], "o-", label="Default")
        ax.plot(qubits, [r[col_ai] for r in results], "s-", label="AI")
        ax.set_title(label)
        ax.set_xlabel("Number of Qubits")
        ax.set_ylabel(label)
        ax.legend()
    plt.tight_layout()
    plt.show()
```

--------------------------------

### Install Samplomatic

Source: https://quantum.cloud.ibm.com/docs/en/guides/executor-input-output

Required installation for examples using the Samplomatic package.

```bash
pip install samplomatic

# For visualization support, include the visualization dependencies.
# pip install samplomatic[vis]
```

--------------------------------

### Initialize QuantumProgram and transpile circuit

Source: https://quantum.cloud.ibm.com/docs/en/guides/executor-input-output

Setup a QuantumProgram with 1024 shots and prepare an ISA circuit for execution.

```python
from qiskit.transpiler import generate_preset_pass_manager
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit_ibm_runtime import Executor, QiskitRuntimeService
from qiskit.circuit import Parameter, QuantumCircuit
import numpy as np
from samplomatic import build
from samplomatic.transpiler import generate_boxing_pass_manager

# Initialize an empty program
program = QuantumProgram(shots=1024)

# Initialize and transpile a 3-qubit quantum circuit with 2 parameters.
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0, 1)
circuit.cx(1, 2)
circuit.rz(Parameter("theta"), 0)
circuit.rz(Parameter("phi"), 1)

# `measure_all` adds a 3-bit classical register named "meas"
circuit.measure_all()

# Choose the least busy backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Generate a preset pass manager
# This will be used to convert the abstract circuit to an
# equivalent Instruction Set Architecture (ISA) circuit.
preset_pass_manager = generate_preset_pass_manager(
    backend=backend, optimization_level=0
)

# Transpile the circuit
isa_circuit = preset_pass_manager.run(circuit)
```

--------------------------------

### Workload response example

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-runtime-rest/tags/workloads

Example JSON response body returned by the GET /v1/workloads endpoint.

```json
{
  "workloads": [
    {
      "id": "ch8b1ok4k9li68vm059r",
      "created": "2024-07-04T16:13:56.562Z",
      "ended": "2024-07-04T16:13:56.562Z",
      "backend": "ibm_seattle",
      "instance": "ibmq/open/main",
      "user_id": "65f0478ed32a1891af0a8d31",
      "accepting_jobs": true,
      "mode": "job",
      "status": "in_progress",
      "status_reason": "Error occurred for job circuit-runner_ckodgbs1fc4b8ufrjsd0_d35e_2. Stale payload, retry maximum reached.",
      "tags": [
        "test-job",
        "foo",
        "bar"
      ],
      "usage_seconds": 1,
      "usage": {
        "qpu_charge_time_seconds": 123,
        "status": "complete"
      },
      "estimated_running_time_seconds": 1
    }
  ],
  "total_count": 5,
  "limit": 5,
  "previous": {
    "href": "https://api.example.com/v2/accounts?previous=3fe78a36b9aa7f26"
  },
  "next": {
    "href": "https://api.example.com/v2/accounts?next=3fe78a36b9aa7f26"
  }
}
```

--------------------------------

### Retrieve usage analytics

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-runtime-rest/tags/analytics

Examples for calling the GET /v1/analytics/usage endpoint using cURL and Python.

```bash
curl -X GET \
  'https://quantum.cloud.ibm.com/api/v1/analytics/usage' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer YOUR-TOKEN' \
  -H 'Service-CRN: YOUR-SERVICE-CRN' \
  -H 'IBM-API-Version: 2026-04-15'
```

```python
import requests

response = requests.request(
    "GET",
    "https://quantum.cloud.ibm.com/api/v1/analytics/usage",
    headers={
      "Accept": "application/json",
      "IBM-API-Version": "2026-04-15",
      "Authorization": "Bearer YOUR-TOKEN",
      "Service-CRN": "YOUR-SERVICE-CRN"
    },
)
print(response.json())
```

--------------------------------

### Configure the runtime environment

Source: https://quantum.cloud.ibm.com/docs/en/guides/debug-qiskit-runtime-jobs

Initialize the service, select a backend, and set up the pass manager for ISA circuit conversion.

```python
# Choose the least busy backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Generate a preset pass manager
# This will be used to convert the abstract circuit to an equivalent
# Instruction Set Architecture (ISA) circuit.

pm = generate_preset_pass_manager(backend=backend, optimization_level=0)

# Set the random seed
random.seed(10)
```

--------------------------------

### Job Response Example

Source: https://quantum.cloud.ibm.com/docs/en/api/quantum-system-rest/tags/jobs

A sample JSON response body returned upon a successful GET request.

```json
{
  "backend": "ibm_rensselaer",
  "created_time": "example",
  "end_time": "example",
  "id": "example",
  "log_level": "info",
  "program_id": "sampler",
  "reason_code": 1,
  "reason_message": "example",
  "reason_solution": "example",
  "status": "Running",
  "storage": {
    "input": {
      "bucket_crn": "crn:v1:bluemix:public:cloud-object-storage:global:a/abc123:abc123:bucket:my-bucket",
      "object_name": "example",
      "presigned_url": "example",
      "region": "us-east",
      "region_type": "regional",
      "runtime_instance_crn": "crn:v1:bluemix:public:quantum-computing:us-east:a/abc123:abc123::",
      "type": "s3_compatible"
    },
    "logs": {
      "bucket_crn": "crn:v1:bluemix:public:cloud-object-storage:global:a/abc123:abc123:bucket:my-bucket",
      "object_name": "example",
      "presigned_url": "example",
      "region": "us-east",
      "region_type": "regional",
      "runtime_instance_crn": "crn:v1:bluemix:public:quantum-computing:us-east:a/abc123:abc123::",
      "type": "s3_compatible"
    },
    "results": {
      "bucket_crn": "crn:v1:bluemix:public:cloud-object-storage:global:a/abc123:abc123:bucket:my-bucket",
      "object_name": "example",
      "presigned_url": "example",
      "region": "us-east",
      "region_type": "regional",
      "runtime_instance_crn": "crn:v1:bluemix:public:quantum-computing:us-east:a/abc123:abc123::",
      "type": "s3_compatible"
    }
  },
  "timeout_secs": 1,
  "usage": {
    "quantum_nanoseconds": 1
  }
}
```

--------------------------------

### Compiling a Unitary with AQC

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.synthesis.unitary.aqc

This example demonstrates the basic workflow for using the AQC algorithm, including defining the target unitary, configuring the CNOT network, and running the optimization process.

```python
# Define a target circuit as a unitary matrix
unitary = ...

# Define a number of qubits for the algorithm, at least 3 qubits
num_qubits = round(math.log2(unitary.shape[0]))

# Choose a layout of the CNOT structure for the approximate circuit, e.g. ``spin`` for
# a linear layout.
layout = options.get("layout") or "spin"

# Choose a connectivity type, e.g. ``full`` for full connectivity between qubits.
connectivity = options.get("connectivity") or "full"

# Define a targeted depth of the approximate circuit in the number of CNOT units.
depth = int(options.get("depth") or 0)

# Generate a network made of CNOT units
cnots = make_cnot_network(
    num_qubits=num_qubits,
    network_layout=layout,
    connectivity_type=connectivity,
    depth=depth
)

# Create an optimizer to be used by AQC
optimizer = partial(scipy.optimize.minimize, method="L-BFGS-B")

# Create an instance
aqc = AQC(optimizer)

# Create a template circuit that will approximate our target circuit
approximate_circuit = CNOTUnitCircuit(num_qubits=num_qubits, cnots=cnots)

# Create an objective that defines our optimization problem
approximating_objective = DefaultCNOTUnitObjective(num_qubits=num_qubits, cnots=cnots)

# Run optimization process to compile the unitary
aqc.compile_unitary(
    target_matrix=unitary,
    approximate_circuit=approximate_circuit,
    approximating_objective=approximating_objective
)
```

--------------------------------

### Set up the circuit and backend

Source: https://quantum.cloud.ibm.com/docs/en/guides/executor-examples

Initializes the QiskitRuntimeService and constructs a 10-qubit circuit with alternating RX and CZ gates.

```python
from qiskit_ibm_runtime import QiskitRuntimeService, Executor
from qiskit_ibm_runtime.quantum_program import QuantumProgram
from qiskit.circuit import QuantumCircuit, Parameter
from qiskit.transpiler import generate_preset_pass_manager
from samplomatic.transpiler import generate_boxing_pass_manager
from samplomatic import build

# Initialize the service and choose a backend
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Prepare a circuit

num_qubits = 10
num_layers = 10

qubits = list(range(num_qubits))
circuit = QuantumCircuit(num_qubits)

for layer_idx in range(num_layers):
    circuit.rx(Parameter(f"theta_{layer_idx}"), qubits)
    for i in range(num_qubits // 2):
        circuit.cz(qubits[2 * i], qubits[2 * i + 1])

    circuit.rx(Parameter(f"phi_{layer_idx}"), qubits)
    for i in range(num_qubits // 2 - 1):
        circuit.cz(qubits[2 * i] + 1, qubits[2 * i + 1] + 1)

circuit.draw("mpl", scale=0.35, fold=100)
```

--------------------------------

### Retrieve operation start times in a scheduled circuit

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.circuit.QuantumCircuit

Use op_start_times to get estimated start times for operations in a circuit that has undergone scheduling analysis. This attribute is only available for simple circuits without control flow.

```python
from qiskit import QuantumCircuit
from qiskit.providers.fake_provider import GenericBackendV2
from qiskit.transpiler import generate_preset_pass_manager

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

# Print the original circuit
print("Original circuit:")
print(qc)

# Transpile the circuit with a specific basis gates list and print the resulting circuit
backend = GenericBackendV2(2, basis_gates=['u1', 'u2', 'u3', 'cx'])
pm = generate_preset_pass_manager(
    optimization_level=1, backend=backend, scheduling_method="alap"
)
transpiled_qc = pm.run(qc)
print("Transpiled circuit with basis gates ['u1', 'u2', 'u3', 'cx']:")
print(transpiled_qc)

# Print the start times of each instruction in the transpiled circuit
print("Start times of instructions in the transpiled circuit:")
for instruction, start_time in zip(transpiled_qc.data, transpiled_qc.op_start_times):
    print(f"{instruction.operation.name}: {start_time}")
```

--------------------------------

### Identify Compilation Errors

Source: https://quantum.cloud.ibm.com/docs/en/guides/install-qiskit

Example of error output indicating a failure to build a package wheel from source during installation.

```text
Failed building wheel for SOME_PACKAGE
...
build/temp.linux-x86_64-3.5/_openssl.c:498:30: fatal error
compilation terminated.
error: command 'x86_64-linux-gnu-gcc' failed with exit status 1
```

--------------------------------

### Initialize Qiskit and Q-CTRL environment

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/transverse-field-ising-model

Imports necessary libraries for quantum circuit construction, transpilation, and performance management.

```python
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager
from qiskit import QuantumCircuit
from qiskit_ibm_catalog import QiskitFunctionsCatalog
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit.quantum_info import SparsePauliOp
from qiskit_aer import AerSimulator

import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
import qctrlvisualizer as qv
```

--------------------------------

### Retrieve Backend Properties

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-runtime-rest/tags/backends

Examples for calling the GET /v1/backends/{id}/properties endpoint using cURL and Python.

```bash
curl -X GET \
  'https://quantum.cloud.ibm.com/api/v1/backends/{id}/properties' \
  -H 'Accept: application/json' \
  -H 'Authorization: Bearer YOUR-TOKEN' \
  -H 'Service-CRN: YOUR-SERVICE-CRN' \
  -H 'IBM-API-Version: 2026-04-15'
```

```python
import requests

response = requests.request(
    "GET",
    "https://quantum.cloud.ibm.com/api/v1/backends/{id}/properties",
    headers={
      "Accept": "application/json",
      "IBM-API-Version": "2026-04-15",
      "Authorization": "Bearer YOUR-TOKEN",
      "Service-CRN": "YOUR-SERVICE-CRN"
    },
)
print(response.json())
```

--------------------------------

### Register plugin via setup.py

Source: https://quantum.cloud.ibm.com/docs/en/guides/create-transpiler-plugin

Define the entry point in the setup.py file to register the unitary synthesis plugin.

```python
from setuptools import setup

setup(
    # ...,
    entry_points={
        'qiskit.unitary_synthesis': [
            'my_unitary_synthesis = my_qiskit_plugin:MyUnitarySynthesisPlugin',
        ]
    }
)
```

--------------------------------

### Setup Imports and Data Preparation

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/quantum-kernel-training

Initializes required libraries, downloads the dataset, and defines helper functions for data loading and result visualization.

```python
# General Imports and helper functions
import urllib.request

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt


from qiskit.circuit import Parameter, ParameterVector, QuantumCircuit
from qiskit.circuit.library import unitary_overlap
from qiskit.primitives import StatevectorSampler
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService, Sampler

# Download the dataset (portable across platforms)
urllib.request.urlretrieve(
    "https://raw.githubusercontent.com/qiskit-community/prototype-quantum-kernel-training/main/data/dataset_graph7.csv",
    "dataset_graph7.csv",
)


def visualize_counts(res_counts, num_qubits, num_shots):
    """Visualize the outputs from the Qiskit Sampler primitive."""
    zero_prob = res_counts.get(0, 0.0)
    top_10 = dict(
        sorted(res_counts.items(), key=lambda item: item[1], reverse=True)[
            :10
        ]
    )
    top_10.update({0: zero_prob})
    by_key = dict(sorted(top_10.items(), key=lambda item: item[0]))
    x_vals, y_vals = list(zip(*by_key.items()))
    x_vals = [bin(x_val)[2:].zfill(num_qubits) for x_val in x_vals]
    y_vals_prob = []
    for t in range(len(y_vals)):
        y_vals_prob.append(y_vals[t] / num_shots)
    y_vals = y_vals_prob
    plt.bar(x_vals, y_vals)
    plt.xticks(rotation=75)
    plt.title("Results of sampling")
    plt.xlabel("Measured bitstring")
    plt.ylabel("Probability")
    plt.show()


def get_training_data():
    """Read the training data."""
    df = pd.read_csv("dataset_graph7.csv", sep=",", header=None)
    training_data = df.values[:20, :]
    ind = np.argsort(training_data[:, -1])
    X_train = training_data[ind][:, :-1]

    return X_train
```

--------------------------------

### Retrieve instance usage via Python

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-runtime-rest/tags/instances

Use the requests library to perform a GET request for instance usage. Requires the requests package to be installed.

```python
import requests

response = requests.request(
    "GET",
    "https://quantum.cloud.ibm.com/api/v1/instances/usage",
    headers={
      "Accept": "application/json",
      "IBM-API-Version": "2026-04-15",
      "Authorization": "Bearer YOUR-TOKEN",
      "Service-CRN": "YOUR-SERVICE-CRN"
    },
)
print(response.json())
```

--------------------------------

### Initialize service and list backends

Source: https://quantum.cloud.ibm.com/docs/en/guides/qpu-information

Authenticate with the service and retrieve a list of available IBMBackend instances.

```python
# Initialize your account
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()

service.backends()
```

```text
[<IBMBackend('ibm_boston')>,
 <IBMBackend('ibm_pittsburgh')>,
 <IBMBackend('ibm_fez')>,
 <IBMBackend('ibm_marrakesh')>,
 <IBMBackend('ibm_kingston')>,
 <IBMBackend('ibm_miami')>]
```

--------------------------------

### Retrieve API versions via Python

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-runtime-rest/tags/versions

Uses the requests library to perform a GET request for API versions. Ensure the requests library is installed.

```python
import requests

response = requests.request(
    "GET",
    "https://quantum.cloud.ibm.com/api/v1/versions",
    headers={
      "Accept": "application/json"
    },
)
print(response.json())
```

--------------------------------

### Configure build system in setup.py

Source: https://quantum.cloud.ibm.com/docs/en/guides/c-extension-for-python

Defines the C extension module and includes the necessary Qiskit C API headers for the build process.

```python
import qiskit
from setuptools import setup, Extension

core_ext = Extension(
    # The fully qualified module name of the extension.
    name="spectator_measures._core",
    # The C source files needed for the extension.  The file
    # name is conventionally `<mod>module.c`, where `<mod>`
    # is the module name (`_core`, in this case).
    sources=["src/spectator_measures/_coremodule.c"],
    # Directories containing additional header files used in
    # the build process.
    include_dirs=[qiskit.capi.get_include()],
)
setup(ext_modules=[core_ext])
```

--------------------------------

### Install dependencies

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/simulate-kicked-ising-tem

Install the required Python packages for the simulation.

```python
%pip install numpy matplotlib qiskit qiskit-ibm-catalog qiskit-ibm-runtime pylatexenc qiskit_qasm3_import
```

--------------------------------

### SamplerPub.__init__

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit/qiskit.primitives.StatevectorEstimator

Initializes a new SamplerPub instance with a quantum circuit, optional parameter values, and shot count.

```APIDOC
## class qiskit.primitives.SamplerPub(circuit, parameter_values=None, shots=None, validate=True)

### Description
Initializes a sampler pub, which is a tuple composed of a circuit, parameter values, and shots.

### Parameters
- **circuit** (QuantumCircuit) - Required - A quantum circuit.
- **parameter_values** (BindingsArray | None) - Optional - A bindings array.
- **shots** (int | None) - Optional - A specific number of shots to run with. This value takes precedence over any value owed by or supplied to a sampler.
- **validate** (bool) - Optional - If True, the input data is validated during initialization.
```

--------------------------------

### Launch OpenCode

Source: https://quantum.cloud.ibm.com/docs/en/guides/qiskit-code-assistant

Start the OpenCode TUI in your project directory.

```bash
opencode
```

--------------------------------

### Install from PyPI

Source: https://quantum.cloud.ibm.com/docs/en/addons/qiskit-addon-paulice/install

Install the package directly from the Python Package Index.

```sh
pip install qiskit-paulice
```

--------------------------------

### Register plugin via setup.cfg

Source: https://quantum.cloud.ibm.com/docs/en/guides/create-transpiler-plugin

Define the entry point in the setup.cfg file to register the unitary synthesis plugin.

```ini
[options.entry_points]
qiskit.unitary_synthesis =
    my_unitary_synthesis = my_qiskit_plugin:MyUnitarySynthesisPlugin
```

--------------------------------

### Install Scikit-Learn

Source: https://quantum.cloud.ibm.com/docs/en/guides/multiverse-computing-singularity

Command to install the scikit-learn library required for dataset generation.

```sh
python3 -m pip install scikit-learn
```

--------------------------------

### Initialize backend and target

Source: https://quantum.cloud.ibm.com/docs/en/guides/dynamical-decoupling-pass-manager

Set up the mock backend and extract operation names for the target.

```python
from qiskit_ibm_runtime.fake_provider import FakeSherbrooke

backend = FakeSherbrooke()

target = backend.target
basis_gates = list(target.operation_names)
```

--------------------------------

### Initialize Sampler V2 and set options

Source: https://quantum.cloud.ibm.com/docs/en/guides/v2-primitives

Demonstrates initializing the Sampler V2 class and setting options post-initialization.

```python
sampler = Sampler(backend)
sampler.options.default_shots = 1024
```

--------------------------------

### Verify installation requirements

Source: https://quantum.cloud.ibm.com/docs/en/guides/install-c-api

Checks that the necessary compilers and tools are installed on the system.

```bash
rustc --version
gcc --version
cbindgen --version
make --version  # optional, but recommended
```

--------------------------------

### Install qiskit-ibm-transpiler

Source: https://quantum.cloud.ibm.com/docs/en/guides/ai-transpiler-passes

Install the required package to access AI transpiler passes.

```sh
pip install qiskit-ibm-transpiler
```

--------------------------------

### Initialize and configure Sampler V1

Source: https://quantum.cloud.ibm.com/docs/en/guides/v2-primitives

Demonstrates initializing the V1 Sampler with Options and updating settings post-initialization.

```python
from qiskit_ibm_runtime import QiskitRuntimeService, Sampler, Options

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Setting options during primitive initialization
options = Options()
# This uses auto complete.
options.resilience_level = 2
sampler = Sampler(backend=backend, options=options)

# Setting options after primitive initialization.
# This does bulk update.
sampler.set_options(shots=2000)
```

```python
from qiskit_ibm_runtime import Sampler, Options

sampler = Sampler(backend, options=options)

options = Options()

options.resilience_level = 2
```

--------------------------------

### Install TeNPy dependencies

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-addon-mpf/backends-tenpy-layers

Install the required optional dependencies for the TeNPy backend.

```bash
pip install "qiskit-addon-mpf[tenpy]"
```

--------------------------------

### Register a synthesis plugin in setup.py

Source: https://quantum.cloud.ibm.com/docs/en/guides/create-transpiler-plugin

Define the entry point for a custom synthesis plugin within the setup configuration.

```python
from setuptools import setup

setup(
    # ...,
    entry_points={
        'qiskit.synthesis': [
            'clifford.my_clifford_synthesis = my_qiskit_plugin:MyCliffordSynthesisPlugin',
        ]
    }
)
```

--------------------------------

### Initialize Neat analyzer

Source: https://quantum.cloud.ibm.com/docs/en/guides/debug-qiskit-runtime-jobs

Set up the Neat analyzer with a backend and optional noise model.

```python
# You could specify a custom `NoiseModel` here. If `None`, `Neat`
# pulls the noise model from the given backend
noise_model = None

# Initialize `Neat`
analyzer = Neat(backend, noise_model)
```

--------------------------------

### Install dependencies for HiVQE

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/qunova-hivqe

Install the required Python packages to run the HiVQE tutorial.

```python
!pip install --upgrade pip
!pip install -U qiskit-ibm-catalog "qiskit_ibm_runtime<0.42.0" pyscf numpy matplotlib typing_extensions
```

--------------------------------

### Setup imports for Nishimori phase transition

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/nishimori-phase-transition

Initializes the necessary libraries for the GEM protocol, Qiskit Runtime, and simulation environments.

```python
import matplotlib.pyplot as plt
import warnings

from collections import defaultdict

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_aer import AerSimulator

from qiskit.transpiler import generate_preset_pass_manager

from gem_suite import PlaquetteLattice
from gem_suite.experiments import GemExperiment
```

--------------------------------

### Initialize Qiskit Runtime Service and Parameters

Source: https://quantum.cloud.ibm.com/docs/en/guides/estimator-rest-api

Sets up the service connection and defines parameters for the quantum circuit.

```python
import requests
import qiskit_ibm_runtime
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit.transpiler import generate_preset_pass_manager
from qiskit.qasm3 import dumps
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit import transpile

service = QiskitRuntimeService(channel='ibm_quantum')
backend = service.backend("<SPECIFY BACKEND>")

pm = generate_preset_pass_manager(backend=backend, optimization_level=1)

theta = Parameter('theta')
phi = Parameter('phi')
parameter_values = {'theta': 1.57, 'phi': 3.14}   # In case we want to pass a dictionary
```

--------------------------------

### Install Qiskit Aer

Source: https://quantum.cloud.ibm.com/docs/en/guides/qiskit-1.0-features

Install the qiskit-aer package to replace the removed qiskit.Aer object.

```bash
pip install qiskit-aer
```

--------------------------------

### Install numpy dependency

Source: https://quantum.cloud.ibm.com/docs/en/guides/q-ctrl-performance-management

Optional command to install numpy if running in an IPython kernel.

```python
# %pip install numpy
```

--------------------------------

### Initialize Fake Backend and Create Circuit

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-ibm-runtime/fake-provider

Instantiate a fake backend and construct a quantum circuit for subsequent transpilation and simulation.

```python
from qiskit import QuantumCircuit
from qiskit import transpile
from qiskit.visualization import plot_histogram
from qiskit_ibm_runtime import SamplerV2
from qiskit_ibm_runtime.fake_provider import FakeManilaV2

# Get a fake backend from the fake provider
backend = FakeManilaV2()

# Create a simple circuit
circuit = QuantumCircuit(3)
circuit.h(0)
circuit.cx(0,1)
circuit.cx(0,2)
circuit.measure_all()
circuit.draw('mpl', style="iqp")
```

--------------------------------

### Install developer requirements

Source: https://quantum.cloud.ibm.com/docs/en/guides/install-qiskit-runtime-source

Install additional dependencies required for running tests or linting.

```bash
pip install -e ".[dev]"
```

--------------------------------

### QiskitRuntimeService and Session Usage

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-ibm-runtime/runtime-service

Demonstrates how to initialize the QiskitRuntimeService, select a backend, and execute quantum circuits using Sampler and Estimator primitives within a Session.

```APIDOC
## QiskitRuntimeService and Session Usage

### Description
This example demonstrates how to initialize the QiskitRuntimeService, select an operational backend, and perform quantum tasks using the Sampler and Estimator primitives within a managed Session.

### Usage
```python
from qiskit_ibm_runtime import QiskitRuntimeService, Session
from qiskit_ibm_runtime import SamplerV2 as Sampler
from qiskit_ibm_runtime import EstimatorV2 as Estimator

# Initialize account
service = QiskitRuntimeService()

# Select backend
backend = service.least_busy(operational=True, simulator=False)

# Execute within a session
with Session(backend=backend) as session:
    sampler = Sampler(mode=session)
    job = sampler.run([circuit])
    
    estimator = Estimator(mode=session)
    job = estimator.run([(circuit, observables, theta)])
```
```

--------------------------------

### Verify plugin installation

Source: https://quantum.cloud.ibm.com/docs/en/guides/create-transpiler-plugin

List installed plugins to ensure the custom plugin is detected.

```python
from qiskit.transpiler.preset_passmanagers.plugin import list_stage_plugins

list_stage_plugins("layout")
```

```text
['default', 'dense', 'sabre', 'trivial']
```

--------------------------------

### Install dependencies

Source: https://quantum.cloud.ibm.com/docs/en/addons/qiskit-addon-paulice/install

Install the package in editable mode along with notebook and development dependencies.

```sh
pip install tox notebook -e '.[notebook-dependencies,dev]'
```

--------------------------------

### Initialize and configure Sampler V2

Source: https://quantum.cloud.ibm.com/docs/en/guides/v2-primitives

Shows how to set options for Sampler V2 during and after initialization, including enabling dynamical decoupling and gate twirling.

```python
from dataclasses import asdict
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import SamplerV2 as Sampler

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

# Setting options during primitive initialization
sampler = Sampler(backend, options={"default_shots": 4096})

# Setting options after primitive initialization
# This uses auto complete.
sampler.options.dynamical_decoupling.enable = True
# Turn on gate twirling. Requires qiskit_ibm_runtime 0.23.0 or later.
sampler.options.twirling.enable_gates = True

# This does bulk update.
# The value for default_shots is overridden 
# if you specify shots with run() or in the PUB.
sampler.options.update(default_shots=1024, 
dynamical_decoupling={"sequence_type": "XpXm"})

# Print the dictionary format.
# Server defaults are used for unset options.
print(asdict(sampler.options))
```

```python
from qiskit_ibm_runtime import SamplerV2 as Sampler

sampler = Sampler(backend)
# Turn on dynamical decoupling with sequence XpXm.
sampler.options.dynamical_decoupling.enable = True
sampler.options.dynamical_decoupling.sequence_type = "XpXm"

print(f">> dynamical decoupling sequence to use: "
f"{sampler.options.dynamical_decoupling.sequence_type}")
```

--------------------------------

### Import necessary libraries for QAOA

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/quantum-approximate-optimization-algorithm

Initializes the environment with required Qiskit, SciPy, and Rustworkx modules.

```python
import matplotlib.pyplot as plt
import rustworkx as rx
from rustworkx.visualization import mpl_draw as draw_graph
import numpy as np
from scipy.optimize import minimize
from collections import defaultdict
from typing import Sequence


from qiskit.quantum_info import SparsePauliOp
from qiskit.circuit.library import QAOAAnsatz
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import Session, EstimatorV2 as Estimator
from qiskit_ibm_runtime import SamplerV2 as Sampler
```

--------------------------------

### Usage analytics response example

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-runtime-rest/tags/analytics

Example JSON structure returned by the analytics endpoint.

```json
{
  "interval_start": "2024-01-01T00:00:00.000Z",
  "interval_end": "2024-01-01T00:00:00.000Z",
  "data": [
    {
      "key": "ibm-q/open/main",
      "interval_start": "2024-01-01T00:00:00.000Z",
      "interval_end": "2024-01-01T00:00:00.000Z",
      "usage": 10,
      "jobs": 10,
      "sessions": 10,
      "sessions_usage": 10,
      "avg_sessions_usage": 10,
      "max_sessions_usage": 10,
      "batch_sessions": 10,
      "batch_sessions_usage": 10,
      "avg_batch_sessions_usage": 10,
      "max_batch_sessions_usage": 10,
      "dedicated_sessions": 10,
      "dedicated_sessions_usage": 10,
      "avg_dedicated_sessions_usage": 10,
      "max_dedicated_sessions_usage": 10,
      "individual_jobs": 10,
      "individual_jobs_usage": 10,
      "avg_individual_jobs_usage": 10,
      "max_individual_jobs_usage": 10,
      "queue_time": 10,
      "avg_queue_time": 10,
      "max_queue_time": 10
    }
  ]
}
```

--------------------------------

### Example Output Permutation Array

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-c/qk-transpile-layout

An example of an array representing the permutation induced by the transpiler.

```c
[1, 2, 0]
```

--------------------------------

### Install SQD development dependencies

Source: https://quantum.cloud.ibm.com/docs/en/guides/qiskit-addons-sqd

Install the package in editable mode with development and notebook dependencies.

```bash
pip install tox notebook -e '.[notebook-dependencies, dev]'
```

--------------------------------

### Select a backend

Source: https://quantum.cloud.ibm.com/docs/en/guides/serverless-run-first-workload

Initializes the QiskitRuntimeService and selects the least busy operational backend.

```python
from qiskit_ibm_runtime import QiskitRuntimeService

service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)
print(backend.name)
```

--------------------------------

### FakeQuitoV2.__init__

Source: https://quantum.cloud.ibm.com/docs/en/api/qiskit-ibm-runtime/fake-provider-fake-quito-v2

Initializes a new instance of the FakeQuitoV2 backend.

```APIDOC
## FakeQuitoV2(provider=None, name=None, description=None, online_date=None, backend_version=None, **fields)

### Description
Initializes a BackendV2 based fake 5-qubit backend.

### Parameters
- **provider** (object) - Optional - A backwards reference to the provider object.
- **name** (str) - Optional - A name for the backend.
- **description** (str) - Optional - A description of the backend.
- **online_date** (datetime) - Optional - The date the backend was brought online.
- **backend_version** (str) - Optional - Version string for the backend.
- **fields** (kwargs) - Optional - Overrides for default options.

### Raises
- **AttributeError** - If a field is specified that is outside the backend's options.
```

--------------------------------

### Install SQD via PyPI

Source: https://quantum.cloud.ibm.com/docs/en/guides/qiskit-addons-sqd

Use pip to install the package from the Python Package Index.

```bash
pip install qiskit-addon-sqd
```

--------------------------------

### Initialize the Optimization Solver

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/solve-higher-order-binary-optimization-problems-with-q-ctrls-optimization-solver

Authenticate with the Qiskit Functions Catalog and load the Q-CTRL optimization solver.

```python
# Authenticate to the Qiskit Functions Catalog
catalog = QiskitFunctionsCatalog(
    token=token,
    instance=instance,
)

# Load the function
solver = catalog.load("q-ctrl/optimization_solver")
```

--------------------------------

### Install dependencies for MaxCut

Source: https://quantum.cloud.ibm.com/docs/en/guides/kipu-optimization

Install the required networkx and numpy packages before running the optimization script.

```python
# %pip install networkx numpy
```

--------------------------------

### Import Qiskit and Runtime libraries

Source: https://quantum.cloud.ibm.com/docs/en/tutorials/chsh-inequality

Initializes the environment with necessary Qiskit, Runtime, and plotting modules.

```python
# General
import numpy as np

# Qiskit imports
from qiskit import QuantumCircuit
from qiskit.circuit import Parameter
from qiskit.quantum_info import SparsePauliOp
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

# Qiskit Runtime imports
from qiskit_ibm_runtime import QiskitRuntimeService
from qiskit_ibm_runtime import EstimatorV2 as Estimator

# Qiskit Aer for local noisy simulation
from qiskit_aer import AerSimulator

# Plotting routines
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
```
Tokens:
Raw