Lumaktaw sa pangunahing nilalaman

CHSH inequality

Tinatayang paggamit: Dalawang minuto sa isang Heron r3 processor (PAALALA: Ito ay tantya lamang. Maaaring mag-iba ang iyong runtime.)

Mga layunin sa pagkatuto​

Pagkatapos makumpleto ang tutorial na ito, inaasahang mauunawaan mo ang mga sumusunod:

  • Paano gumawa ng parameterized Bell-state CHSH Circuit at sukatin ang apat na expectation values na bumubuo sa mga CHSH witness.
  • Paano kalkulahin ang mga expectation values ng maraming observables sa isang parameter sweep sa isang tawag sa EstimatorV2 primitive.
  • Paano i-validate ang isang quantum workflow sa isang maingay na lokal na simulator gamit ang AerSimulator.from_backend bago isumite sa hardware.
  • Paano palakihin ang isang CHSH experiment sa isang device-wide entanglement benchmark sa pamamagitan ng pagpapatakbo ng maraming independiyenteng Bell pair nang magkasamang-sabay sa IBM Quantum® hardware.

Mga kinakailangan​

Inirerekomenda na pamilyarisado ka sa mga paksang ito:

Pinagmulan​

Sa tutorial na ito, magsasagawa ka ng eksperimento sa isang quantum computer upang ipakita ang paglabag sa CHSH inequality gamit ang Estimator primitive.

Ang CHSH inequality, na pinangalanan mula kina Clauser, Horne, Shimony, at Holt, ay ginagamit upang eksperimentong patunayan ang teorama ni Bell (1969). Inaangkin ng teoremang ito na ang mga lokal na teoryang may nakatagong variable ay hindi makapaliwanag ng ilang kahihinatnan ng entanglement sa quantum mechanics. Ang pagpapakita ng paglabag sa CHSH inequality ay nagpapatunay na ang quantum mechanics ay hindi tugma sa mga lokal na teoryang may nakatagong variable — isang eksperimentong pundamental sa ating pag-unawa sa quantum mechanics.

Ang 2022 Nobel Prize for Physics ay iginawad kina Alain Aspect, John Clauser, at Anton Zeilinger dahil sa kanilang pioneering work sa quantum information science, at lalo na, para sa kanilang mga eksperimento na may entangled photons na nagpapakita ng paglabag sa mga inequality ni Bell.

Para sa eksperimentong ito, gagawa tayo ng entangled pair kung saan susukatin ang bawat qubit sa dalawang magkaibang bases. Tatakan natin ang mga bases para sa unang qubit na AA at aa at ang mga bases para sa pangalawang qubit na BB at bb. Ito ay nagbibigay-daan sa atin na kalkulahin ang CHSH quantity na S1S_1:

S1=A(B−b)+a(B+b).S_1 = A(B-b) + a(B+b).

Ang bawat observable ay +1+1 o −1-1. Malinaw, ang isa sa mga termino na B±bB\pm b ay dapat na 00, at ang isa pa ay dapat na ±2\pm 2. Samakatuwid, S1=±2S_1 = \pm 2. Ang average value ng S1S_1 ay dapat sumunod sa inequality:

∣⟨S1⟩∣≤2.|\langle S_1 \rangle|\leq 2.

Ang pag-expand ng S1S_1 sa mga termino ng AA, aa, BB, at bb ay nagbibigay ng:

∣⟨S1⟩∣=∣⟨AB⟩−⟨Ab⟩+⟨aB⟩+⟨ab⟩∣≤2.|\langle S_1 \rangle| = |\langle AB \rangle - \langle Ab \rangle + \langle aB \rangle + \langle ab \rangle| \leq 2.

Maaari kang magtalaga ng isa pang CHSH quantity na S2S_2:

S2=A(B+b)−a(B−b),S_2 = A(B+b) - a(B-b),

na humahantong sa isa pang inequality:

∣⟨S2⟩∣=∣⟨AB⟩+⟨Ab⟩−⟨aB⟩+⟨ab⟩∣≤2.|\langle S_2 \rangle| = |\langle AB \rangle + \langle Ab \rangle - \langle aB \rangle + \langle ab \rangle| \leq 2.

Kung ang quantum mechanics ay maaaring ilarawan ng mga lokal na teoryang may nakatagong variable, ang mga inequality na ito ay palaging mananatiling totoo. Gaya ng ipinakita sa tutorial na ito, maaari silang labagin sa isang quantum computer, kaya ang quantum mechanics ay hindi tugma sa mga lokal na teoryang may nakatagong variable.

Gagawa tayo ng entangled pair sa pamamagitan ng paghahanda ng Bell state na ∣Φ+⟩=∣00⟩+∣11⟩2|\Phi^+\rangle = \frac{|00\rangle + |11\rangle}{\sqrt{2}}. Gamit ang Estimator primitive, direkta nating makukuha ang mga expectation values na ⟨AB⟩,⟨Ab⟩,⟨aB⟩\langle AB \rangle, \langle Ab \rangle, \langle aB \rangle, at ⟨ab⟩\langle ab \rangle, nang hindi kailangang buuin mula sa mga raw counts. Susukat tayo ng pangalawang qubit sa ZZ at XX bases. Ang unang qubit ay susukatin din sa orthogonal bases, ngunit may rotation angle na θ\theta na ating i-sweep sa pagitan ng 00 at 2π2\pi. Sinusuri ng Estimator primitive ang parameter sweep na ito sa isang primitive unified bloc (PUB).

Mga kinakailangan​

Bago magsimula ng tutorial na ito, tiyaking mayroon kang sumusunod na naka-install:

  • Qiskit SDK v2.0 o mas bago, na may visualization support
  • Qiskit Runtime v0.40 o mas bago (pip install qiskit-ibm-runtime)
  • Qiskit Aer v0.17 o mas bago (pip install qiskit-aer)

Setup​

# Added by doQumentation — required packages for this notebook
!pip install -q matplotlib numpy qiskit qiskit-aer qiskit-ibm-runtime
# General
import numpy as np

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

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

# Qiskit Aer for local noisy simulation
from qiskit_aer import AerSimulator

# Plotting routines
import matplotlib.pyplot as plt
import matplotlib.ticker as tck
# Select an IBM Quantum backend.
service = QiskitRuntimeService()
backend = service.least_busy(
    min_num_qubits=127, operational=True, simulator=False
)
backend.name
'ibm_pittsburgh'

Maliit na halimbawa ng simulator​

Bago magsumite ng hardware job, ina-validate natin ang buong workflow sa isang lokal na maingay na simulator. Ginagamit natin ang AerSimulator.from_backend(backend) upang bumuo ng simulator na nagmamana ng noise model at coupling map ng backend na iyong pinili, kaya ang tugon ng simulator ay kalidad na katulad ng inaasahan natin mula sa hardware.

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

Isinusulat natin ang CHSH Circuit na may isang parameter na θ\theta, na nag-i-sweep ng measurement basis ng unang qubit. Pinasimple ng Estimator primitive ang pagsusuri: direkta nitong ibinabalik ang mga expectation values ng mga observable, at kaya nitong suriin ang isang parameterized circuit sa maraming parameter values sa isang tawag.

theta = Parameter(r"$\theta$")

chsh_circuit = QuantumCircuit(2)
chsh_circuit.h(0)
chsh_circuit.cx(0, 1)
chsh_circuit.ry(theta, 0)
chsh_circuit.draw(output="mpl", idle_wires=False, style="iqp")

Output of the previous code cell

Susunod, gagawa tayo ng listahan ng 21 phase values mula 00 hanggang 2π2\pi kung saan susuriin ang parameterized circuit (00, 0.1π0.1\pi, 0.2π0.2\pi, ..., 1.9π1.9\pi, 2π2\pi).

number_of_phases = 21
phases = np.linspace(0, 2 * np.pi, number_of_phases)
# Phases need to be expressed as a list of lists for the Estimator PUB
individual_phases = [[ph] for ph in phases]

Sa wakas, tinutukoy natin ang mga observable. Ang unang qubit ay sinusukat sa mga axes na inikot ng θ\theta; ang pangalawang qubit ay sinusukat sa ZZ at XX. Sa mga pagpipiliang ito, ang apat na CHSH correlators ay namamapa sa mga Pauli operator na ZZZZ, ZXZX, XZXZ, at XXXX:

⟨S1⟩=⟨ZZ⟩−⟨ZX⟩+⟨XZ⟩+⟨XX⟩,\langle S_1 \rangle = \langle ZZ \rangle - \langle ZX \rangle + \langle XZ \rangle + \langle XX \rangle, ⟨S2⟩=⟨ZZ⟩+⟨ZX⟩−⟨XZ⟩+⟨XX⟩.\langle S_2 \rangle = \langle ZZ \rangle + \langle ZX \rangle - \langle XZ \rangle + \langle XX \rangle. 
# <S_1> = <ZZ> - <ZX> + <XZ> + <XX>
observable1 = SparsePauliOp.from_list(
    [("ZZ", 1), ("ZX", -1), ("XZ", 1), ("XX", 1)]
)

# <S_2> = <ZZ> + <ZX> - <XZ> + <XX>
observable2 = SparsePauliOp.from_list(
    [("ZZ", 1), ("ZX", 1), ("XZ", -1), ("XX", 1)]
)

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

Ang mga V2 primitive ay tumatanggap lamang ng mga circuit at observable na sumusunod sa mga instruction at connectivity na sinusuportahan ng target system (instruction set architecture, o ISA, circuits at observables). Binubuo natin ang AerSimulator mula sa backend at ini-transpile laban sa target ng simulator upang ang parehong pass manager ay masanay nang buo.

# Build a noisy simulator from the ibm_pittsburgh backend
aer_sim = AerSimulator.from_backend(backend)

pm = generate_preset_pass_manager(target=aer_sim.target, optimization_level=3)
chsh_isa_circuit = pm.run(chsh_circuit)
chsh_isa_circuit.draw(output="mpl", idle_wires=False, style="iqp")

Output of the previous code cell

Binabago rin natin ang mga observable upang tumugma sa qubit layout ng transpiled circuit gamit ang SparsePauliOp.apply_layout.

isa_observable1 = observable1.apply_layout(layout=chsh_isa_circuit.layout)
isa_observable2 = observable2.apply_layout(layout=chsh_isa_circuit.layout)

Hakbang 3: Isagawa gamit ang mga Qiskit primitive​

Pinapatakbo ang parameter sweep gamit ang EstimatorV2 sa aer_sim mode. Ang run() method ng Estimator ay tumatanggap ng isang iterable ng mga PUB. Ang bawat PUB ay may format na (circuit, observables, parameter_values, precision). Ipinapasa natin ang parehong observable nang magkasama upang maibahagi nila ang parehong parameter sweep.

# Use the AerSimulator-backed Estimator to validate the workflow locally
estimator_sim = Estimator(mode=aer_sim)

pub = (
    chsh_isa_circuit,  # ISA circuit
    [[isa_observable1], [isa_observable2]],  # ISA observables
    individual_phases,  # Parameter values
)

sim_result = estimator_sim.run(pubs=[pub]).result()

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

Ibinabalik ng Estimator ang mga expectation values para sa parehong observable. Ini-plot natin ang mga ito laban sa θ\theta kasama ang classical bound (±2\pm 2) at ang Tsirelson bound (±22\pm 2\sqrt{2}). Ang mga shaded grey na lugar ay nagmamarka ng agwat sa pagitan ng dalawa. Ang mga puntong nasa loob ng mga band na ito ay lumalabag sa CHSH inequality.

chsh1_sim = sim_result[0].data.evs[0]
chsh2_sim = sim_result[0].data.evs[1]

def plot_chsh(phases, chsh1, chsh2, title):
    fig, ax = plt.subplots(figsize=(10, 6))

    ax.plot(
        phases / np.pi, chsh1, "o-", label=r"$\langle S_1 \rangle$", zorder=3
    )
    ax.plot(
        phases / np.pi, chsh2, "o-", label=r"$\langle S_2 \rangle$", zorder=3
    )

    # classical bound +-2
    ax.axhline(y=2, color="0.9", linestyle="--")
    ax.axhline(y=-2, color="0.9", linestyle="--")

    # quantum bound, +-2*sqrt(2)
    ax.axhline(y=np.sqrt(2) * 2, color="0.9", linestyle="-.")
    ax.axhline(y=-np.sqrt(2) * 2, color="0.9", linestyle="-.")
    ax.fill_between(phases / np.pi, 2, 2 * np.sqrt(2), color="0.6", alpha=0.7)
    ax.fill_between(
        phases / np.pi, -2, -2 * np.sqrt(2), color="0.6", alpha=0.7
    )

    ax.xaxis.set_major_formatter(tck.FormatStrFormatter("%g $\\pi$"))
    ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))

    ax.set_xlabel(r"$\theta$")
    ax.set_ylabel("CHSH witness")
    ax.set_title(title)
    ax.legend()
    plt.show()

plot_chsh(
    phases,
    chsh1_sim,
    chsh2_sim,
    "CHSH witnesses from AerSimulator (ibm_pittsburgh noise model)",
)

Output of the previous code cell

Ang mga CHSH witness ng simulator ay lumampas na sa classical bound na ±2\pm 2 sa ilang mga value ng θ\theta, kahit na may noise model ng backend. Ang mga tuktok ay bahagyang kulang sa Tsirelson bound na ±22\pm 2\sqrt{2} dahil sa simulate na device noise. Sa na-validate na workflow, magpatuloy na tayo sa tunay na hardware.

Malaking-sukat na halimbawa ng hardware​

Ang CHSH test ay mahalagang isang two-qubit na eksperimento, kaya hindi ito lumalaki sa pamamagitan ng paggawa ng mas malaking Circuit. Sa halip, lumalaki ito sa pamamagitan ng pagpapatakbo ng maraming test nang sabay-sabay. Dito natin inuulit ang backend na may maraming disjoint Bell pair hangga't pinapayagan ng connectivity nito (isang matching ng coupling map) at nagpapatakbo ng independiyenteng CHSH sub-circuit sa bawat pair, lahat sa isang job.

Ginagawa nitong isang device-wide benchmark ng kalidad ng entanglement ang CHSH: sa halip na isang hand-picked na pair, sinusubukan natin ang entanglement sa malaking bahagi ng chip nang sabay-sabay, sa makatotohanang kondisyon kung saan ang bawat pair ay nakikipaglaban sa crosstalk ng mga kapitbahay at mga parallel-gate error. Ang paglabag sa inequality sa bawat pair sabay-sabay ay nagpapatunay na ang tunay na entanglement ay available sa lahat ng dako ng device.

# -------------------------Step 1: Map classical inputs to a quantum problem-------------------------
# A CHSH test is bipartite, so we scale up by running one independent CHSH
# experiment on every disjoint Bell pair the device can host. A greedy
# matching of the coupling map gives a set of edges that share no qubits.
num_qubits = backend.num_qubits
used = set()
pairs = []
for qa, qb in backend.coupling_map.get_edges():
    if qa not in used and qb not in used:
        pairs.append((qa, qb))
        used.update((qa, qb))
num_pairs = len(pairs)
print(
    f"Tiling {backend.name} with {num_pairs} parallel Bell pairs "
    f"({2 * num_pairs} of {num_qubits} qubits)"
)

# One parameterized CHSH sub-circuit per pair, all sharing the angle theta
theta = Parameter(r"$\theta$")
chsh_circuit = QuantumCircuit(num_qubits)
for qa, qb in pairs:
    chsh_circuit.h(qa)
    chsh_circuit.cx(qa, qb)
    chsh_circuit.ry(theta, qa)

# Embed the two CHSH observables onto each pair's qubits (identity elsewhere)
obs1 = SparsePauliOp.from_list([("ZZ", 1), ("ZX", -1), ("XZ", 1), ("XX", 1)])
obs2 = SparsePauliOp.from_list([("ZZ", 1), ("ZX", 1), ("XZ", -1), ("XX", 1)])
observables = []
for qa, qb in pairs:
    observables.append([obs1.apply_layout([qa, qb], num_qubits)])
    observables.append([obs2.apply_layout([qa, qb], num_qubits)])

number_of_phases = 21
phases = np.linspace(0, 2 * np.pi, number_of_phases)
individual_phases = [[ph] for ph in phases]

# -------------------------Step 2: Optimize problem for quantum hardware execution-------------------------
pm = generate_preset_pass_manager(target=backend.target, optimization_level=3)
chsh_isa_circuit = pm.run(chsh_circuit)
isa_observables = [
    [o[0].apply_layout(chsh_isa_circuit.layout)] for o in observables
]

# -------------------------Step 3: Execute using Qiskit primitives-------------------------
estimator_hw = Estimator(mode=backend)
estimator_hw.options.environment.job_tags = ["TUT_CI"]

pub = (chsh_isa_circuit, isa_observables, individual_phases)
job = estimator_hw.run(pubs=[pub])
print(f"Job ID: {job.job_id()}")
hw_result = job.result()

# -------------------------Step 4: Post-process and return result in desired classical format-------------------------
# evs has shape (2 * num_pairs, number_of_phases); rows alternate S1, S2
evs = np.asarray(hw_result[0].data.evs)
chsh1_all = evs[0::2]
chsh2_all = evs[1::2]

# A pair "violates" CHSH if its strongest witness exceeds the classical bound
peak = np.maximum(
    np.abs(chsh1_all).max(axis=1), np.abs(chsh2_all).max(axis=1)
)
n_violate = int(np.sum(peak > 2))
print(
    f"{n_violate}/{num_pairs} Bell pairs violated the CHSH inequality "
    f"(mean peak witness {peak.mean():.2f}, classical bound 2)"
)

fig, ax = plt.subplots(figsize=(10, 6))

# Faint individual per-pair curves
for row in chsh1_all:
    ax.plot(phases / np.pi, row, color="#1f77b4", alpha=0.2, lw=1)
for row in chsh2_all:
    ax.plot(phases / np.pi, row, color="#ff7f0e", alpha=0.2, lw=1)

# Bold mean curves across all pairs
ax.plot(
    phases / np.pi,
    chsh1_all.mean(axis=0),
    color="#1f77b4",
    lw=2.5,
    label=r"$\langle S_1 \rangle$ (mean)",
)
ax.plot(
    phases / np.pi,
    chsh2_all.mean(axis=0),
    color="#ff7f0e",
    lw=2.5,
    label=r"$\langle S_2 \rangle$ (mean)",
)

# classical bound +-2 and Tsirelson bound +-2*sqrt(2)
ax.axhline(y=2, color="0.9", linestyle="--")
ax.axhline(y=-2, color="0.9", linestyle="--")
ax.axhline(y=np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.axhline(y=-np.sqrt(2) * 2, color="0.9", linestyle="-.")
ax.fill_between(phases / np.pi, 2, 2 * np.sqrt(2), color="0.6", alpha=0.7)
ax.fill_between(phases / np.pi, -2, -2 * np.sqrt(2), color="0.6", alpha=0.7)

ax.xaxis.set_major_formatter(tck.FormatStrFormatter("%g $\\pi$"))
ax.xaxis.set_major_locator(tck.MultipleLocator(base=0.5))
ax.set_xlabel(r"$\theta$")
ax.set_ylabel("CHSH witness")
ax.set_title(
    f"CHSH witnesses for {num_pairs} parallel Bell pairs on {backend.name}"
)
ax.legend()
plt.show()
Tiling ibm_pittsburgh with 64 parallel Bell pairs (128 of 156 qubits)
Job ID: d86efd5g7okc73el0rp0
63/64 Bell pairs violated the CHSH inequality (mean peak witness 2.75, classical bound 2)

Output of the previous code cell

Ang mga maputlang kurba ay ang mga indibidwal na Bell pair at ang mga matapang na kurba ay ang kanilang average sa buong device. Bawat pair ay sumusubaybay sa parehong sinusoid na hinuhulaan ng quantum mechanics, at ang pagkalat sa pagitan ng mga maputlang kurba ay sumasalamin sa pagkakaiba-iba ng noise mula sa pair hanggang sa pair. Saan man pumapasok ang isang kurba sa mga grey band, lumampas na ito sa classical bound na ±2\pm 2, at ang naka-print na buod ay nagpapatunay na halos bawat pair ay lumalabag sa CHSH inequality nang sabay-sabay.

Ang mga tuktok ay kulang sa Tsirelson bound na ±22\pm 2\sqrt{2} dahil sa device noise, ngunit ang konklusyon ay malinaw: ang backend ay nagpapanatili ng tunay na entanglement sa buong chip nang sabay-sabay, hindi lamang sa isang hand-picked na pair. Ito ang kahulugan kung saan "lumalaki" ang CHSH experiment: hindi bilang isang mas malaking Circuit, kundi bilang isang parallel benchmark na nagpapatunay ng entanglement sa lahat ng dako nang sabay-sabay.

Mga susunod na hakbang​

Mga rekomendasyon

Kung nahanap mong kawili-wili ang gawaing ito, maaari kang maging interesado sa sumusunod na materyal:

Pinagmulan: IBM Quantum docs — na-update noong Hun 8, 2026
Bersyong Ingles sa doQumentation — na-update noong Hun 8, 2026
Ang pagsasaling ito ay batay sa bersyong Ingles noong Abr 9, 2026
Isyu sa site o pagsasalin?Isyu sa nilalaman? I-edit sa IBM Quantum docs