Lumaktaw sa pangunahing nilalaman
Ang proyektong ito ay nasa beta. Nakakita ng bug? Mag-bukas ng GitHub issue. May tanong o ideya? Magtanong sa Discussions — gusto naming marinig ang iyong feedback!
Gaano kaganda ang kalidad ng pagsasalin sa pahinang ito?

Matuto ng mga maingay na quantum state gamit ang classical shadows

Tantiya ng paggamit: 34 minuto sa isang Heron r2 processor (PAALALA: Tantiya lamang ito. Maaaring iba ang runtime mo.)

Mga learning outcome​

  • Mangolekta ng mga randomized measurement sa isang IBM® quantum processor mula sa Julia at i-save ang mga ito para sa susunod na pagsusuri

  • Suriin ang measurement data para sa mga sirang qubit at gate bago ang pagkatuto

  • I-fit ang isang matrix product operator (MPO) model ng maingay na state sa classical shadows

  • I-validate ang model sa mga held-out na measurement at ihambing ito sa ideal na circuit

Mga prerequisite​

Pinagmulan at konteksto​

Sa isang totoong quantum processor, ginagawa ng ingay na mixed state na ρ\rho ang pure state na ∣ψ⟩|\psi\rangle na dinisenyong ihanda ng isang circuit. Kayang buuin muli ng buong quantum state tomography ang ρ\rho, pero lumalaki nang exponential ang bilang ng mga measurement na kailangan nito kasabay ng bilang ng mga qubit. Sa halip, natutunan nina Votto et al. [1] ang isang compact na model ng ρ\rho hanggang 96 qubit mula sa mga randomized measurement. Sinusunod ng tutorial na ito ang workflow nila.

Sa isang randomized measurement [2], bawat qubit na ii ay iniikot ng isang independiyenteng random na unitary na uiu_i at saka sinusukat sa computational basis. Tinatawag na measurement setting ang isang draw ng mga pag-ikot, at inuulit ang bawat setting para sa NMN_M shot. Ang isang shot na may outcome bit na sis_i ay nagbibigay ng classical 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),

na ang average nito sa mga setting at shot ay ρ\rho. Kinukuha ng prerequisite na tutorial ang bawat uiu_i mula sa tatlong Pauli basis; ang tutorial na ito, tulad ng paper, ay kinukuha ang mga ito nang uniform mula sa lahat ng single-qubit unitary (Haar random), at pareho pa rin ang formula.

Tinatantya ng mga shadow ang mga katangian ng ilang qubit sa isang pagkakataon. Pinagsasama ng paper ang mga ito sa isang matrix product operator (MPO), na isinusulat ang density matrix bilang isang kadena ng maliliit na tensor, isa bawat qubit; ang mga maingay na state na may short-range na correlation ay nangangailangan lang ng maliliit na bond sa pagitan ng magkakalapit na tensor. Tulad ng density matrix renormalization group (DMRG) algorithm, nag-i-sweep ang learner sa kadena at nag-a-update ng isang tensor sa bawat pagkakataon, kaya tumutugma ang model sa mga shadow sa window na 2ℓ+12\ell+1 qubit na nakasentro sa tensor na iyon (Equation 4 ng paper). Nananatiling fixed ang bond dimension habang ginagawa ang mga update na ito, kaya hindi kailanman nagta-truncate ng model ang learner. Dahil sa mga window na ito lang pumapasok ang data, hindi lumalaki ang bilang ng mga setting na kailangan kasabay ng haba ng kadena.

Hinahati ang mga setting sa isang training set at isang testing set. Sa testing set, tinatantya ng paper ang max fidelity sa pagitan ng ρ\rho at ng model na σ\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)}.

Ang direktang pagsukat sa tr(ρσ)\mathrm{tr}(\rho\sigma) ay mangangailangan ng exponential na dami ng measurement. Sa halip, ina-assume ng paper ang approximate factorization condition (AFC): bumababa ang mga correlation sa ρ\rho sa loob ng ilang qubit, kaya ang mga global na overlap at purity ay nagfa-factor sa mga term sa mga block ng kk magkakalapit na qubit. Ibinibigay rin ng purity ang Rényi-2 entropy na S2=−log⁡2tr ρ2S_2=-\log_2\mathrm{tr}\,\rho^2, na sumusukat kung gaano kahalo ang state.

Inihahanda ng paper ang depth-DD na kicked-Ising state

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

sa 96 qubit ng ibm_brisbane, isang Eagle processor, na may 2,048 setting ng 1,024 shot para sa D=1D=1. Dalawang resulta para sa D=1D=1 ang iniuulat ng Figure 1(c,d) ng paper:

  • Naaabot ng natutunang model ang Fmax⁡≈75%\mathcal{F}_{\max}\approx 75\% kasama ang experimental na state sa N=96N=96, na higit na mataas kaysa sa overlap ng ideal na state na ∣ψ⟩|\psi\rangle at ng eksperimento.

  • Linear ang paglaki ng entropy, S2≈(0.14 hanggang 0.15) NS_2\approx(0.14\text{ hanggang }0.15)\,N, at tumutugma ang entropy ng model sa independiyenteng tantiya mula sa testing set.

Sinusuri ng tutorial na ito ang parehong resulta, una sa isang eight-qubit na simulation kung saan alam ang mga eksaktong sagot, at saka sa isang bagong 96-qubit na run sa ibm_fez, isang Heron r2 processor. Ang learner ay isang independiyenteng Julia implementation ng mga equation sa paper at supplement nito.

Mga kinakailangan​

Nangangailangan ang tutorial na ito ng macOS o Linux, dahil hindi pa sinusuportahan ng Qiskit.jl ang Windows (Qiskit.jl issue #15). Kailangan mo rin ang mga sumusunod:

  • Julia 1.11, mula sa pahina ng pag-download ng Julia o gamit ang juliaup add 1.11, at ang package na IJulia:

    julia -e 'using Pkg; Pkg.add("IJulia")'
  • Para sa hardware na halimbawa, isang IBM Quantum® Platform account na may access sa isang QPU na may hindi bababa sa 96 qubit, at mga naka-save na credential. Kung wala kang account, maaari mong patakbuhin ang hardware na halimbawa mula sa mga naka-save na measurement ng ibm_fez run na gumawa ng mga resulta sa tutorial na ito. Tumatakbo nang walang account ang iba pang seksyon.

Gumagamit ang notebook ng Qiskit.jl at QiskitIBMRuntime.jl para bumuo at magpatakbo ng mga circuit, RandomMeas.jl [4] para sa mga randomized measurement (nagbibigay din ito ng ITensors.jl at ITensorMPS.jl), at NPZ.jl, JSON.jl, at Plots.jl. Nasubukan ang tutorial na ito gamit ang Qiskit.jl 0.6.1, QiskitIBMRuntime.jl 0.3.2, at RandomMeas.jl 0.3.1.

May dalawang paraan para i-set up ang environment:

  • Opsyon 1: I-install ang pinakabagong compatible na bersyon ng mga package sa isang pansamantalang environment. Patakbuhin ang sumusunod na cell nang walang pagbabago.

  • Opsyon 2: Eksaktong gayahin ang nasubukang environment. Itakda ang download_toml_files = true sa sumusunod na cell. Dina-download ng cell ang Project.toml at Manifest.toml mula sa repository ng dokumentasyon papunta sa isang folder na env_tutorial/classical-shadows/ sa tabi ng notebook na ito, at saka ini-install ang eksaktong bersyon ng bawat package na nakatala sa manifest, kasama ang mga indirect na dependency. Para sa mga detalye, tingnan ang dokumentasyon ng Julia tungkol sa mga file na ito.

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

Pag-set up​

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

Ang helper module na mpo_learning.jl, na dina-download ng Setup cell, ang nag-iimplement ng learner. Tinatawag ng tutorial ang mga sumusunod na function mula rito:

FunctionLayunin
kicked_ising_reference(N, D; depolarization)Eksaktong MPO ng ideal na kicked-Ising state, o ng state pagkatapos ng local depolarizing noise
split_settings(group; seed, train_fraction)Random na i-assign ang mga measurement setting sa mga training at testing set (kalahati bawat isa bilang default)
training_marginals(train; ell, prior)Mga shadow estimate ng bawat learning window, mula sa mga training setting lang
fitted_prior(ideal, train)Prior para sa common randomized measurements (CRM), na naka-fit sa nasukat na purity ng bawat window, gaya ng sa paper
learn_mpo(marginals, N; ell, maxbond, sweeps)I-sweep ang one-site update ng paper sa kahabaan ng kadena, simula sa maximally mixed state
max_fidelity(a, b), mpo_overlap(a, b)Eksaktong Fmax⁡\mathcal{F}_{\max} at tr(ab)\mathrm{tr}(ab) sa pagitan ng dalawang MPO
afc_estimate, afc_statistics, afc_prefix_curveMga AFC estimate ng Fmax⁡\mathcal{F}_{\max} at S2S_2 mula sa mga testing setting, na may jackknife na error bar

Iniimbak ng learner ang MPO sa Pauli basis. Pinananatili nitong Hermitian na may unit trace ang model, pero hindi nito pinipilit na positive semidefinite ang model, kaya iniuulat ng notebook kung gaano ka-negatibo ang mga eigenvalue nito.

Maliit na halimbawa sa simulator​

Magsimula sa isang system na sapat na maliit para makalkula ang lahat nang eksakto: ang depth-one na kicked-Ising state sa walong qubit, na may 12% local depolarizing noise para i-model ang hardware. Dahil alam ang maingay na state, maaari mong direktang ihambing ang natutunang model dito.

Hakbang 1: I-map ang mga classical na input sa isang quantum na problema​

Ibinabalik ng function na kicked_ising_reference ang eksaktong state bilang MPO. Sa depolarization=0.12, lumiliit ng 12% ang Bloch vector ng bawat qubit pagkatapos ng circuit.

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

Hakbang 2: I-optimize ang problema para sa pagpapatakbo sa quantum hardware​

Nagsa-sample ang halimbawang ito ng mga measurement outcome nang classical, kaya walang circuit na ita-transpile. Sinasaklaw ng hardware na halimbawa ang hakbang na ito.

Hakbang 3: Patakbuhin gamit ang mga Qiskit primitive​

Gamitin ang RandomMeas.jl para mag-draw ng 2,048 Haar-random na measurement setting at mag-sample ng 256 shot mula sa bawat isa, at saka hatiin nang pantay ang mga setting sa mga training at testing set. Hatiin ayon sa setting at hindi ayon sa shot: ang mga shot mula sa parehong setting ay may parehong mga pag-ikot, kaya hindi sila independiyente.

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

Hakbang 4: I-post-process at ibalik ang resulta sa nais na classical na format​

Alamin ang model gamit ang mga depth-one na parameter ng paper: mga window na umaabot ng ℓ=2\ell=2 qubit sa bawat gilid ng ina-update na tensor, bond dimension na 4, at 20 sweep na nagsisimula sa maximally mixed state. Ina-update ng unang sweep ang magkakalapit na pares ng tensor, na nagpapalaki sa bond dimension mula 1 hanggang 4; bawat sumunod na sweep ay nag-a-update ng isang tensor sa bawat pagkakataon sa fixed na bond dimension na iyon.

Para bawasan ang statistical noise ng mga shadow, gumagamit ang paper ng common randomized measurements (CRM) [5]. Para sa bawat setting, ibinabawas nito ang average na shadow na bubuuin ng isang prior na hula sa state sa parehong setting, at saka ibinabalik ang eksaktong halaga ng prior. Nag-a-average sa zero ang correction, kaya binabago ng prior ang laki ng statistical error pero hindi ang tinatantya. Dito, ang prior ay ang ideal na state na may 10% local depolarization, malapit sa totoong 12%. Sa hardware, hindi alam ang antas ng ingay, kaya sa hardware na halimbawa ay ifi-fit ang prior sa mga nasukat na purity, gaya ng ginagawa ng paper.

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

Sinusukat ng residual kung gaano kalayo ang mga window ng model sa mga training shadow. Bumababa ito kapag nagsimula ang mga one-site update, sa ikalawang sweep, at pagkatapos ay nananatiling halos pare-pareho sa halip na umabot sa zero, dahil may statistical noise ang mga shadow na hindi kayang gayahin ng model na may maliit na bond dimension.

Dahil alam ang state na ito, maaari mong ihambing nang eksakto ang natutunang model dito, at ihambing din dito ang dalawang pinakasimpleng hula: ang CRM prior at ang ideal na state.

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

Mas malapit ang natutunang model sa maingay na state kaysa sa prior o sa ideal na state, kaya natutunan nito ang ingay mula sa data. Ang maliliit nitong negatibong eigenvalue ay nagmumula sa limitadong bilang ng mga measurement.

Sa hardware, hindi alam ang state, kaya tinatantya mo na lang ang Fmax⁡\mathcal{F}_{\max} mula sa mga testing setting. Hinahati ng AFC ang kadena sa mga block na A1,…,ARA_1,\dots,A_R ng kk qubit at tinatantya ang purity sa pamamagitan ng

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

at ang tr(ρσ)\mathrm{tr}(\rho\sigma) sa pamamagitan ng parehong ratio ng mga local overlap. Sa k=4k=4, sinasaklaw ng dalawang block ang lahat ng walong qubit at eksakto ang formula; sa k=2k=2, umaasa ito sa factorization assumption. Sinasaklaw lang ng mga jackknife error bar, na nag-iiwan ng isang testing setting sa bawat pagkakataon, ang statistical error ng testing data, hindi ang randomness ng training o ang AFC approximation.

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

Parehong tumutugma sa eksaktong halaga ang dalawang held-out na estimate sa loob ng kanilang mga error bar.

Malakihang halimbawa sa hardware​

Ngayon, patakbuhin ang eksperimento sa isang 96-qubit na kadena ng ibm_fez, isang Heron r2 processor. Tulad ng ibm_brisbane, may heavy-hex na coupling map ito at katulad na antas ng ingay.

Ang pagkolekta ng data ay nangangailangan ng 1,024 Sampler job at humigit-kumulang 34 minuto ng oras sa QPU. Kung wala kang access sa QPU na may hindi bababa sa 96 qubit, o mahaba ang queue, patakbuhin ang hardware example gamit ang mga sukat na naitala sa ibm_fez noong 27 Setyembre 2026, na siyang nagbigay ng mga resultang ipinapakita sa tutorial na ito. Kapag use_saved_data = true, dina-download ng notebook ang mga sukat na ito (15 MB) mula sa Zenodo [6] sa Step 1 at nilalaktawan ang pag-submit ng job sa Step 3. Para kolektahin ang sarili mong data, itakda ito sa false.

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

Step 1: I-map ang mga classical na input sa isang quantum na problema​

Bawat setting ay nangangailangan ng isang circuit: ang kicked-Ising circuit, isang U(θ,ϕ,λ)U(\theta,\phi,\lambda) gate sa bawat qubit para sa uiu_i, at isang pagsukat ng bawat qubit. Ang pag-sample ng θ=2arcsin⁡v\theta=2\arcsin\sqrt{v}, kung saan ang vv, ϕ/2π\phi/2\pi, at λ/2π\lambda/2\pi ay uniform sa [0,1)[0,1), ay ginagawang Haar random ang UU. Ibinabalik ng function na u3_matrix ang matrix ng UU, na ginagamit ng Step 4.

Ang budget ay 1,024 na setting na may tig-1,024 shots, kalahati ng bilang ng mga setting sa paper, na hinati nang pantay sa training at testing. Kapag may saved data, nilo-load ng cell ang mga naitalang anggulo. Kung hindi, gumagawa ito ng mga bagong anggulo at sine-save ang mga ito bago ka mag-submit ng anuman, dahil hindi mo maa-analyze ang mga resulta kung wala ang mga ito. Kung umiiral na ang file, nilo-load ito ng cell, para magtugma pa rin ang mga anggulo sa mga naka-save na resulta pagkatapos mong i-restart ang session.

"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

Step 2: I-optimize ang problema para sa pag-execute sa quantum hardware​

Ang isang chain ay kasing-husay lang ng pinakamasamang qubit nito, kaya ikaw mismo ang pumili ng 96 na pisikal na qubit. Hindi pa tumatanggap ng fixed initial layout ang function na transpile ng Qiskit.jl, at sa isang test sa ibm_phoenix, may kasamang qubit na may 51% readout error ang layout na pinili nito. Ang sumusunod na chain ay ang 96-qubit na path sa coupling map ng ibm_fez na pinili ng error-aware na layout ng function na transpile ng Python Qiskit (na may optimization_level=3) mula sa calibration data noong 27 Setyembre 2026. Ang mean na readout error nito ay 1.6%, ngunit kakaunti ang 96-qubit na path sa isang heavy-hex lattice, at kasama sa isang ito ang qubit 35, na may 15% na readout error. Nagbabago ang mga calibration, kaya pumili ng bagong chain mula sa kasalukuyang calibration data bago ka mag-run sa ibang araw o ibang QPU.

Para mapanatili ang chain na ito, isulat nang direkta ang mga circuit gamit ang mga native gate sa halip na i-transpile ang mga ito. Ang isang U(θ,ϕ,λ)U(\theta,\phi,\lambda) gate ay katumbas ng RZ(ϕ+π) X RZ(θ+π) X RZ(λ)R_Z(\phi+\pi)\,\sqrt{X}\,R_Z(\theta+\pi)\,\sqrt{X}\,R_Z(\lambda) hanggang sa isang global phase. Sinasaklaw ng decomposition na ito ang parehong random rotation at ang kick na e−iπ8X=U(π/4,−π/2,π/2)e^{-i\frac{\pi}{8}X}=U(\pi/4,-\pi/2,\pi/2). Ang gate na eiπ4ZjZj+1e^{i\frac{\pi}{4}Z_jZ_{j+1}} ay katumbas ng isang CZ gate na sinusundan ng S†S^\dagger sa dalawang qubit, hanggang sa isang global phase. Dahil diagonal ang mga S†S^\dagger gate na ito, nagko-commute sila sa mga CZ gate, kaya bawat qubit ay nakakaipon ng isang RZ(−π/2)R_Z(-\pi/2) kada bond bago ang measurement rotation nito.

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

Step 3: I-execute gamit ang mga Qiskit primitive​

Ang QiskitIBMRuntime.jl ay nagpapatakbo ng isang circuit kada Sampler job, kaya ang pagkolekta ng data ay nangangailangan ng 1,024 na job. Ang sumusunod na cell ay nagpapanatili ng hanggang 32 job sa queue at sine-save ang mga resulta ng bawat setting sa sandaling matapos ang job nito. Ang bawat shot ay ibinabalik bilang vector ng mga bit, kung saan ang elementong ii ay ang resulta ng chain qubit na ii.

Kailangan mong kunin ang mga resulta sa parehong session na nag-submit ng mga job, dahil hindi pa kayang maghanap ng job gamit ang ID nito ng QiskitIBMRuntime.jl (qiskit-ibm-runtime-c issue #28). Kung pumalya ang isang job, mag-iisyu ng babala ang cell at magpapatuloy. Kung huminto ang session, patakbuhin muli ang Steps 1 hanggang 3. Ang muling pagpapatakbo ng cell ay magsa-submit lamang ng mga setting na kulang ang resulta. Kapag use_saved_data = true, walang isinusumite ang cell.

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

Step 4: Mag-post-process at ibalik ang resulta sa nais na classical na format​

Ang step na ito ay nagbabasa lamang ng naka-save na data: ang na-download na run ng ibm_fez kung true ang use_saved_data, o kung hindi, ang mga file na isinulat ng Step 3. Kaya maaari mo itong patakbuhin sa bagong session nang hindi nagsa-submit ng mga job (patakbuhin muna ang Setup cell, ang use_saved_data cell, at ang Step 1). Ang na-download na file ay nag-iimbak ng 96 na resulta ng bawat shot na naka-pack sa 12 byte, pinakamahalagang bit muna, kaya ina-unpack ito ng loader. Ang RandomMeas.jl ay nagla-label ng mga resulta bilang 1 at 2, kaya dinadagdagan din ng loader ng 1 ang bawat 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

Bago mag-learn, suriin ang data. Ang sirang qubit o hindi maayos na na-calibrate na gate ay ginagawang mas mixed ang sinukat na state sa paligid nito, at maaari nitong gawing mag-diverge ang learner. Ang purity ng ilang magkakalapit na qubit ay isang model-free na benchmark ng ingay na ito: tinatantya ng function na get_purity mula sa RandomMeas.jl ang tr ρA2\mathrm{tr}\,\rho_A^2 para sa isang subsystem na AA sa pamamagitan ng paghahambing ng mga pares ng shot mula sa parehong setting. Kalkulahin ang Rényi-2 entropy na S2=−log⁡2tr ρA2S_2=-\log_2\mathrm{tr}\,\rho_A^2 ng bawat window ng anim na magkakalapit na qubit, at ihambing ito sa parehong window ng ideal na state. Hindi zero ang ideal na halaga, dahil ang bawat window ay entangled sa natitirang bahagi ng chain; pinapataas ito ng ingay, at itinutulak ng sirang qubit ang bawat window na naglalaman nito papunta sa maximum na anim.

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

Mas mixed ang bawat window kaysa sa ideal na state, nang humigit-kumulang kalahating bit hanggang isang bit, at ang pinakamaingay na bahagi ay nasa paligid ng mga posisyon 30 hanggang 35 ng chain. Walang window na lumalapit sa maximum na anim, kaya walang sirang qubit, at ginagamit ng analysis ang buong 96-qubit na chain. Kung may mga window na may entropy na malapit sa anim, aalisin mo ang qubit na pinagsasaluhan ng mga window na iyon at ima-mag-learn mo ang pinakamahabang bahagi ng chain nang wala ito.

Ang parehong mga purity ang tumutukoy sa CRM prior. Para sa bawat window, kinukuha ng fitted_prior ang ideal na state at fina-fit ang isang lokal na depolarizing strength upang tumugma ang purity nito sa purity na sinukat sa mga training setting, tulad ng sa paper.

Ginagawa ng function na learn_and_validate sa sumusunod na cell ang natitirang bahagi ng analysis. Natututo ito ng model mula sa mga training setting, pagkatapos ay tinatantya ang Fmax⁡\mathcal{F}_{\max} at S2S_2 sa mga testing setting para sa unang NN qubit ng chain, sa mga hakbang na 12. Ito ang mga dami sa Figure 1(c,d) ng paper. Ang ideal na state ay tinatasa sa parehong testing data bilang baseline.

Pinapatakbo ng cell ang function na may ℓ=2\ell=2 at inuulit ito na may ℓ=1\ell=1 at ℓ=0\ell=0 upang makita kung gaano kahalaga ang laki ng mga learning window. Ang bond dimension ay maaaring umabot nang hindi hihigit sa 4ℓ4^\ell, kaya ang ℓ=0\ell=0 ay natututo ng product state: bawat qubit nang mag-isa, na walang correlation sa pagitan ng mga qubit.

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

Ginagaya ng mga resulta ang dalawang claim ng paper sa ibang processor:

  • Mas mahusay na inilalarawan ng model ang data kaysa sa ideal na state. Sa N=96N=96, ang held-out na Fmax⁡\mathcal{F}_{\max} ng ℓ=2\ell=2 na model ay 0.59 ± 0.10, kumpara sa 0.0035 para sa ideal na state. Nag-uulat ang paper ng humigit-kumulang 0.75 sa ibm_brisbane.

  • Tugma ang entropy ng model sa testing data sa bawat NN. Sa N=96N=96, ito ay 10.2 mula sa model at 10.0 ± 0.3 mula sa testing data, o S2/N≈0.10S_2/N\approx 0.10, kumpara sa 0.14 hanggang 0.15 sa mas lumang ibm_brisbane.

Ipinapakita ng paghahambing ng mga laki ng window kung nasaan ang impormasyon. Sa ℓ=1\ell=1, halos kasing-husay ang model (Fmax⁡=0.55±0.09\mathcal{F}_{\max}=0.55\pm0.09), kaya para sa data na ito, kaunti lang ang naidaragdag ng mga correlation na lampas sa ilang qubit. Sa ℓ=0\ell=0, hindi nakukuha ng product state ang entanglement sa pagitan ng magkakalapit na qubit: lumalaki ang entropy nito hanggang 32 sa halip na 10, at mas mabilis pang bumabagsak ang Fmax⁡\mathcal{F}_{\max} nito kaysa sa ideal na state, hanggang 6×10−66\times10^{-6} sa N=96N=96.

Tandaan ang mga sumusunod na limitasyon kapag binabasa ang mga numerong ito:

  • Training split. Sinasaklaw lamang ng mga error bar ang statistical error ng testing data. Ang ibang random na split ng parehong mga setting ay nagbibigay ng Fmax⁡\mathcal{F}_{\max} sa pagitan ng 0.49 at 0.59 sa N=96N=96 para sa ℓ=2\ell=2.

  • Huling sweep. Laging ibinabalik ng learner ang model mula sa huling sweep, kaya hindi kailanman naiimpluwensyahan ng testing data ang model.

  • Positivity. Ang model ay hindi pinipilit na maging positive semidefinite; ang pinakanegatibong eigenvalue nito sa isang learning window ay humigit-kumulang −0.05-0.05. Kaya ang Fmax⁡\mathcal{F}_{\max} at S2S_2 nito ay naglalarawan ng isang operator, hindi ng mga certified na katangian ng isang pisikal na state.

  • Factorization. Ang bawat held-out na pagtatantya ay umaasa sa AFC assumption, na hindi mapapatunayan ng mga sukat mismo.

Mga susunod na hakbang​

Mga Rekomendasyon
  • Ulitin ang eksperimento sa depth na dalawa gamit ang mga parameter ng paper para sa depth na iyon (ℓ=3\ell=3 at maximum na bond dimension na 8), at alamin kung ilang measurement setting ang kailangan ng learner.

  • Mag-learn gamit ang two-site update sa halip (update=:two_site sa training_marginals at learn_mpo), na nagta-truncate ng bond dimension pagkatapos ng bawat hakbang, at tingnan kung paano ito kumikilos sa mas kaunting training setting.

  • Mag-learn nang walang CRM prior (prior=nothing) at ihambing ang held-out na fidelity.

  • Ilapat ang parehong analysis sa mga inilathalang ibm_brisbane na sukat ng mga may-akda.

  • Basahin ang supplement ng paper para sa derivation ng update at ng mga AFC estimator.

  • Tuklasin ang iba pang randomized-measurement na protocol sa mga halimbawa ng RandomMeas.jl.

Mga Sanggunian​

  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