Transversales Ising-Modell mit Leistungsmanagement von Q-CTRL

Geschätzte Nutzungsdauer: 2 Minuten auf einem Heron r2 Prozessor. (HINWEIS: Dies ist nur eine Schätzung. Ihre Laufzeit kann variieren.)

Hintergrund

Das Transversalfeld-Ising-Modell (TFIM) ist wichtig für die Untersuchung von Quantenmagnetismus und Phasenübergängen. Es beschreibt eine Reihe von Spins, die auf einem Gitter angeordnet sind, wobei jeder Spin mit seinen Nachbarn interagiert und gleichzeitig von einem externen Magnetfeld beeinflusst wird, das Quantenfluktuationen verursacht.

Ein gängiger Ansatz zur Simulation dieses Modells ist die Verwendung der Trotter-Zerlegung zur Annäherung an den Zeitentwicklungsoperator, wobei Schaltkreise konstruiert werden, die zwischen Ein-Qubit-Rotationen und verschränkenden Zwei-Qubit-Wechselwirkungen abwechseln. Die Simulation auf echter Hardware ist jedoch aufgrund von Rauschen und Dekohärenz schwierig, was zu Abweichungen von der tatsächlichen Dynamik führt. Um dieses Problem zu lösen, verwenden wir Q-CTRLs Fire Opal-Fehlerunterdrückungs- und Leistungsmanagement-Tools, die als Qiskit-Funktion angeboten werden (siehe die Fire Opal-Dokumentation ). Fire Opal optimiert automatisch die Ausführung von Schaltungen, indem es dynamische Entkopplung, fortschrittliches Layout, Routing und andere Fehlerunterdrückungstechniken anwendet, die alle darauf abzielen, Rauschen zu reduzieren. Mit diesen Verbesserungen stimmen die Hardware-Ergebnisse besser mit geräuschlosen Simulationen überein, so dass wir die TFIM-Magnetisierungsdynamik mit höherer Genauigkeit untersuchen können.

In diesem Lernprogramm werden wir:

Aufbau des TFIM-Hamiltonianers auf einem Graphen aus verbundenen Spindreiecken
Simulieren Sie die Zeitentwicklung mit trotterisierten Kreisläufen in verschiedenen Tiefen
Berechnung und Visualisierung von Einzel-Qubit-Magnetisierungen $\langle Z_i \rangle$ über die Zeit
Vergleich von Basissimulationen mit den Ergebnissen von Hardware-Läufen unter Verwendung von Q-CTRLs Fire Opal Performance Management

Übersicht

Das Transversalfeld-Ising-Modell (TFIM) ist ein Quantenspinmodell, das wesentliche Merkmale von Quantenphasenübergängen erfasst. Der Hamiltonian ist definiert als:

H = -J \sum_{i} Z_i Z_{i+1} - h \sum_{i} X_i

wobei $Z_i$ und $X_i$ Pauli-Operatoren sind, die auf das Qubit $i$ wirken, $J$ die Stärke der Kopplung zwischen benachbarten Spins ist und $h$ die Stärke des transversalen Magnetfelds ist. Der erste Term steht für klassische ferromagnetische Wechselwirkungen, während der zweite Term Quantenfluktuationen durch das transversale Feld einführt. Zur Simulation der TFIM-Dynamik verwenden Sie eine Trotter-Zerlegung des unitären Evolutionsoperators $e^{-iHt}$ , die durch Schichten von RX- und RZZ-Gattern auf der Grundlage eines benutzerdefinierten Graphen verbundener Spindreiecke implementiert wird. In der Simulation wird untersucht, wie sich die Magnetisierung $\langle Z \rangle$ mit zunehmenden Trotter-Schritten entwickelt.

Die Leistung der vorgeschlagenen TFIM-Implementierung wird durch den Vergleich geräuschloser Simulationen mit verrauschten Backends bewertet. Die verbesserten Ausführungs- und Fehlerunterdrückungsfunktionen von Fire Opal werden eingesetzt, um die Auswirkungen des Rauschens in echter Hardware zu mindern, was zu zuverlässigeren Schätzungen von Spin-Observablen wie $\langle Z_i \rangle$ und Korrelatoren $\langle Z_i Z_j \rangle$ führt.

Anforderungen

Bevor Sie mit diesem Tutorial beginnen, sollten Sie sicherstellen, dass Sie Folgendes installiert haben:

Qiskit SDK v1.4 oder später, mit Visual isierungsunterstützung
Qiskit Runtime v0.40 oder später (pip install qiskit-ibm-runtime)
Qiskit Functions Catalog v0.9.0 (pip install qiskit-ibm-catalog)
Fire Opal SDK v9.0.2 oder höher (pip install fire-opal)
Q-CTRL Visualizer v8.0.2 oder höher (pip install qctrl-visualizer)

Einrichtung

Melden Sie sich zunächst mit Ihrem API-Schlüssel für „ IBM Quantum “ an. Wählen Sie anschließend die Qiskit-Funktion wie folgt aus. (Dieser Code setzt voraus, dass Sie Ihr Konto bereits in Ihrer lokalen Umgebung gespeichert haben.)

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

catalog = QiskitFunctionsCatalog(channel="ibm_quantum_platform")

# Access Function
perf_mgmt = catalog.load("q-ctrl/performance-management")

Schritt 1: Klassische Eingaben einem Quantenproblem zuordnen

TFIM-Diagramm erstellen

Wir beginnen mit der Definition des Spingitters und der Kopplungen zwischen den Spins. In diesem Tutorium wird das Gitter aus zusammenhängenden Dreiecken konstruiert, die in einer linearen Kette angeordnet sind. Jedes Dreieck besteht aus drei Knoten, die in einer geschlossenen Schleife verbunden sind, und die Kette wird gebildet, indem ein Knoten jedes Dreiecks mit dem vorherigen Dreieck verbunden wird.

Die Hilfsfunktion connected_triangles_adj_matrix baut die Adjazenzmatrix für diese Struktur auf. Bei einer Kette von $n$ Dreiecken enthält der resultierende Graph $2n+1$ Knoten.

def connected_triangles_adj_matrix(n):
    """
    Generate the adjacency matrix for 'n' connected triangles in a chain.
    """
    num_nodes = 2 * n + 1
    adj_matrix = np.zeros((num_nodes, num_nodes), dtype=int)

    for i in range(n):
        a, b, c = i * 2, i * 2 + 1, i * 2 + 2  # Nodes of the current triangle

        # Connect the three nodes in a triangle
        adj_matrix[a, b] = adj_matrix[b, a] = 1
        adj_matrix[b, c] = adj_matrix[c, b] = 1
        adj_matrix[a, c] = adj_matrix[c, a] = 1

        # If not the first triangle, connect to the previous triangle
        if i > 0:
            adj_matrix[a, a - 1] = adj_matrix[a - 1, a] = 1

    return adj_matrix

Zur Veranschaulichung des soeben definierten Gitters können wir die Kette der verbundenen Dreiecke aufzeichnen und jeden Knoten beschriften. Die folgende Funktion erstellt das Diagramm für eine bestimmte Anzahl von Dreiecken und zeigt es an.

def plot_triangle_chain(n, side=1.0):
    """
    Plot a horizontal chain of n equilateral triangles.
    Baseline: even nodes (0,2,4,...,2n) on y=0
    Apexes: odd nodes (1,3,5,...,2n-1) above the midpoint.
    """
    # Build graph
    A = connected_triangles_adj_matrix(n)
    G = nx.from_numpy_array(A)

    h = np.sqrt(3) / 2 * side
    pos = {}

    # Place baseline nodes
    for k in range(n + 1):
        pos[2 * k] = (k * side, 0.0)

    # Place apex nodes
    for k in range(n):
        x_left = pos[2 * k][0]
        x_right = pos[2 * k + 2][0]
        pos[2 * k + 1] = ((x_left + x_right) / 2, h)

    # Draw
    fig, ax = plt.subplots(figsize=(1.5 * n, 2.5))
    nx.draw(
        G,
        pos,
        ax=ax,
        with_labels=True,
        font_size=10,
        font_color="white",
        node_size=600,
        node_color=qv.QCTRL_STYLE_COLORS[0],
        edge_color="black",
        width=2,
    )
    ax.set_aspect("equal")
    ax.margins(0.2)
    plt.show()

    return G, pos

Für dieses Tutorial werden wir eine Kette aus 20 Dreiecken verwenden.

n_triangles = 20
n_qubits = 2 * n_triangles + 1
plot_triangle_chain(n_triangles, side=1.0)
plt.show()

Output:

Graphen-Kanten einfärben

Um die Spin-Spin-Kopplung zu realisieren, ist es sinnvoll, Kanten, die sich nicht überschneiden, zu gruppieren. Dies ermöglicht es uns, Zwei-Qubit-Gatter parallel anzuwenden. Wir können dies mit einem einfachen Verfahren zur Kantenfärbung [1] erreichen, das jeder Kante eine Farbe zuweist, so dass Kanten, die sich an demselben Knoten treffen, in verschiedene Gruppen eingeordnet werden.

def edge_coloring(graph):
    """
    Takes a NetworkX graph and returns a list of lists
    where each inner list contains
    the edges assigned the same color.
    """
    line_graph = nx.line_graph(graph)
    edge_colors = nx.coloring.greedy_color(line_graph)

    color_groups = {}
    for edge, color in edge_colors.items():
        if color not in color_groups:
            color_groups[color] = []
        color_groups[color].append(edge)

    return list(color_groups.values())

Schritt 2: Optimierung des Problems für die Ausführung auf Quantenhardware

Erzeugen Sie Trotterisierte Schaltungen auf Spin-Graphen

Um die Dynamik des TFIM zu simulieren, konstruieren wir Schaltungen, die den Zeitentwicklungsoperator annähern.

U(t) = e^{-i H t}, \quad \text{where} \quad H = -J \sum_{\langle i,j \rangle} Z_i Z_j - h \sum_i X_i .

Wir verwenden eine Trotter-Zerlegung zweiter Ordnung:

e^{-i H \Delta t} \approx e^{-i H_X \Delta t / 2}\, e^{-i H_Z \Delta t}\, e^{-i H_X \Delta t / 2},

wobei $H_X = -h \sum_i X_i$ und $H_Z = -J \sum_{\langle i,j \rangle} Z_i Z_j$ .

Der Begriff $H_X$ wird mit Schichten von RX Rotationen umgesetzt.
Der Term $H_Z$ wird mit Schichten von RZZ Gattern entlang der Kanten des Interaktionsgraphen implementiert.

Die Winkel dieser Gatter werden durch das transversale Feld $h$ , die Kopplungskonstante $J$ und den Zeitschritt $\Delta t$ bestimmt. Durch die Stapelung mehrerer Trotter-Schritte erzeugen wir Schaltungen mit zunehmender Tiefe, die die Dynamik des Systems annähern. Die Funktionen generate_tfim_circ_custom_graph und trotter_circuits konstruieren einen trotterisierten Quantenkreis aus einem beliebigen Spininteraktionsgraphen.

def generate_tfim_circ_custom_graph(
    steps, h, J, dt, psi0, graph: nx.graph.Graph, meas_basis="Z", mirror=False
):
    """
    Generate a second order trotter of the form e^(a+b) ~ e^(b/2) e^a e^(b/2)
    for simulating a transverse field ising model:
    e^{-i H t} where the Hamiltonian H = -J \\sum_i Z_i Z_{i+1} + h \\sum_i X_i.

    steps: Number of trotter steps
    theta_x: Angle for layer of X rotations
    theta_zz: Angle for layer of ZZ rotations
    theta_x: Angle for second layer of X rotations
    J: Coupling between nearest neighbor spins
    h: The transverse magnetic field strength
    dt: t/total_steps
    psi0: initial state (assumed to be prepared in the computational basis).
    meas_basis: basis to measure all correlators in

    This is a second order trotter of the form e^(a+b) ~ e^(b/2) e^a e^(b/2)
    """
    theta_x = h * dt
    theta_zz = -2 * J * dt
    nq = graph.number_of_nodes()
    color_edges = edge_coloring(graph)
    circ = QuantumCircuit(nq, nq)
    # Initial state, for typical cases in the computational basis
    for i, b in enumerate(psi0):
        if b == "1":
            circ.x(i)
    # Trotter steps
    for step in range(steps):
        for i in range(nq):
            circ.rx(theta_x, i)
        if mirror:
            color_edges = [sublist[::-1] for sublist in color_edges[::-1]]
        for edge_list in color_edges:
            for edge in edge_list:
                circ.rzz(theta_zz, edge[0], edge[1])
        for i in range(nq):
            circ.rx(theta_x, i)

    # some typically used basis rotations
    if meas_basis == "X":
        for b in range(nq):
            circ.h(b)
    elif meas_basis == "Y":
        for b in range(nq):
            circ.sdg(b)
            circ.h(b)

    for i in range(nq):
        circ.measure(i, i)

    return circ


def trotter_circuits(G, d_ind_tot, J, h, dt, meas_basis, mirror=True):
    """
    Generates a sequence of Trotterized circuits, each with increasing depth.
    Given a spin interaction graph and Hamiltonian parameters, it constructs
    a list of circuits with 1 to d_ind_tot Trotter steps

    G: Graph defining spin interactions (edges = ZZ couplings)
    d_ind_tot: Number of Trotter steps (maximum depth)
    J: Coupling between nearest neighboring spins
    h: Transverse magnetic field strength
    dt: (t / total_steps
    meas_basis: Basis to measure all correlators in
    mirror: If True, mirror the Trotter layers
    """
    qubit_count = len(G)
    circuits = []
    psi0 = "0" * qubit_count

    for steps in range(1, d_ind_tot + 1):
        circuits.append(
            generate_tfim_circ_custom_graph(
                steps, h, J, dt, psi0, G, meas_basis, mirror
            )
        )
    return circuits

Schätzung der Magnetisierungen einzelner Qubits $\langle Z_i \rangle$

Um die Dynamik des Modells zu untersuchen, wollen wir die Magnetisierung jedes Qubits messen, die durch den Erwartungswert $\langle Z_i \rangle = \langle \psi | Z_i | \psi \rangle$ definiert ist.

In Simulationen können wir dies direkt aus den Messergebnissen berechnen. Die Funktion z_expectation verarbeitet die Bitstring-Zählungen und gibt den Wert von $\langle Z_i \rangle$ für einen ausgewählten Qubit-Index zurück. Auf echter Hardware wird dieselbe Größe durch Angabe des Pauli-Operators mit der Funktion generate_z_observables berechnet, und dann berechnet das Backend den Erwartungswert.

def z_expectation(counts, index):
    """
    counts: Dict of mitigated bitstrings.
    index: Index i in the single operator expectation value < II...Z_i...I >
        to be calculated.
    return:  < Z_i >
    """
    z_exp = 0
    tot = 0
    for bitstring, value in counts.items():
        bit = int(bitstring[index])
        sign = 1
        if bit % 2 == 1:
            sign = -1
        z_exp += sign * value
        tot += value

    return z_exp / tot

def generate_z_observables(nq):
    observables = []
    for i in range(nq):
        pauli_string = "".join(["Z" if j == i else "I" for j in range(nq)])
        observables.append(SparsePauliOp(pauli_string))
    return observables

observables = generate_z_observables(n_qubits)

Wir definieren nun die Parameter für die Erstellung der trotterisierten Schaltungen. In diesem Tutorium ist das Gitter eine Kette von 20 verbundenen Dreiecken, was einem 41-Qubit-System entspricht.

all_circs_mirror = []
for num_triangles in [n_triangles]:
    for meas_basis in ["Z"]:
        A = connected_triangles_adj_matrix(num_triangles)
        G = nx.from_numpy_array(A)
        nq = len(G)
        d_ind_tot = 22
        dt = 2 * np.pi * 1 / 30 * 0.25
        J = 1
        h = -7
        all_circs_mirror.extend(
            trotter_circuits(G, d_ind_tot, J, h, dt, meas_basis, True)
        )
circs = all_circs_mirror

Schritt 3: Mit „ Qiskit primitives “ ausführen

MPS-Simulation ausführen

Die Liste der trotterisierten Schaltungen wird mit dem matrix_product_state Simulator mit einer beliebigen Auswahl von $4096$ Schüssen ausgeführt. Die MPS-Methode bietet eine effiziente Annäherung an die Schaltungsdynamik, wobei die Genauigkeit durch die gewählte Bindungsdimension bestimmt wird. Bei den hier betrachteten Systemgrößen ist die Standardabmessung der Bindung ausreichend, um die Magnetisierungsdynamik mit hoher Genauigkeit zu erfassen. Die rohen Zählungen werden normalisiert, und daraus werden die Ein-Qubit-Erwartungswerte $\langle Z_i \rangle$ bei jedem Trotter-Schritt berechnet. Schließlich berechnen wir den Durchschnitt über alle Qubits, um eine einzige Kurve zu erhalten, die zeigt, wie sich die Magnetisierung im Laufe der Zeit verändert.

backend_sim = AerSimulator(method="matrix_product_state")


def normalize_counts(counts_list, shots):
    new_counts_list = []
    for counts in counts_list:
        a = {k: v / shots for k, v in counts.items()}
        new_counts_list.append(a)
    return new_counts_list


def run_sim(circ_list):
    shots = 4096
    res = backend_sim.run(circ_list, shots=shots)
    normed = normalize_counts(res.result().get_counts(), shots)
    return normed


sim_counts = run_sim(circs)

Auf Hardware ausführen

service = QiskitRuntimeService()
backend = service.backend("ibm_marrakesh")


def run_qiskit(circ_list):
    shots = 4096
    pm = generate_preset_pass_manager(backend=backend)
    isa_circuits = [pm.run(qc) for qc in circ_list]
    sampler = Sampler(mode=backend)
    res = sampler.run(isa_circuits, shots=shots)
    res = [r.data.c.get_counts() for r in res.result()]
    normed = normalize_counts(res, shots)
    return normed


qiskit_counts = run_qiskit(circs)

Auf Hardware mit Fire Opal ausführen

Wir untersuchen die Magnetisierungsdynamik auf realer Quantenhardware. Fire Opal stellt eine Qiskit-Funktion bereit, die die Standardprimitive „ IBM Quantum -Estimator“ um automatische Fehlerunterdrückung und Leistungsmanagement erweitert. Wir übermitteln die „Trotterisierten“ Schaltkreise direkt an ein „ IBM® “-Backend, während Fire Opal die rauschbewusste Ausführung übernimmt.

Wir erstellen eine Liste von pubs, in der jedes Element einen Schaltkreis und die entsprechenden Pauli-Z-Beobachtungswerte enthält. Diese werden an die Schätzfunktion von Fire Opal weitergegeben, die die Erwartungswerte $\langle Z_i \rangle$ für jedes Qubit bei jedem Trotter-Schritt zurückgibt. Die Ergebnisse können dann über die Qubits gemittelt werden, um die Magnetisierungskurve der Hardware zu erhalten.

backend_name = "ibm_marrakesh"
estimator_pubs = [(qc, observables) for qc in all_circs_mirror[:]]

# Run the circuit using the estimator
qctrl_estimator_job = perf_mgmt.run(
    primitive="estimator",
    pubs=estimator_pubs,
    backend_name=backend_name,
    options={"default_shots": 4096},
)

result_qctrl = qctrl_estimator_job.result()

Schritt 4: Nachbearbeitung und Rückgabe des Ergebnisses im gewünschten klassischen Format

Schließlich vergleichen wir die Magnetisierungskurve aus dem Simulator mit den Ergebnissen, die wir auf echter Hardware erhalten haben. Wenn man beide nebeneinander aufträgt, sieht man, wie sehr die Hardware-Ausführung mit Fire Opal der geräuschlosen Basislinie über Trotter-Schritte entspricht.

def make_correlators(test_counts, nq, d_ind_tot):
    mz = np.empty((nq, d_ind_tot))
    for d_ind in range(d_ind_tot):
        counts = test_counts[d_ind]
        for i in range(nq):
            mz[i, d_ind] = z_expectation(counts, i)
    average_z = np.mean(mz, axis=0)
    return np.concatenate((np.array([1]), average_z), axis=0)


sim_exp = make_correlators(sim_counts[0:22], nq=nq, d_ind_tot=22)
qiskit_exp = make_correlators(qiskit_counts[0:22], nq=nq, d_ind_tot=22)

qctrl_exp = [ev.data.evs for ev in result_qctrl[:]]
qctrl_exp_mean = np.concatenate(
    (np.array([1]), np.mean(qctrl_exp, axis=1)), axis=0
)

def make_expectations_plot(
    sim_z,
    depths,
    exp_qctrl=None,
    exp_qctrl_error=None,
    exp_qiskit=None,
    exp_qiskit_error=None,
    plot_from=0,
    plot_upto=23,
):
    import numpy as np
    import matplotlib.pyplot as plt

    depth_ticks = [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22]

    d = np.asarray(depths)[plot_from:plot_upto]
    sim = np.asarray(sim_z)[plot_from:plot_upto]

    qk = (
        None
        if exp_qiskit is None
        else np.asarray(exp_qiskit)[plot_from:plot_upto]
    )
    qc = (
        None
        if exp_qctrl is None
        else np.asarray(exp_qctrl)[plot_from:plot_upto]
    )

    qk_err = (
        None
        if exp_qiskit_error is None
        else np.asarray(exp_qiskit_error)[plot_from:plot_upto]
    )
    qc_err = (
        None
        if exp_qctrl_error is None
        else np.asarray(exp_qctrl_error)[plot_from:plot_upto]
    )

    # ---- helper(s) ----
    def rmse(a, b):
        if a is None or b is None:
            return None
        a = np.asarray(a, dtype=float)
        b = np.asarray(b, dtype=float)
        mask = np.isfinite(a) & np.isfinite(b)
        if not np.any(mask):
            return None
        diff = a[mask] - b[mask]
        return float(np.sqrt(np.mean(diff**2)))

    def plot_panel(ax, method_y, method_err, color, label, band_color=None):
        # Noiseless reference
        ax.plot(d, sim, color="grey", label="Noiseless simulation")

        # Method line + band
        if method_y is not None:
            ax.plot(d, method_y, color=color, label=label)
            if method_err is not None:
                lo = np.clip(method_y - method_err, -1.05, 1.05)
                hi = np.clip(method_y + method_err, -1.05, 1.05)
                ax.fill_between(
                    d,
                    lo,
                    hi,
                    alpha=0.18,
                    color=band_color if band_color else color,
                    label=f"{label} ± error",
                )
        else:
            ax.text(
                0.5,
                0.5,
                "No data",
                transform=ax.transAxes,
                ha="center",
                va="center",
                fontsize=10,
                color="0.4",
            )

        # RMSE box (vs sim)
        r = rmse(method_y, sim)
        if r is not None:
            ax.text(
                0.98,
                0.02,
                f"RMSE: {r:.4f}",
                transform=ax.transAxes,
                va="bottom",
                ha="right",
                fontsize=8,
                bbox=dict(
                    boxstyle="round,pad=0.35", fc="white", ec="0.7", alpha=0.9
                ),
            )
        # Axes
        ax.set_xticks(depth_ticks)
        ax.set_ylim(-1.05, 1.05)
        ax.grid(True, which="both", linewidth=0.4, alpha=0.4)
        ax.set_axisbelow(True)
        ax.legend(prop={"size": 8}, loc="best")

    fig, axes = plt.subplots(1, 2, figsize=(10, 4), dpi=300, sharey=True)

    axes[0].set_title("Fire Opal (Q-CTRL)", fontsize=10)
    plot_panel(
        axes[0],
        qc,
        qc_err,
        color="#680CE9",
        label="Fire Opal",
        band_color="#680CE9",
    )
    axes[0].set_xlabel("Trotter step")
    axes[0].set_ylabel(r"$\langle Z \rangle$")
    axes[1].set_title("Qiskit", fontsize=10)
    plot_panel(
        axes[1], qk, qk_err, color="blue", label="Qiskit", band_color="blue"
    )
    axes[1].set_xlabel("Trotter step")

    plt.tight_layout()
    plt.show()

depths = list(range(d_ind_tot + 1))
errors = np.abs(np.array(qctrl_exp_mean) - np.array(sim_exp))

errors_qiskit = np.abs(np.array(qiskit_exp) - np.array(sim_exp))

make_expectations_plot(
    sim_exp,
    depths,
    exp_qctrl=qctrl_exp_mean,
    exp_qctrl_error=errors,
    exp_qiskit=qiskit_exp,
    exp_qiskit_error=errors_qiskit,
)

Output:

Referenzen

[1] Graphenfärbung. Wikipedia. Abgerufen am 15. September 2025, von https://en.wikipedia.org/wiki/Graph _coloring

Tutorial-Umfrage

Bitte nehmen Sie sich eine Minute Zeit, um uns Feedback zu diesem Tutorial zu geben. Ihre Erkenntnisse helfen uns, unser Inhaltsangebot und unsere Nutzererfahrung zu verbessern.

Link zur Umfrage

War diese Seite hilfreich?

Melden Sie auf GitHub einen Fehler, einen Tippfehler oder fordern Sie Inhalte an.