Zum Hauptinhalt springen
Dieses Projekt befindet sich in der Beta-Phase. Einen Fehler gefunden? GitHub Issue erstellen. Frage oder Idee? In Discussions fragen — wir freuen uns über dein Feedback!
Wie ist die Übersetzungsqualität auf dieser Seite?

Verrauschte Quantenzustände mit klassischen Shadows lernen

Nutzungsschätzung: 34 Minuten auf einem Heron-r2-Prozessor (HINWEIS: Dies ist nur eine Schätzung. Deine Laufzeit kann abweichen.)

Lernziele​

  • Randomisierte Messungen auf einem IBM® Quantenprozessor mit Julia erfassen und für die spätere Analyse speichern

  • Die Messdaten vor dem Lernen auf fehlerhafte Qubits und Gates prüfen

  • Ein Matrixproduktoperator-Modell (MPO) eines verrauschten Zustands an klassische Shadows anpassen

  • Das Modell an zurückgehaltenen Messungen validieren und mit dem idealen Circuit vergleichen

Voraussetzungen​

Hintergrund​

Auf einem realen Quantenprozessor verwandelt Rauschen den reinen Zustand ∣ψ⟩|\psi\rangle, den ein Circuit vorbereiten soll, in einen gemischten Zustand ρ\rho. Die vollständige Quantenzustandstomographie kann ρ\rho rekonstruieren, aber die Anzahl der dafür nötigen Messungen wächst exponentiell mit der Zahl der Qubits. Votto et al. [1] haben stattdessen aus randomisierten Messungen ein kompaktes Modell von ρ\rho für bis zu 96 Qubits gelernt. Dieses Tutorial folgt ihrem Workflow.

Bei einer randomisierten Messung [2] wird jedes Qubit ii mit einer unabhängigen zufälligen Unitären uiu_i rotiert und dann in der Rechenbasis gemessen. Eine Ziehung der Rotationen heißt Messeinstellung, und jede Einstellung wird für NMN_M Shots wiederholt. Ein Shot mit den Ergebnisbits sis_i ergibt den klassischen Shadow [3]

ρ^=⨂i=1N(3 ui†∣si⟩⟨si∣ui−1),\hat\rho=\bigotimes_{i=1}^{N}\left(3\,u_i^\dagger|s_i\rangle\langle s_i|u_i-\mathbb{1}\right),

dessen Mittelwert über Einstellungen und Shots ρ\rho ist. Das Voraussetzungs-Tutorial zieht jedes uiu_i aus den drei Pauli-Basen; dieses Tutorial zieht sie, wie das Paper, gleichverteilt aus allen Einzel-Qubit-Unitären (Haar-zufällig), und dieselbe Formel gilt.

Shadows schätzen Eigenschaften weniger Qubits gleichzeitig ab. Das Paper kombiniert sie zu einem Matrixproduktoperator (MPO), der die Dichtematrix als Kette kleiner Tensoren schreibt, einen pro Qubit; verrauschte Zustände mit kurzreichweitigen Korrelationen benötigen nur kleine Bindungen zwischen benachbarten Tensoren. Wie beim Algorithmus der Dichtematrix-Renormierungsgruppe (DMRG) läuft der Lernalgorithmus die Kette entlang und aktualisiert jeweils einen Tensor, sodass das Modell die Shadows auf dem Fenster aus 2ℓ+12\ell+1 Qubits, zentriert um diesen Tensor, reproduziert (Gleichung 4 des Papers). Die Bonddimension bleibt bei diesen Aktualisierungen fest, sodass der Lernalgorithmus das Modell nie abschneidet. Weil die Daten nur über diese Fenster eingehen, wächst die Zahl der benötigten Einstellungen nicht mit der Länge der Kette.

Die Einstellungen werden in eine Trainingsmenge und eine Testmenge aufgeteilt. Auf der Testmenge schätzt das Paper die maximale Fidelity zwischen ρ\rho und dem Modell σ\sigma,

Fmax⁡(ρ,σ)=tr(ρσ)max⁡(tr ρ2, tr σ2).\mathcal{F}_{\max}(\rho,\sigma)=\frac{\mathrm{tr}(\rho\sigma)}{\max\left(\mathrm{tr}\,\rho^2,\ \mathrm{tr}\,\sigma^2\right)}.

tr(ρσ)\mathrm{tr}(\rho\sigma) direkt zu messen würde exponentiell viele Messungen erfordern. Stattdessen nimmt das Paper die approximative Faktorisierungsbedingung (AFC) an: Korrelationen in ρ\rho klingen innerhalb weniger Qubits ab, sodass globale Überlappungen und Reinheiten in Terme auf Blöcken aus kk benachbarten Qubits faktorisieren. Die Reinheit liefert auch die Rényi-2-Entropie S2=−log⁡2tr ρ2S_2=-\log_2\mathrm{tr}\,\rho^2, die misst, wie gemischt der Zustand ist.

Das Paper bereitet den Kicked-Ising-Zustand der Tiefe DD vor

∣ψ⟩=(∏jeiπ4ZjZj+1∏je−iπ8Xj)D∣0⟩⊗N|\psi\rangle=\left(\prod_{j} e^{i\frac{\pi}{4}Z_jZ_{j+1}}\prod_j e^{-i\frac{\pi}{8}X_j}\right)^{D}|0\rangle^{\otimes N}

auf 96 Qubits von ibm_brisbane, einem Eagle-Prozessor, mit 2.048 Einstellungen zu je 1.024 Shots für D=1D=1. Abbildung 1(c,d) des Papers berichtet zwei Ergebnisse für D=1D=1:

  • Das gelernte Modell erreicht Fmax⁡≈75%\mathcal{F}_{\max}\approx 75\% mit dem experimentellen Zustand bei N=96N=96, weit über der Überlappung des idealen Zustands ∣ψ⟩|\psi\rangle mit dem Experiment.

  • Die Entropie wächst linear, S2≈(0.14 bis 0.15) NS_2\approx(0.14\text{ bis }0.15)\,N, und die Entropie des Modells stimmt mit einer unabhängigen Schätzung aus der Testmenge überein.

Dieses Tutorial prüft beide Ergebnisse, zuerst in einer Simulation mit acht Qubits, bei der die exakten Antworten bekannt sind, und dann in einem neuen 96-Qubit-Lauf auf ibm_fez, einem Heron-r2-Prozessor. Der Lernalgorithmus ist eine unabhängige Julia-Implementierung der Gleichungen im Paper und seinem Supplement.

Anforderungen​

Dieses Tutorial erfordert macOS oder Linux, da Qiskit.jl Windows noch nicht unterstützt (Qiskit.jl issue #15). Außerdem benötigst du Folgendes:

  • Julia 1.11, von der Julia-Downloadseite oder mit juliaup add 1.11, und das Paket IJulia:

    julia -e 'using Pkg; Pkg.add("IJulia")'
  • Für das Hardware-Beispiel ein IBM Quantum® Platform-Konto mit Zugriff auf eine QPU mit mindestens 96 Qubits sowie gespeicherte Zugangsdaten. Ohne Konto kannst du das Hardware-Beispiel mit den gespeicherten Messungen des Laufs auf ibm_fez ausführen, der die Ergebnisse in diesem Tutorial geliefert hat. Die anderen Abschnitte laufen ohne Konto.

Das Notebook verwendet Qiskit.jl und QiskitIBMRuntime.jl, um Circuits zu erstellen und auszuführen, RandomMeas.jl [4] für randomisierte Messungen (es stellt auch ITensors.jl und ITensorMPS.jl bereit) sowie NPZ.jl, JSON.jl und Plots.jl. Dieses Tutorial ist mit Qiskit.jl 0.6.1, QiskitIBMRuntime.jl 0.3.2 und RandomMeas.jl 0.3.1 getestet.

Es gibt zwei Möglichkeiten, die Umgebung einzurichten:

  • Option 1: Installiere die neuesten kompatiblen Versionen der Pakete in eine temporäre Umgebung. Führe die folgende Zelle unverändert aus.

  • Option 2: Reproduziere die getestete Umgebung exakt. Setze download_toml_files = true in der folgenden Zelle. Die Zelle lädt Project.toml und Manifest.toml aus dem Dokumentations-Repository in einen Ordner env_tutorial/classical-shadows/ neben diesem Notebook herunter und installiert dann die exakte Version jedes Pakets, die das Manifest verzeichnet, einschließlich indirekter Abhängigkeiten. Details findest du in der Julia-Dokumentation zu diesen Dateien.

using Pkg
using Downloads

download_toml_files = false

if !download_toml_files
# Option 1: Install the latest compatible versions into a temporary environment
Pkg.activate(mktempdir(); io=devnull)
Pkg.add([
PackageSpec(name="Qiskit", version="0.6"),
PackageSpec(name="QiskitIBMRuntime", version="0.3"),
PackageSpec(name="RandomMeas", version="0.3"),
PackageSpec(name="NPZ"),
PackageSpec(name="JSON"),
PackageSpec(name="Plots"),
]; io=devnull)
else
# Option 2: Install the exact tested versions recorded in Project.toml and Manifest.toml
base_url = "https://raw.githubusercontent.com/Qiskit/documentation/main/docs/tutorials/assets/classical-shadows/julia"
env_dir = joinpath(@__DIR__, "env_tutorial", "classical-shadows")
mkpath(env_dir)
for file in ("Project.toml", "Manifest.toml")
Downloads.download("$base_url/$file", joinpath(env_dir, file))
end
Pkg.activate(env_dir; io=devnull)
Pkg.instantiate(; io=devnull)
end

Einrichtung​

using RandomMeas # also loads ITensors and ITensorMPS
using Qiskit, QiskitIBMRuntime
using Random, LinearAlgebra, Statistics
using Downloads, SHA, NPZ, JSON, Plots

# Download the helper module that implements the learner, unless a copy exists
docs_url = "https://raw.githubusercontent.com/Qiskit/documentation/main"
helper_file = joinpath(@__DIR__, "env_tutorial", "classical-shadows", "mpo_learning.jl")
if !isfile(helper_file)
mkpath(dirname(helper_file))
helper_url = "$docs_url/docs/tutorials/assets/classical-shadows/julia/mpo_learning.jl"
Downloads.download(helper_url, helper_file)
end
include(helper_file)
using .ShadowMPOLearning
BLAS.set_num_threads(1) # the learner multiplies many small matrices

Das Hilfsmodul mpo_learning.jl, das die Einrichtungszelle herunterlädt, implementiert den Lernalgorithmus. Das Tutorial ruft daraus die folgenden Funktionen auf:

FunktionZweck
kicked_ising_reference(N, D; depolarization)Exakter MPO des idealen Kicked-Ising-Zustands oder des Zustands nach lokalem depolarisierendem Rauschen
split_settings(group; seed, train_fraction)Messeinstellungen zufällig Trainings- und Testmengen zuweisen (standardmäßig je zur Hälfte)
training_marginals(train; ell, prior)Shadow-Schätzungen jedes Lernfensters, nur aus den Trainingseinstellungen
fitted_prior(ideal, train)Prior für gemeinsame randomisierte Messungen (CRM), angepasst an die gemessene Reinheit jedes Fensters, wie im Paper
learn_mpo(marginals, N; ell, maxbond, sweeps)Das Ein-Site-Update des Papers entlang der Kette durchlaufen, beginnend mit dem maximal gemischten Zustand
max_fidelity(a, b), mpo_overlap(a, b)Exaktes Fmax⁡\mathcal{F}_{\max} und tr(ab)\mathrm{tr}(ab) zwischen zwei MPOs
afc_estimate, afc_statistics, afc_prefix_curveAFC-Schätzungen von Fmax⁡\mathcal{F}_{\max} und S2S_2 aus den Testeinstellungen, mit Jackknife-Fehlerbalken

Der Lernalgorithmus speichert den MPO in der Pauli-Basis. Dadurch bleibt das Modell hermitesch mit Spur eins, aber es erzwingt nicht, dass das Modell positiv semidefinit ist, weshalb das Notebook berichtet, wie negativ seine Eigenwerte werden.

Beispiel mit kleinem Simulator​

Beginne mit einem System, das klein genug ist, um alles exakt zu berechnen: dem Kicked-Ising-Zustand der Tiefe eins auf acht Qubits, mit 12 % lokalem depolarisierendem Rauschen, um die Hardware zu modellieren. Da der verrauschte Zustand bekannt ist, kannst du das gelernte Modell direkt mit ihm vergleichen.

Schritt 1: Klassische Eingaben auf ein Quantenproblem abbilden​

Die Funktion kicked_ising_reference liefert den exakten Zustand als MPO. Mit depolarization=0.12 schrumpft der Bloch-Vektor jedes Qubits nach dem Circuit um 12 %.

N = 8
ideal = kicked_ising_reference(N, 1)
rho = kicked_ising_reference(N, 1; depolarization=0.12)
println("Purity of the noisy state: ", round(mpo_overlap(rho, rho), digits=3))
println("F_max between the noisy and ideal states: ", round(max_fidelity(rho, ideal), digits=3))
Purity of the noisy state: 0.327
F_max between the noisy and ideal states: 0.56

Schritt 2: Problem für die Ausführung auf Quantenhardware optimieren​

Dieses Beispiel zieht Messergebnisse klassisch, daher gibt es keinen Circuit zu transpilieren. Das Hardware-Beispiel behandelt diesen Schritt.

Schritt 3: Ausführung mit Qiskit-Primitiven​

Verwende RandomMeas.jl, um 2.048 Haar-zufällige Messeinstellungen zu ziehen und aus jeder 256 Shots zu samplen, und teile die Einstellungen dann gleichmäßig in Trainings- und Testmengen auf. Teile nach Einstellung und nicht nach Shot auf: Shots derselben Einstellung teilen sich deren Rotationen, sind also nicht unabhängig.

Random.seed!(20260921)
sites = siteinds("Qubit", N)
settings = [LocalUnitaryMeasurementSetting(N; site_indices=sites, ensemble=Haar) for _ in 1:2048]
measurements = MeasurementGroup(to_itensor_mpo(rho, sites), settings, 256)
split = split_settings(measurements; seed=20260921)
println(length(split.train_ids), " training settings, ", length(split.test_ids), " testing settings")
1024 training settings,
1024 testing settings

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

Lerne das Modell mit den Tiefe-eins-Parametern des Papers: Fenster, die sich ℓ=2\ell=2 Qubits zu jeder Seite des aktualisierten Tensors erstrecken, eine Bonddimension von 4 und 20 Sweeps, beginnend mit dem maximal gemischten Zustand. Der erste Sweep aktualisiert benachbarte Tensorpaare, wodurch die Bonddimension von 1 auf 4 wachsen kann; jeder spätere Sweep aktualisiert jeweils einen Tensor bei dieser festen Bonddimension.

Um das statistische Rauschen der Shadows zu verringern, verwendet das Paper gemeinsame randomisierte Messungen (CRM) [5]. Für jede Einstellung subtrahiert es den mittleren Shadow, den eine Vorabschätzung des Zustands in derselben Einstellung erzeugen würde, und addiert dann den exakten Wert des Priors wieder hinzu. Die Korrektur mittelt sich zu null, sodass der Prior die Größe des statistischen Fehlers ändert, nicht aber, was geschätzt wird. Hier ist der Prior der ideale Zustand mit 10 % lokaler Depolarisation, nahe an den wahren 12 %. Auf Hardware ist das Rauschniveau unbekannt, daher passt das Hardware-Beispiel den Prior stattdessen an gemessene Reinheiten an, wie es das Paper tut.

prior = kicked_ising_reference(N, 1; depolarization=0.10)
marginals = training_marginals(split.train; ell=2, prior)
fit = learn_mpo(marginals, N; ell=2, maxbond=4, sweeps=20)
sigma = fit.model
plot([h.sweep for h in fit.history], [h.local_loss for h in fit.history];
xlabel="sweep", ylabel="mean squared residual", label="training windows",
size=(680, 320), left_margin=5Plots.mm, bottom_margin=5Plots.mm)

Output of the previous code cell

Das Residuum misst, wie weit die Fenster des Modells von den Trainings-Shadows entfernt sind. Es sinkt, wenn die Ein-Site-Updates im zweiten Sweep beginnen, und bleibt dann ungefähr konstant, statt null zu erreichen, weil die Shadows statistisches Rauschen enthalten, das ein Modell mit kleiner Bonddimension nicht reproduzieren kann.

Da dieser Zustand bekannt ist, kannst du das gelernte Modell exakt mit ihm vergleichen und außerdem die beiden einfachsten Schätzungen mit ihm vergleichen: den CRM-Prior und den idealen Zustand.

eigenvalues = eigvals(Hermitian(dense_operator(sigma)))
println("F_max with the noisy state")
println(" learned model: ", round(max_fidelity(rho, sigma), digits=3))
println(" CRM prior: ", round(max_fidelity(rho, prior), digits=3))
println(" ideal state: ", round(max_fidelity(rho, ideal), digits=3))
println("Most negative eigenvalue of the model: ", round(minimum(eigenvalues), digits=4))
println("Total negative eigenvalue weight: ", round(-sum(min.(eigenvalues, 0)), digits=4))
F_max with the noisy state
learned model: 0.993
CRM prior: 0.911
ideal state: 0.56
Most negative eigenvalue of the model: -0.0076
Total negative eigenvalue weight: 0.0348

Das gelernte Modell liegt näher am verrauschten Zustand als der Prior oder der ideale Zustand, hat also das Rauschen aus den Daten gelernt. Seine kleinen negativen Eigenwerte stammen von der endlichen Anzahl an Messungen.

Auf Hardware ist der Zustand unbekannt, daher schätzt du stattdessen Fmax⁡\mathcal{F}_{\max} aus den Testeinstellungen ab. AFC teilt die Kette in Blöcke A1,…,ARA_1,\dots,A_R aus je kk Qubits und nähert die Reinheit an durch

tr ρ2≈∏i=1R−1tr ρAiAi+12∏i=2R−1tr ρAi2,\mathrm{tr}\,\rho^2\approx\frac{\prod_{i=1}^{R-1}\mathrm{tr}\,\rho_{A_iA_{i+1}}^2}{\prod_{i=2}^{R-1}\mathrm{tr}\,\rho_{A_i}^2},

und tr(ρσ)\mathrm{tr}(\rho\sigma) durch dasselbe Verhältnis lokaler Überlappungen. Mit k=4k=4 decken die beiden Blöcke alle acht Qubits ab und die Formel ist exakt; mit k=2k=2 stützt sie sich auf die Faktorisierungsannahme. Die Jackknife-Fehlerbalken, die jeweils eine Testeinstellung auslassen, erfassen nur den statistischen Fehler der Testdaten, nicht die Zufälligkeit des Trainings oder die AFC-Näherung.

for k in (2, 4)
estimate = afc_estimate(sigma, split.test; k, statistics=afc_statistics(split.test, k; prior))
println("k = $k: held-out F_max = ", round(estimate.fidelity, digits=3), " ± ",
round(estimate.fidelity_sem, digits=3))
end
println("Exact F_max: ", round(max_fidelity(rho, sigma), digits=3))
k = 2: held-out F_max = 0.966
± 0.036
k = 4: held-out F_max =
0.958 ± 0.049
Exact F_max: 0.993

Beide zurückgehaltenen Schätzungen stimmen innerhalb ihrer Fehlerbalken mit dem exakten Wert überein.

Hardware-Beispiel im großen Maßstab​

Führe nun das Experiment auf einer 96-Qubit-Kette von ibm_fez aus, einem Heron-r2-Prozessor. Wie ibm_brisbane hat er eine Heavy-Hex-Kopplungskarte und ein ähnliches Rauschniveau.

Die Datenerfassung dauert 1.024 Sampler-Jobs und etwa 34 Minuten QPU-Zeit. Wenn du keinen Zugriff auf eine QPU mit mindestens 96 Qubits hast oder die Warteschlange lang ist, führe das Hardware-Beispiel mit den am 27. September 2026 auf ibm_fez aufgezeichneten Messungen aus, die die in diesem Tutorial gezeigten Ergebnisse geliefert haben. Mit use_saved_data = true lädt das Notebook diese Messungen (15 MB) in Schritt 1 von Zenodo [6] herunter und überspringt die Job-Übermittlung in Schritt 3. Setze den Wert auf false, um eigene Daten zu erfassen.

use_saved_data = true; # set to false to collect new measurements on hardware

Schritt 1: Klassische Eingaben auf ein Quantenproblem abbilden​

Jede Einstellung benötigt einen Circuit: den Kicked-Ising-Circuit, ein U(θ,ϕ,λ)U(\theta,\phi,\lambda)-Gate auf jedem Qubit für uiu_i und eine Messung jedes Qubits. Wenn du θ=2arcsin⁡v\theta=2\arcsin\sqrt{v} ziehst, wobei vv, ϕ/2π\phi/2\pi und λ/2π\lambda/2\pi gleichverteilt in [0,1)[0,1) sind, ist UU Haar-zufällig. Die Funktion u3_matrix gibt die Matrix von UU zurück, die Schritt 4 verwendet.

Das Budget beträgt 1.024 Einstellungen mit je 1.024 Shots, also halb so viele Einstellungen wie in der Veröffentlichung, gleichmäßig aufgeteilt auf Training und Test. Wenn gespeicherte Daten vorhanden sind, lädt die Zelle die aufgezeichneten Winkel. Andernfalls zieht sie neue Winkel und speichert sie, bevor du etwas einreichst, weil du die Ergebnisse ohne sie nicht auswerten kannst. Wenn die Datei bereits existiert, lädt die Zelle sie, sodass die Winkel auch nach einem Neustart der Session noch zu den gespeicherten Ergebnissen passen.

"Matrix of the U(θ, ϕ, λ) gate, as used by `qc.u` in Qiskit."
u3_matrix(θ, ϕ, λ) = [cos(θ/2) -exp(im*λ)*sin(θ/2);
exp(im*ϕ)*sin(θ/2) exp(im*(ϕ + λ))*cos(θ/2)]

"Angles (θ, ϕ, λ) for which `u3_matrix(θ, ϕ, λ)` is a Haar-random unitary."
random_u3_angles() = (2asin(sqrt(rand())), 2π*rand(), 2π*rand())

N_hw, NU_hw, NM_hw = 96, 1024, 1024
data_directory = joinpath(@__DIR__, "classical-shadows-data")
saved_file = joinpath(data_directory, "ibm-fez-run.npz")
run_directory = joinpath(data_directory, "new-run")
settings_file = joinpath(run_directory, "settings.npz")
if use_saved_data
saved_url = "https://zenodo.org/records/24116174/files/ibm-fez-run.npz?download=1"
saved_sha256 = "c42f4d8d42e5083e9e152b4fec0846884ebe3be003e5ab528deebf4f00c9fe50"
if !isfile(saved_file)
mkpath(data_directory)
println("Downloading the saved ibm_fez run (15 MB)...")
Downloads.download(saved_url, saved_file * ".part")
mv(saved_file * ".part", saved_file)
end
bytes2hex(open(sha256, saved_file)) == saved_sha256 ||
error("$saved_file is incomplete or corrupted; delete it and run this cell again")
saved_run = npzread(saved_file)
angles = saved_run["angles"]
elseif isfile(settings_file)
angles = npzread(settings_file)["angles"]
else
mkpath(joinpath(run_directory, "outcomes"))
Random.seed!(20260927)
angles = Array{Float64}(undef, NU_hw, N_hw, 3)
for r in 1:NU_hw, i in 1:N_hw
angles[r, i, :] .= random_u3_angles()
end
npzwrite(settings_file, Dict("angles" => angles))
end
println("Measurement settings: ", size(angles, 1), " × ", size(angles, 2), " qubits")
Measurement settings: 1024
× 96 qubits

Schritt 2: Problem für die Ausführung auf Quantenhardware optimieren​

Eine Kette ist nur so gut wie ihr schlechtestes Qubit, also wähle die 96 physischen Qubits selbst aus. Die Funktion transpile von Qiskit.jl kann noch kein festes anfängliches Layout akzeptieren, und in einem Test auf ibm_phoenix enthielt das gewählte Layout ein Qubit mit 51 % Auslesefehler. Die folgende Kette ist der 96-Qubit-Pfad in der Coupling Map von ibm_fez, den das fehlerbewusste Layout der Python-Funktion Qiskit transpile (mit optimization_level=3) aus den Kalibrierungsdaten vom 27. September 2026 ausgewählt hat. Ihr mittlerer Auslesefehler beträgt 1,6 %, aber ein Heavy-Hex-Gitter hat nur wenige 96-Qubit-Pfade, und dieser enthält Qubit 35 mit einem Auslesefehler von 15 %. Kalibrierungen ändern sich, also wähle eine neue Kette aus den aktuellen Kalibrierungsdaten, bevor du an einem anderen Tag oder auf einer anderen QPU ausführst.

Um diese Kette beizubehalten, schreibe die Circuits direkt in nativen Gates, statt sie zu transpilieren. Ein U(θ,ϕ,λ)U(\theta,\phi,\lambda)-Gate entspricht bis auf eine globale Phase RZ(ϕ+π) X RZ(θ+π) X RZ(λ)R_Z(\phi+\pi)\,\sqrt{X}\,R_Z(\theta+\pi)\,\sqrt{X}\,R_Z(\lambda). Diese Zerlegung deckt sowohl die zufälligen Rotationen als auch den Kick e−iπ8X=U(π/4,−π/2,π/2)e^{-i\frac{\pi}{8}X}=U(\pi/4,-\pi/2,\pi/2) ab. Das Gate eiπ4ZjZj+1e^{i\frac{\pi}{4}Z_jZ_{j+1}} entspricht bis auf eine globale Phase einem CZ-Gate, gefolgt von S†S^\dagger auf beiden Qubits. Da diese S†S^\dagger-Gates diagonal sind, kommutieren sie mit den CZ-Gates, sodass jedes Qubit vor seiner Messrotation ein RZ(−π/2)R_Z(-\pi/2) pro Bindung ansammelt.

num_device_qubits = 156
# Physical qubits of ibm_fez, in IBM numbering, forming the chain
chain_physical = [
2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 19, 35, 34, 33, 39, 53, 54, 55, 59, 75, 74,
73, 79, 93, 94, 95, 99, 115, 114, 113, 119, 133, 132, 131, 130, 129, 128, 127, 137, 147, 146,
145, 144, 143, 136, 123, 124, 125, 117, 105, 106, 107, 108, 109, 110, 111, 98, 91, 90, 89,
88, 87, 86, 85, 77, 65, 66, 67, 68, 69, 70, 71, 58, 51, 50, 49, 48, 47, 46, 45, 37, 25, 24,
23, 22, 21, 36, 41, 42, 43, 56, 63]
chain = chain_physical .+ 1 # Qiskit.jl numbers qubits from 1

"Apply U(θ, ϕ, λ) to qubit q with native gates: rz(λ), sx, rz(θ + π), sx, rz(ϕ + π)."
function native_u!(qc, q, θ, ϕ, λ)
qc.rz(λ, q)
qc.sx(q)
qc.rz(θ + π, q)
qc.sx(q)
qc.rz(ϕ + π, q)
end

"Kicked-Ising circuit on `chain`, then the rotations of one setting and a measurement."
function native_setting_circuit(chain, angles, num_device_qubits)
n = length(chain)
qc = QuantumCircuit(num_device_qubits, n)
for q in chain
native_u!(qc, q, π/4, -π/2, π/2) # e^{-iπ/8 X}
end
for i in 1:n-1
qc.cz(chain[i], chain[i + 1]) # e^{iπ/4 ZZ}, up to the S† gates below
end
for (i, q) in enumerate(chain)
bonds = (i > 1) + (i < n)
qc.rz(-π/2 * bonds, q) # one S† per bond
native_u!(qc, q, angles[i, 1], angles[i, 2], angles[i, 3])
qc.measure(q, i) # outcome of chain qubit i goes to bit i
end
qc
end

circuits = [native_setting_circuit(chain, angles[r, :, :], num_device_qubits) for r in 1:NU_hw]
println(length(circuits), " circuits, each with ", count(inst -> inst.name == "cz", circuits[1].data), " CZ gates")
1024 circuits, each with
95 CZ gates

Schritt 3: Mit Qiskit-Primitiven ausführen​

QiskitIBMRuntime.jl führt pro Sampler-Job einen Circuit aus, daher erfordert das Sammeln der Daten 1.024 Jobs. Die folgende Zelle hält bis zu 32 Jobs in der Warteschlange und speichert die Ergebnisse jeder Einstellung, sobald ihr Job abgeschlossen ist. Jeder Shot wird als Vektor von Bits zurückgegeben, in dem Element ii das Ergebnis von Ketten-Qubit ii ist.

Du musst die Ergebnisse in derselben Session abrufen, die die Jobs eingereicht hat, weil QiskitIBMRuntime.jl einen Job noch nicht anhand seiner ID nachschlagen kann (qiskit-ibm-runtime-c issue #28). Wenn ein Job fehlschlägt, gibt die Zelle eine Warnung aus und läuft weiter. Wenn die Session endet, führe die Schritte 1 bis 3 erneut aus. Wenn du die Zelle erneut ausführst, reicht sie nur die Einstellungen ein, deren Ergebnisse fehlen. Mit use_saved_data = true reicht die Zelle nichts ein.

outcome_file(r) = joinpath(run_directory, "outcomes", "setting_$(lpad(r, 4, '0')).npz")

"Save the outcomes of setting `r` as a (shots × N) matrix of 0/1 values."
function save_outcomes(r, job)
try
samples = get_sampler_job_results(job, service)
bits = UInt8.(permutedims(reduce(hcat, samples)))
npzwrite(outcome_file(r), Dict("bits" => bits))
catch err
@warn "Setting $r failed and was not saved; run this cell again to resubmit it" err
end
end

if use_saved_data
println("Using the saved ibm_fez measurements; no jobs submitted")
else
backend_name = "ibm_fez"
service = Service() # uses the credentials saved on this computer
backend = only(b for b in backend_search(service) if b.name == backend_name)
open(joinpath(run_directory, "metadata.json"), "w") do io
JSON.print(io, Dict("backend" => backend_name, "N" => N_hw, "depth" => 1, "settings" => NU_hw,
"shots" => NM_hw, "chain" => chain_physical), 2)
end
in_flight = []
for r in 1:NU_hw
isfile(outcome_file(r)) && continue
push!(in_flight, (r, run_sampler_job(service, backend, circuits[r], NM_hw)))
length(in_flight) >= 32 && save_outcomes(popfirst!(in_flight)...)
end
foreach(job -> save_outcomes(job...), in_flight)
println("Saved outcomes: ", count(r -> isfile(outcome_file(r)), 1:NU_hw), " of ", NU_hw, " settings")
end
Using the saved ibm_fez measurements; no jobs submitted

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

Dieser Schritt liest nur gespeicherte Daten: den heruntergeladenen Lauf auf ibm_fez, wenn use_saved_data wahr ist, oder andernfalls die Dateien, die Schritt 3 geschrieben hat. Du kannst ihn daher in einer neuen Session ausführen, ohne Jobs einzureichen (führe zuerst die Setup-Zelle, die Zelle use_saved_data und Schritt 1 aus). Die heruntergeladene Datei speichert die 96 Ergebnisse jedes Shots in 12 Bytes gepackt, mit dem höchstwertigen Bit zuerst, daher entpackt der Loader sie. RandomMeas.jl bezeichnet die Ergebnisse mit 1 und 2, daher addiert der Loader außerdem 1 zu jedem Bit.

"Build a `MeasurementGroup` from the angles and a function `outcomes(r)` that returns
the (shots × N) 0/1 outcomes of setting `r`."
function measurement_group(angles, outcomes)
settings_count, n = size(angles, 1), size(angles, 2)
sites = siteinds("Qubit", n)
data = map(1:settings_count) do r
rotations = Array{ComplexF64}(undef, n, 2, 2)
for i in 1:n
rotations[i, :, :] = u3_matrix(angles[r, i, :]...)
end
MeasurementData(Int.(outcomes(r)) .+ 1;
measurement_setting=LocalUnitaryMeasurementSetting(rotations; site_indices=sites))
end
MeasurementGroup(data)
end

if use_saved_data
packed = saved_run["outcomes"] # settings × shots × 12 bytes
# Bit i of a shot is in byte (i - 1) ÷ 8 + 1, most significant bit first
unpack(r) = [(packed[r, s, (i - 1) ÷ 8 + 1] >> (7 - (i - 1) % 8)) & 0x01
for s in 1:size(packed, 2), i in 1:N_hw]
group_hw = measurement_group(angles, unpack)
else
group_hw = measurement_group(angles, r -> npzread(outcome_file(r))["bits"])
end
println(group_hw.NU, " settings × ", group_hw.NM, " shots on ", group_hw.N, " qubits")
1024 settings ×
1024 shots on 96 qubits

Prüfe die Daten vor dem Lernen. Ein defektes Qubit oder ein schlecht kalibriertes Gate macht den gemessenen Zustand in seiner Umgebung deutlich gemischter und kann dazu führen, dass der Lernalgorithmus divergiert. Die Reinheit einiger benachbarter Qubits ist ein modellfreier Benchmark für dieses Rauschen: Die Funktion get_purity aus RandomMeas.jl schätzt tr ρA2\mathrm{tr}\,\rho_A^2 für ein Teilsystem AA, indem sie Paare von Shots derselben Einstellung vergleicht. Berechne die Rényi-2-Entropie S2=−log⁡2tr ρA2S_2=-\log_2\mathrm{tr}\,\rho_A^2 jedes Fensters aus sechs benachbarten Qubits und vergleiche sie mit demselben Fenster des idealen Zustands. Der ideale Wert ist nicht null, weil jedes Fenster mit dem Rest der Kette verschränkt ist; Rauschen erhöht ihn, und ein defektes Qubit treibt jedes Fenster, das es enthält, zum Maximum von sechs.

ideal_hw = kicked_ising_reference(N_hw, 1)
width = 6
starts = 1:N_hw - width + 1
window_entropy(rho, w) = -log2(mpo_overlap(segment_mpo(rho, w), segment_mpo(rho, w)))
measured_entropy = [-log2(get_purity(group_hw, collect(j:j + width - 1))) for j in starts]
ideal_entropy = [window_entropy(ideal_hw, j:j + width - 1) for j in starts]
worst = argmax(measured_entropy)
println("S₂ of six-qubit windows: median ", round(median(measured_entropy), digits=2), "; highest ",
round(measured_entropy[worst], digits=2), " (chain positions ", worst, " to ", worst + width - 1, ")")
println("Ideal state: ", round(minimum(ideal_entropy), digits=2), " to ", round(maximum(ideal_entropy), digits=2))
plot(starts, measured_entropy; marker=:circle, markersize=2, label="measured",
xlabel="first chain position of the window", ylabel="S₂ of six qubits", ylims=(0, width),
legend=:topright, size=(800, 280), left_margin=5Plots.mm, bottom_margin=5Plots.mm)
plot!(starts, ideal_entropy; linestyle=:dash, label="ideal state")
S₂ of six-qubit windows: median 0.9
; highest 1.43 (chain positions 30 to 35)
Ideal state: 0.19 to 0.39

Output of the previous code cell

Jedes Fenster ist stärker gemischt als der ideale Zustand, um etwa ein halbes bis ein Bit, und der verrauschteste Abschnitt liegt um die Kettenpositionen 30 bis 35. Kein Fenster kommt dem Maximum von sechs nahe, daher ist kein Qubit defekt, und die Analyse verwendet die gesamte 96-Qubit-Kette. Hätten einige Fenster eine Entropie nahe sechs, würdest du das Qubit entfernen, das diese Fenster gemeinsam haben, und den längsten Teil der Kette ohne es lernen.

Dieselben Reinheiten bestimmen den CRM-Prior. Für jedes Fenster nimmt fitted_prior den idealen Zustand und passt eine lokale Depolarisationsstärke so an, dass seine Reinheit wie in der Veröffentlichung der in den Trainingseinstellungen gemessenen Reinheit entspricht.

Die Funktion learn_and_validate in der folgenden Zelle führt den Rest der Analyse durch. Sie lernt das Modell aus den Trainingseinstellungen und schätzt dann Fmax⁡\mathcal{F}_{\max} und S2S_2 auf den Testeinstellungen für die ersten NN Qubits der Kette, in Schritten von 12. Das sind die Größen in Abbildung 1(c,d) der Veröffentlichung. Der ideale Zustand wird als Baseline auf denselben Testdaten ausgewertet.

Die Zelle führt die Funktion mit ℓ=2\ell=2 aus und wiederholt sie dann mit ℓ=1\ell=1 und ℓ=0\ell=0, um zu sehen, wie stark die Größe der Lernfenster ins Gewicht fällt. Die Bonddimension kann höchstens 4ℓ4^\ell betragen, daher lernt ℓ=0\ell=0 einen Produktzustand: jedes Qubit für sich, ohne Korrelationen zwischen den Qubits.

function learn_and_validate(group; ideal, ell=2, k=3, sizes=12:12:group.N, seed=20260921, train_fraction=0.5)
split = split_settings(group; seed, train_fraction)
prior = fitted_prior(ideal, split.train)
marginals = training_marginals(split.train; ell, prior)
fit = learn_mpo(marginals, group.N; ell, maxbond=min(4, 4^ell), sweeps=20)
last(fit.history).purity <= 1 ||
@warn "The model has purity above one, so the fit diverged. Collect more settings or shots."
statistics = afc_statistics(split.test, k; prior)
learned = afc_prefix_curve(fit.model, statistics, split.test.NU; k, sizes)
baseline = afc_prefix_curve(ideal, statistics, split.test.NU; k, sizes)
model_entropy = [-log2(mpo_overlap(prefix_mpo(fit.model, n), prefix_mpo(fit.model, n))) for n in sizes]
(; ell, fit, split, learned, baseline, model_entropy)
end

function plot_validation(results, title)
n = [r.n for r in first(results).learned]
# Marker, size, and line style per ℓ. The ℓ = 1 squares are small enough to sit inside the
# ℓ = 2 circles, so both stay visible where the two curves overlap.
style = Dict(2 => (:circle, 7, :solid), 1 => (:rect, 3.5, :dash), 0 => (:utriangle, 5, :dot))
fidelity = plot(yscale=:log10, ylims=(1e-6, 1.5), legend=:bottomleft, xlabel="number of qubits N",
ylabel="held-out F_max", title=title)
entropy = plot(xlabel="number of qubits N", ylabel="Rényi-2 entropy S₂", legend=:topleft)
held_out = first(results).learned
# Draw every error bar before any marker, so the bars stay behind the symbols
for (color, result) in enumerate(results)
scatter!(fidelity, n, [r.fidelity for r in result.learned]; yerror=[r.fidelity_sem for r in result.learned],
markersize=0, markerstrokecolor=color, label="")
end
scatter!(entropy, n, [r.entropy for r in held_out]; yerror=[r.entropy_sem for r in held_out],
markersize=0, markerstrokecolor=:black, label="")
for (color, result) in enumerate(results)
marker, markersize, linestyle = style[result.ell]
label = "learned model, ℓ = $(result.ell)"
plot!(fidelity, n, [r.fidelity for r in result.learned]; color, marker, markersize, linestyle,
markerstrokewidth=0, label)
plot!(entropy, n, result.model_entropy; color, linestyle, linewidth=2, label)
end
plot!(fidelity, n, [r.fidelity for r in first(results).baseline]; marker=:diamond, markersize=5,
linestyle=:dashdot, color=:black, label="ideal state")
scatter!(entropy, n, [r.entropy for r in held_out]; marker=:circle, markersize=4, color=:black,
label="held-out AFC estimate")
plot(fidelity, entropy; layout=(1, 2), size=(1000, 400), left_margin=7Plots.mm, bottom_margin=7Plots.mm)
end

function summarize(result)
final = last(result.learned)
println("ℓ = ", result.ell, ", N = ", final.n, ": held-out F_max = ", round(final.fidelity, sigdigits=3), " ± ",
round(final.fidelity_sem, sigdigits=2), " (ideal state: ", round(last(result.baseline).fidelity, sigdigits=2), ")")
println(" S₂ = ", round(final.entropy, digits=2), " ± ", round(final.entropy_sem, digits=2),
" held out; ", round(last(result.model_entropy), digits=2), " from the model")
lowest = minimum(minimum(eigvals(Hermitian(operator_from_coefficients(local_coefficients(result.fit.model, w)))))
for w in unique(learning_windows(final.n, max(result.ell, 1))))
println(" Most negative eigenvalue in any learning window: ", round(lowest, digits=4))
end

results_hw = [learn_and_validate(group_hw; ideal=ideal_hw, ell) for ell in (2, 1, 0)]
foreach(summarize, results_hw)
plot_validation(results_hw, "ibm_fez, 96-qubit chain")
ℓ = 2
, N = 96: held-out F_max = 0.591 ± 0.1 (ideal state: 0.0035)
S₂ = 10.04 ± 0.28 held out; 10.21 from the model
Most negative eigenvalue in any learning window: -0.0523
ℓ = 1, N = 96: held-out F_max = 0.554 ± 0.094 (ideal state: 0.0035)
S₂ = 10.04 ± 0.28 held out; 10.26 from the model
Most negative eigenvalue in any learning window: -0.0215
ℓ = 0, N = 96: held-out F_max = 6.18e-6 ± 1.1e-6 (ideal state: 0.0035)
S₂ = 10.04 ± 0.28 held out; 32.01 from the model
Most negative eigenvalue in any learning window: 0.0012

Output of the previous code cell

Die Ergebnisse reproduzieren beide Aussagen der Veröffentlichung auf einem anderen Prozessor:

  • Das Modell beschreibt die Daten weit besser als der ideale Zustand. Bei N=96N=96 beträgt das zurückgehaltene Fmax⁡\mathcal{F}_{\max} des ℓ=2\ell=2-Modells 0,59 ± 0,10, verglichen mit 0,0035 für den idealen Zustand. Die Veröffentlichung berichtet etwa 0,75 auf ibm_brisbane.

  • Die Entropie des Modells stimmt bei jedem NN mit den Testdaten überein. Bei N=96N=96 beträgt sie 10,2 vom Modell und 10,0 ± 0,3 aus den Testdaten, also S2/N≈0.10S_2/N\approx 0.10, verglichen mit 0,14 bis 0,15 auf dem älteren ibm_brisbane.

Der Vergleich der Fenstergrößen zeigt, wo die Information steckt. Mit ℓ=1\ell=1 ist das Modell fast ebenso gut (Fmax⁡=0.55±0.09\mathcal{F}_{\max}=0.55\pm0.09), daher tragen Korrelationen jenseits weniger Qubits bei diesen Daten wenig bei. Mit ℓ=0\ell=0 verfehlt der Produktzustand die Verschränkung zwischen benachbarten Qubits: Seine Entropie wächst auf 32 statt 10, und sein Fmax⁡\mathcal{F}_{\max} fällt noch schneller als das des idealen Zustands, auf 6×10−66\times10^{-6} bei N=96N=96.

Beachte beim Lesen dieser Zahlen die folgenden Einschränkungen:

  • Trainingsaufteilung. Die Fehlerbalken decken nur den statistischen Fehler der Testdaten ab. Andere zufällige Aufteilungen derselben Einstellungen ergeben Fmax⁡\mathcal{F}_{\max} zwischen 0,49 und 0,59 bei N=96N=96 für ℓ=2\ell=2.

  • Letzter Durchlauf. Der Lernalgorithmus gibt immer das Modell aus dem letzten Durchlauf zurück, daher beeinflussen die Testdaten das Modell nie.

  • Positivität. Das Modell ist nicht auf positiv semidefinit beschränkt; sein negativster Eigenwert in einem Lernfenster beträgt etwa −0.05-0.05. Sein Fmax⁡\mathcal{F}_{\max} und S2S_2 beschreiben daher einen Operator, keine zertifizierten Eigenschaften eines physikalischen Zustands.

  • Faktorisierung. Jede zurückgehaltene Schätzung beruht auf der AFC-Annahme, die die Messungen selbst nicht zertifizieren können.

Nächste Schritte​

Empfehlungen
  • Wiederhole das Experiment bei Tiefe zwei mit den Parametern der Veröffentlichung für diese Tiefe (ℓ=3\ell=3 und eine maximale Bonddimension von 8) und bestimme, wie viele Messeinstellungen der Lernalgorithmus benötigt.

  • Lerne stattdessen mit dem Zwei-Site-Update (update=:two_site in training_marginals und learn_mpo), das die Bonddimension nach jedem Schritt abschneidet, und sieh dir an, wie es sich mit weniger Trainingseinstellungen verhält.

  • Lerne ohne den CRM-Prior (prior=nothing) und vergleiche die zurückgehaltene Fidelity.

  • Wende dieselbe Analyse auf die veröffentlichten ibm_brisbane-Messungen der Autoren an.

  • Lies das Supplement der Veröffentlichung für die Herleitung des Updates und der AFC-Schätzer.

  • Erkunde andere Protokolle für randomisierte Messungen in den RandomMeas.jl-Beispielen.

Referenzen​

  1. M. Votto, M. Ljubotina, C. Lancien, J. I. Cirac, P. Zoller, M. Serbyn, L. Piroli, and B. Vermersch, "Learning mixed quantum states in large-scale experiments", Phys. Rev. Lett. 136, 090801 (2026). arXiv:2507.12550

  2. A. Elben, S. T. Flammia, H.-Y. Huang, R. Kueng, J. Preskill, B. Vermersch, and P. Zoller, "The randomized measurement toolbox", Nat. Rev. Phys. 5, 9 (2023). arXiv:2203.11374

  3. H.-Y. Huang, R. Kueng, and J. Preskill, "Predicting many properties of a quantum system from very few measurements", Nat. Phys. 16, 1050 (2020). arXiv:2002.08953

  4. A. Elben and B. Vermersch, "RandomMeas.jl: A Julia package for randomized measurements in quantum devices", Quantum 10, 2086 (2026). arXiv:2509.12749

  5. B. Vermersch, A. Rath, B. Sundar, C. Branciard, J. Preskill, and A. Elben, "Enhanced estimation of quantum properties with common randomized measurements", PRX Quantum 5, 010352 (2024). arXiv:2304.12292

  6. H. Zou, "Randomized measurements of a 96-qubit kicked-Ising state on ibm_fez", Zenodo (2026). doi:10.5281/zenodo.24116174