Saltar al contenido principal
Este proyecto está en fase beta. ¿Encontraste un error? Abre un issue en GitHub. ¿Tienes una pregunta o una idea? Pregunta en Discussions — ¡nos encantaría tu opinión!
¿Cómo es la calidad de la traducción en esta página?

Aprende estados cuánticos ruidosos con sombras clásicas

Estimación de uso: 34 minutos en un procesador Heron r2 (NOTA: Esto es solo una estimación. Tu tiempo de ejecución puede variar.)

Resultados de aprendizaje​

  • Recopilar mediciones aleatorizadas en un procesador cuántico de IBM® desde Julia y guardarlas para su análisis posterior

  • Comprobar en los datos de medición si hay qubits y puertas defectuosos antes de aprender

  • Ajustar un modelo de operador de producto de matrices (MPO) de un estado ruidoso a partir de sombras clásicas

  • Validar el modelo con mediciones reservadas y compararlo con el circuito ideal

Requisitos previos​

Contexto​

En un procesador cuántico real, el ruido convierte el estado puro ∣ψ⟩|\psi\rangle que un circuito está diseñado para preparar en un estado mixto ρ\rho. La tomografía completa del estado cuántico puede reconstruir ρ\rho, pero el número de mediciones que necesita crece exponencialmente con el número de qubits. En cambio, Votto et al. [1] aprendieron un modelo compacto de ρ\rho para hasta 96 qubits a partir de mediciones aleatorizadas. Este tutorial sigue su flujo de trabajo.

En una medición aleatorizada [2], cada qubit ii se rota con un unitario aleatorio independiente uiu_i y luego se mide en la base computacional. Una realización de las rotaciones se denomina configuración de medición, y cada configuración se repite durante NMN_M shots. Un shot con bits de resultado sis_i da la sombra clásica [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),

cuyo promedio sobre configuraciones y shots es ρ\rho. El tutorial de requisitos previos toma cada uiu_i de las tres bases de Pauli; este tutorial, como el artículo, los toma uniformemente de todos los unitarios de un solo qubit (aleatorios según Haar), y se aplica la misma fórmula.

Las sombras estiman propiedades de unos pocos qubits a la vez. El artículo las combina en un operador de producto de matrices (MPO), que escribe la matriz de densidad como una cadena de tensores pequeños, uno por qubit; los estados ruidosos con correlaciones de corto alcance solo necesitan enlaces pequeños entre tensores vecinos. Al igual que el algoritmo del grupo de renormalización de la matriz de densidad (DMRG), el aprendiz recorre la cadena y actualiza un tensor cada vez, de modo que el modelo coincida con las sombras en la ventana de 2ℓ+12\ell+1 qubits centrada en ese tensor (ecuación 4 del artículo). La dimensión del enlace permanece fija durante estas actualizaciones, por lo que el aprendiz nunca trunca el modelo. Como los datos entran solo a través de estas ventanas, el número de configuraciones necesarias no crece con la longitud de la cadena.

Las configuraciones se dividen en un conjunto de entrenamiento y un conjunto de prueba. En el conjunto de prueba, el artículo estima la fidelidad máxima entre ρ\rho y el modelo σ\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)}.

Medir tr(ρσ)\mathrm{tr}(\rho\sigma) directamente requeriría un número exponencial de mediciones. En su lugar, el artículo supone la condición de factorización aproximada (AFC): las correlaciones en ρ\rho decaen dentro de unos pocos qubits, de modo que los solapamientos y purezas globales se factorizan en términos sobre bloques de kk qubits vecinos. La pureza también da la entropía de Rényi-2 S2=−log⁡2tr ρ2S_2=-\log_2\mathrm{tr}\,\rho^2, que mide cuán mixto es el estado.

El artículo prepara el estado de Ising pateado de profundidad DD

∣ψ⟩=(∏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}

en 96 qubits de ibm_brisbane, un procesador Eagle, con 2048 configuraciones de 1024 shots para D=1D=1. La figura 1(c,d) del artículo presenta dos resultados para D=1D=1:

  • El modelo aprendido alcanza Fmax⁡≈75%\mathcal{F}_{\max}\approx 75\% con el estado experimental en N=96N=96, muy por encima del solapamiento del estado ideal ∣ψ⟩|\psi\rangle con el experimento.

  • La entropía crece linealmente, S2≈(0.14 a 0.15) NS_2\approx(0.14\text{ a }0.15)\,N, y la entropía del modelo concuerda con una estimación independiente a partir del conjunto de prueba.

Este tutorial comprueba ambos resultados, primero en una simulación de ocho qubits donde se conocen las respuestas exactas, y luego en una nueva ejecución de 96 qubits en ibm_fez, un procesador Heron r2. El aprendiz es una implementación independiente en Julia de las ecuaciones del artículo y de su suplemento.

Requisitos​

Este tutorial requiere macOS o Linux, porque Qiskit.jl todavía no es compatible con Windows (incidencia #15 de Qiskit.jl). También necesitas lo siguiente:

  • Julia 1.11, desde la página de descarga de Julia o con juliaup add 1.11, y el paquete IJulia:

    julia -e 'using Pkg; Pkg.add("IJulia")'
  • Para el ejemplo con hardware, una cuenta de IBM Quantum® Platform con acceso a una QPU que tenga al menos 96 qubits, y credenciales guardadas. Sin una cuenta, puedes ejecutar el ejemplo con hardware a partir de las mediciones guardadas de la ejecución en ibm_fez que produjo los resultados de este tutorial. Las demás secciones se ejecutan sin una cuenta.

El notebook usa Qiskit.jl y QiskitIBMRuntime.jl para construir y ejecutar circuitos, RandomMeas.jl [4] para las mediciones aleatorizadas (que también proporciona ITensors.jl y ITensorMPS.jl), y NPZ.jl, JSON.jl y Plots.jl. Este tutorial se ha probado con Qiskit.jl 0.6.1, QiskitIBMRuntime.jl 0.3.2 y RandomMeas.jl 0.3.1.

Hay dos formas de configurar el entorno:

  • Opción 1: instala las últimas versiones compatibles de los paquetes en un entorno temporal. Ejecuta la siguiente celda sin cambios.

  • Opción 2: reproduce exactamente el entorno probado. Establece download_toml_files = true en la siguiente celda. La celda descarga Project.toml y Manifest.toml del repositorio de documentación en una carpeta env_tutorial/classical-shadows/ junto a este notebook, y luego instala la versión exacta de cada paquete que registra el manifiesto, incluidas las dependencias indirectas. Para más detalles, consulta la documentación de Julia sobre estos archivos.

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

Configuración​

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

El módulo auxiliar mpo_learning.jl, que descarga la celda de configuración, implementa el aprendiz. El tutorial llama a las siguientes funciones de él:

FunciónPropósito
kicked_ising_reference(N, D; depolarization)MPO exacto del estado de Ising pateado ideal, o del estado tras ruido despolarizante local
split_settings(group; seed, train_fraction)Asigna aleatoriamente las configuraciones de medición a los conjuntos de entrenamiento y de prueba (la mitad cada uno por defecto)
training_marginals(train; ell, prior)Estimaciones por sombras de cada ventana de aprendizaje, solo a partir de las configuraciones de entrenamiento
fitted_prior(ideal, train)Prior para las mediciones aleatorizadas comunes (CRM), ajustado a la pureza medida de cada ventana, como en el artículo
learn_mpo(marginals, N; ell, maxbond, sweeps)Recorre la actualización de un solo sitio del artículo a lo largo de la cadena, partiendo del estado máximamente mixto
max_fidelity(a, b), mpo_overlap(a, b)Fmax⁡\mathcal{F}_{\max} exacta y tr(ab)\mathrm{tr}(ab) entre dos MPO
afc_estimate, afc_statistics, afc_prefix_curveEstimaciones AFC de Fmax⁡\mathcal{F}_{\max} y S2S_2 a partir de las configuraciones de prueba, con barras de error jackknife

El aprendiz almacena el MPO en la base de Pauli. Esto mantiene el modelo hermítico y con traza unitaria, pero no obliga a que sea semidefinido positivo, por lo que el notebook informa de cuán negativos se vuelven sus autovalores.

Ejemplo a pequeña escala con simulador​

Empieza con un sistema lo bastante pequeño como para calcular todo de forma exacta: el estado de Ising pateado de profundidad uno en ocho qubits, con un 12 % de ruido despolarizante local para modelar el hardware. Como se conoce el estado ruidoso, puedes comparar directamente el modelo aprendido con él.

Paso 1: Convertir las entradas clásicas en un problema cuántico​

La función kicked_ising_reference devuelve el estado exacto como un MPO. Con depolarization=0.12, el vector de Bloch de cada qubit se reduce un 12 % tras el circuito.

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

Paso 2: Optimizar el problema para la ejecución en hardware cuántico​

Este ejemplo muestrea los resultados de medición de forma clásica, así que no hay ningún circuito que transpilar. El ejemplo con hardware cubre este paso.

Paso 3: Ejecutar con las primitivas de Qiskit​

Usa RandomMeas.jl para generar 2048 configuraciones de medición aleatorias según Haar y muestrear 256 shots de cada una, y luego divide las configuraciones a partes iguales en conjuntos de entrenamiento y de prueba. Divide por configuración y no por shot: los shots de una misma configuración comparten sus rotaciones, por lo que no son independientes.

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

Paso 4: Posprocesar y devolver el resultado en el formato clásico deseado​

Aprende el modelo con los parámetros de profundidad uno del artículo: ventanas que se extienden ℓ=2\ell=2 qubits a cada lado del tensor actualizado, una dimensión de enlace de 4 y 20 barridos partiendo del estado máximamente mixto. El primer barrido actualiza pares de tensores vecinos, lo que permite que la dimensión del enlace crezca de 1 a 4; cada barrido posterior actualiza un tensor cada vez con esa dimensión de enlace fija.

Para reducir el ruido estadístico de las sombras, el artículo usa mediciones aleatorizadas comunes (CRM) [5]. Para cada configuración, resta la sombra promedio que produciría una suposición previa del estado en la misma configuración, y luego suma de nuevo el valor exacto del prior. La corrección tiene promedio cero, por lo que el prior cambia el tamaño del error estadístico pero no lo que se estima. Aquí el prior es el estado ideal con un 10 % de despolarización local, cercano al 12 % real. En hardware el nivel de ruido es desconocido, así que el ejemplo con hardware ajusta el prior a purezas medidas, como hace el artículo.

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

El residuo mide cuánto se alejan las ventanas del modelo de las sombras de entrenamiento. Baja cuando comienzan las actualizaciones de un solo sitio, en el segundo barrido, y luego permanece aproximadamente constante en lugar de llegar a cero, porque las sombras contienen ruido estadístico que un modelo con una dimensión de enlace pequeña no puede reproducir.

Como este estado es conocido, puedes comparar exactamente el modelo aprendido con él, y también comparar con él las dos suposiciones más simples: el prior CRM y el estado ideal.

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

El modelo aprendido está más cerca del estado ruidoso que el prior o el estado ideal, así que ha aprendido el ruido a partir de los datos. Sus pequeños autovalores negativos provienen del número finito de mediciones.

En hardware el estado es desconocido, así que en su lugar estimas Fmax⁡\mathcal{F}_{\max} a partir de las configuraciones de prueba. AFC divide la cadena en bloques A1,…,ARA_1,\dots,A_R de kk qubits y aproxima la pureza mediante

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},

y tr(ρσ)\mathrm{tr}(\rho\sigma) por la misma razón de solapamientos locales. Con k=4k=4, los dos bloques cubren los ocho qubits y la fórmula es exacta; con k=2k=2, se basa en el supuesto de factorización. Las barras de error jackknife, que dejan fuera un ajuste de prueba cada vez, cubren únicamente el error estadístico de los datos de prueba, no la aleatoriedad del entrenamiento ni la aproximación AFC.

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

Ambas estimaciones reservadas concuerdan con el valor exacto dentro de sus barras de error.

Ejemplo de hardware a gran escala​

Ahora ejecuta el experimento en una cadena de 96 qubits de ibm_fez, un procesador Heron r2. Al igual que ibm_brisbane, tiene un mapa de acoplamiento heavy-hex y un nivel de ruido similar.

Recopilar los datos requiere 1,024 trabajos de Sampler y unos 34 minutos de tiempo de QPU. Si no tienes acceso a una QPU con al menos 96 qubits, o la cola es larga, ejecuta el ejemplo de hardware a partir de las mediciones registradas en ibm_fez el 27 de septiembre de 2026, que produjeron los resultados mostrados en este tutorial. Con use_saved_data = true, el notebook descarga estas mediciones (15 MB) desde Zenodo [6] en el Paso 1 y omite el envío de trabajos en el Paso 3. Para recopilar tus propios datos, establécelo en false.

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

Paso 1: Asignar entradas clásicas a un problema cuántico​

Cada ajuste necesita un circuito: el circuito kicked-Ising, una puerta U(θ,ϕ,λ)U(\theta,\phi,\lambda) en cada qubit para uiu_i y una medición de cada qubit. Muestrear θ=2arcsin⁡v\theta=2\arcsin\sqrt{v}, con vv, ϕ/2π\phi/2\pi y λ/2π\lambda/2\pi uniformes en [0,1)[0,1), hace que UU sea aleatoria de Haar. La función u3_matrix devuelve la matriz de UU, que el Paso 4 utiliza.

El presupuesto es de 1,024 ajustes de 1,024 shots, la mitad del número de ajustes del artículo, repartidos a partes iguales entre entrenamiento y prueba. Con datos guardados, la celda carga los ángulos registrados. En caso contrario, genera ángulos nuevos y los guarda antes de que envíes nada, porque no puedes analizar los resultados sin ellos. Si el archivo ya existe, la celda lo carga, de modo que los ángulos sigan coincidiendo con los resultados guardados después de reiniciar la sesión.

"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

Paso 2: Optimizar el problema para su ejecución en hardware cuántico​

Una cadena es tan buena como su peor qubit, así que elige tú mismo los 96 qubits físicos. La función transpile de Qiskit.jl todavía no puede aceptar un layout inicial fijo, y en una prueba en ibm_phoenix, el layout que eligió incluía un qubit con un 51% de error de lectura. La siguiente cadena es el camino de 96 qubits en el mapa de acoplamiento de ibm_fez que el layout con detección de errores de la función transpile de Qiskit para Python (con optimization_level=3) seleccionó a partir de los datos de calibración del 27 de septiembre de 2026. Su error de lectura medio es del 1.6%, pero una red heavy-hex tiene pocos caminos de 96 qubits, y este incluye el qubit 35, que tiene un 15% de error de lectura. Las calibraciones cambian, así que elige una cadena nueva a partir de los datos de calibración actuales antes de ejecutar otro día o en otra QPU.

Para conservar esta cadena, escribe los circuitos directamente en puertas nativas en lugar de transpilarlos. Una puerta U(θ,ϕ,λ)U(\theta,\phi,\lambda) es igual a RZ(ϕ+π) X RZ(θ+π) X RZ(λ)R_Z(\phi+\pi)\,\sqrt{X}\,R_Z(\theta+\pi)\,\sqrt{X}\,R_Z(\lambda) salvo por una fase global. Esta descomposición cubre tanto las rotaciones aleatorias como el kick e−iπ8X=U(π/4,−π/2,π/2)e^{-i\frac{\pi}{8}X}=U(\pi/4,-\pi/2,\pi/2). La puerta eiπ4ZjZj+1e^{i\frac{\pi}{4}Z_jZ_{j+1}} es igual a una puerta CZ seguida de S†S^\dagger en ambos qubits, salvo por una fase global. Como estas puertas S†S^\dagger son diagonales, conmutan con las puertas CZ, de modo que cada qubit acumula un RZ(−π/2)R_Z(-\pi/2) por enlace antes de su rotación de medición.

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

Paso 3: Ejecutar usando primitivas de Qiskit​

QiskitIBMRuntime.jl ejecuta un circuito por trabajo de Sampler, por lo que recopilar los datos requiere 1,024 trabajos. La siguiente celda mantiene hasta 32 trabajos en la cola y guarda los resultados de cada ajuste en cuanto termina su trabajo. Cada shot se devuelve como un vector de bits, en el que el elemento ii es el resultado del qubit ii de la cadena.

Debes recuperar los resultados en la misma sesión que envió los trabajos, porque QiskitIBMRuntime.jl todavía no puede buscar un trabajo por su ID (qiskit-ibm-runtime-c issue #28). Si un trabajo falla, la celda emite una advertencia y continúa. Si la sesión se detiene, ejecuta de nuevo los Pasos 1 a 3. Al volver a ejecutar la celda, solo se envían los ajustes cuyos resultados faltan. Con use_saved_data = true, la celda no envía nada.

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

Paso 4: Posprocesar y devolver el resultado en el formato clásico deseado​

Este paso lee únicamente datos guardados: la ejecución descargada de ibm_fez si use_saved_data es true, o, en caso contrario, los archivos que escribió el Paso 3. Por lo tanto, puedes ejecutarlo en una sesión nueva sin enviar trabajos (ejecuta primero la celda de Setup, la celda use_saved_data y el Paso 1). El archivo descargado almacena los 96 resultados de cada shot empaquetados en 12 bytes, con el bit más significativo primero, por lo que el cargador los desempaqueta. RandomMeas.jl etiqueta los resultados como 1 y 2, así que el cargador también suma 1 a cada 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

Antes de aprender, comprueba los datos. Un qubit defectuoso o una puerta mal calibrada hacen que el estado medido esté mucho más mezclado a su alrededor, y pueden hacer que el aprendiz diverja. La pureza de unos pocos qubits vecinos es una referencia, independiente de modelos, de este ruido: la función get_purity de RandomMeas.jl estima tr ρA2\mathrm{tr}\,\rho_A^2 para un subsistema AA comparando pares de shots del mismo ajuste. Calcula la entropía de Rényi-2 S2=−log⁡2tr ρA2S_2=-\log_2\mathrm{tr}\,\rho_A^2 de cada ventana de seis qubits vecinos y compárala con la misma ventana del estado ideal. El valor ideal no es cero, porque cada ventana está entrelazada con el resto de la cadena; el ruido lo aumenta, y un qubit defectuoso empuja hacia el máximo de seis a cada ventana que lo contiene.

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

Todas las ventanas están más mezcladas que el estado ideal, en aproximadamente medio bit a un bit, y el tramo más ruidoso está alrededor de las posiciones 30 a 35 de la cadena. Ninguna ventana se acerca al máximo de seis, así que ningún qubit está defectuoso, y el análisis usa toda la cadena de 96 qubits. Si algunas ventanas tuvieran una entropía cercana a seis, eliminarías el qubit que esas ventanas comparten y aprenderías la parte más larga de la cadena sin él.

Las mismas purezas determinan el prior CRM. Para cada ventana, fitted_prior toma el estado ideal y ajusta una intensidad de despolarización local de modo que su pureza coincida con la pureza medida en los ajustes de entrenamiento, como en el artículo.

La función learn_and_validate de la siguiente celda realiza el resto del análisis. Aprende el modelo a partir de los ajustes de entrenamiento y luego estima Fmax⁡\mathcal{F}_{\max} y S2S_2 en los ajustes de prueba para los primeros NN qubits de la cadena, en pasos de 12. Estas son las cantidades de la Figura 1(c,d) del artículo. El estado ideal se evalúa sobre los mismos datos de prueba como referencia.

La celda ejecuta la función con ℓ=2\ell=2 y luego la repite con ℓ=1\ell=1 y ℓ=0\ell=0 para ver cuánto importa el tamaño de las ventanas de aprendizaje. La dimensión de enlace puede ser como máximo 4ℓ4^\ell, por lo que ℓ=0\ell=0 aprende un estado producto: cada qubit por separado, sin correlaciones entre 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

Los resultados reproducen las dos afirmaciones del artículo en un procesador diferente:

  • El modelo describe los datos mucho mejor que el estado ideal. Con N=96N=96, el Fmax⁡\mathcal{F}_{\max} reservado del modelo con ℓ=2\ell=2 es 0.59 ± 0.10, frente a 0.0035 del estado ideal. El artículo informa de aproximadamente 0.75 en ibm_brisbane.

  • La entropía del modelo concuerda con los datos de prueba para cada NN. Con N=96N=96, es 10.2 según el modelo y 10.0 ± 0.3 según los datos de prueba, es decir, S2/N≈0.10S_2/N\approx 0.10, frente a 0.14 a 0.15 en el más antiguo ibm_brisbane.

La comparación de tamaños de ventana muestra dónde está la información. Con ℓ=1\ell=1, el modelo es casi igual de bueno (Fmax⁡=0.55±0.09\mathcal{F}_{\max}=0.55\pm0.09), así que para estos datos, las correlaciones más allá de unos pocos qubits aportan poco. Con ℓ=0\ell=0, el estado producto no capta el entrelazamiento entre qubits vecinos: su entropía crece hasta 32 en lugar de 10, y su Fmax⁡\mathcal{F}_{\max} cae incluso más rápido que el del estado ideal, hasta 6×10−66\times10^{-6} con N=96N=96.

Ten en cuenta las siguientes limitaciones al leer estos números:

  • División de entrenamiento. Las barras de error cubren únicamente el error estadístico de los datos de prueba. Otras divisiones aleatorias de los mismos ajustes dan un Fmax⁡\mathcal{F}_{\max} entre 0.49 y 0.59 con N=96N=96 para ℓ=2\ell=2.

  • Barrido final. El aprendiz siempre devuelve el modelo del barrido final, de modo que los datos de prueba nunca influyen en el modelo.

  • Positividad. El modelo no está restringido a ser semidefinido positivo; su autovalor más negativo en una ventana de aprendizaje es de aproximadamente −0.05-0.05. Por lo tanto, su Fmax⁡\mathcal{F}_{\max} y su S2S_2 describen un operador, no propiedades certificadas de un estado físico.

  • Factorización. Cada estimación reservada se basa en el supuesto AFC, que las propias mediciones no pueden certificar.

Próximos pasos​

Recomendaciones
  • Repite el experimento con profundidad dos usando los parámetros del artículo para esa profundidad (ℓ=3\ell=3 y una dimensión de enlace máxima de 8), y determina cuántos ajustes de medición necesita el aprendiz.

  • Aprende con la actualización de dos sitios en su lugar (update=:two_site en training_marginals y learn_mpo), que trunca la dimensión de enlace después de cada paso, y observa cómo se comporta con menos ajustes de entrenamiento.

  • Aprende sin el prior CRM (prior=nothing) y compara la fidelidad reservada.

  • Aplica el mismo análisis a las mediciones de ibm_brisbane publicadas por los autores.

  • Lee el suplemento del artículo para ver la derivación de la actualización y de los estimadores AFC.

  • Explora otros protocolos de medición aleatorizada en los ejemplos de RandomMeas.jl.

Referencias​

  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