W durumu — dayanıklı üçlü dolanıklığın diğer yüzü

W durumu, üç ya da daha fazla kübitlik bir sistemde tam olarak bir tek kübitin uyandığı, geri kalanların uyumakta olduğu bir süperpozisyon olarak anlatılır. “Hangi kübit uyanık?” sorusunun cevabı ölçüm anına kadar askıdadır; ölçümle birlikte ise her zaman tam bir kübit uyanık görülür — ne hiçbiri, ne ikisi birden.

“Uyanık” ve “uyuyor” burada ne demek? Parçacığın yerinde durması, kapının çalışmaması veya enerji taşımaması gibi klasik hareket kastedilmez; tamamen standart (Z) tabanında yapacağınız ölçümün vereceği klasik sonuçlar için kullanılan bir benzetmedir. Bir kübit “uyuyor” ise o dalda 0, “uyanık” ise 1 okumayı düşünün. Ölçüm gerçekleşene kadar sistem, “birlikten hangi kübitin 1 rolünü üstleneceği” üzerinde süperpozisyondadır; ölçüm bu rolü tek bir kübite verir. Üç kübitlik standart W için bu, yalnızca 001, 010 ve 100 klasik dizilerinin süperpozisyonudur — her dizide tam olarak bir adet 1, iki adet 0 bulunur (matematikçe Hamming ağırlığı 1).

Matematiksel ifadesi

Üç eşit dağılmış sonuç Tüm kübitleri standart (Z) tabanda birlikte ölçtüğünüzde yalnızca 001, 010 veya 100 görürsünüz; her birinin olasılığı genliğin karesidir, yani 1/3 (yaklaşık %33). Süperpozisyonda yer almayan diğer beş dizinin genliği sıfırdır — ölçüm onları üretmez. 000 ve 111 GHZ’nin “hep uyuyor / hep uyanık” dünyalarına karşılık gelir. 011, 101, 110 ise iki adet 1 taşıdığı için W’nin “iki uyanık” dünyalarıdır ve bu denkleme girmez.

Olasılık korunumu

Katsayıların karelerinin toplamı 1 $\frac{1}{\sqrt{3}}$ katsayısı tesadüf değildir; üç olası dünyanın olasılıkları $\frac{1}{3} + \frac{1}{3} + \frac{1}{3} = 1$ olmalıdır. Kuantum mekaniğinde her durum vektörü ünite uzunluğundadır — buna uniterite denir; teorinin "ölçtüğünde mutlaka bir sonuç çıkar" garantisidir.

$\sqrt{3}$ neden Bell/GHZ'den farklı Bell ve GHZ'de iki olası klasik dünya vardı, dolayısıyla katsayı $\frac{1}{\sqrt{2}}$. W'de üç dünya var, katsayı $\frac{1}{\sqrt{3}}$. Daha genel olarak $N$ olası klasik sonuç ortak süperpozisyondaysa katsayı $\frac{1}{\sqrt{N}}$ olur — basit ama gözlerden kaçan bir doğal yasa.

GHZ ve W, üç kübitlik dolanıklığın iki ayrı sınıfıdır — birinden ötekine yerel kapılarla geçilemez. Aralarındaki en pratik fark dekoherens (çevreye sızıp kuantum bilginin kaybolması) anındaki davranışlarıdır.

GHZ: kırılgan ama deterministik

Tek kayıp, tüm dolanıklık Bir GHZ sistemindeki kübitlerden herhangi biri ölçülür ya da çevreye kaybolursa, geri kalan kübitler arasındaki dolanıklık anında yok olur; sistem klasik bir korelasyon listesine düşer. Bu "ya hep ya hiç" davranışı GHZ'nin paradoks gücünü verir, ama pratik kullanımda bir zayıflıktır.

W: dayanıklı ve kalıcı

Tek kayıp, geri kalan hâlâ dolanık W durumundaki üç kübitten biri ölçülürse iki olası senaryo çıkar: ölçtüğümüz kübit "1" gelirse diğer iki kübit kesin |00⟩'a düşer; "0" gelirse ise diğer iki kübit doğrudan (|01⟩ + |10⟩)/√2 Bell durumunda kalır — yani hâlâ maksimum düzeyde dolanık.

Asimetrik bilgi dağılımı GHZ tüm bilgiyi tek bir kollektif "ya 0 ya 1" formülünde toplar; W ise üç kübit arasında parçalanmış olarak tutar. Bu parçalanma, tek bir taşıyıcının düşmesini sistem için "kabul edilebilir" hale getirir.

Üç-kübit dolanıklık aileleri

SLOCC sınıflandırması Üç-kübit saf hâl alanı, yerel işlemler ve klasik iletişimle (SLOCC) birbirine dönüştürülemez iki gerçekten dolanık aileye ayrılır: GHZ-sınıfı ve W-sınıfı. Bu, Dür, Vidal ve Cirac'ın 2000'deki klasik makalesinde gösterilmiştir. Yani GHZ ile W, üç-kübit dolanıklığının iki temel "renk"idir; aralarındaki geçiş için kübitlerin yıkıcı işlemden geçmesi gerekir.

W durumu üretmek, GHZ'deki gibi düz bir "zincirleme" işlem değildir. Burada dolanıklık paylaşımı asimetrik — genliği kübitler arasında belirli oranlarda dağıtmamız gerekir. Bu yüzden reçete üç aşamadan oluşur: önce ilk kübite doğru miktarda olasılık yüklemek, sonra bu olasılığı kontrollü kapılarla paylaştırmak, en sonunda durumu istenen forma getirmek için küçük bir "temizlik" hamlesi.

Aşama 1 olasılık yüklemesi

$R_y(\theta)$ rotasyonu GHZ’deki gibi H ile %50–%50 süperpozisyon kurmak burada yetmez: W’de her “tek uyanık” kolunun olasılığı $\frac{1}{3}$ olmalı. İlk kübite bunun tohumunu vermek için Y-ekseni etrafında parametrik rotasyon kullanırız; açı $\theta = 2\arccos(1/\sqrt{3})$ seçildiğinde q0’ın durumu $\sqrt{2/3}\ket{0} + \sqrt{1/3}\ket{1}$ olur — Born kuralına göre 0 yaklaşık 2/3, 1 yaklaşık 1/3 olasılıkla ölçülür; böylece sonra paylaşılacak $\frac{1}{3}$ payı q0 üzerinde hazırlanmış olur.

Aşama 2 kontrollü paylaşım

Kontrollü Hadamard ($CH$) İlk kübit kontrol, ikinci kübit hedef olacak şekilde Hadamard’ın kontrollü sürümünü uygularız: kontrol 0 iken hedefe dokunulmaz; kontrol 1 iken hedefe H uygulanır. Böylece q0’nın 1 kolundaki genlik q1’de de iki dala ayrılır; q0’nın 0 kolu ise olduğu gibi kalır — tek kübitlik süperpozisyon “paylaştırılarak” iki kübitlik yapıya yayılır.

Zincirleme CNOT'lar Önce qc.cx(1, 2): q1 kontrol, q2 hedef — q1’de biriken yapı q2’ye kopyalanarak üçüncü kübit devreye girer. Sonra qc.cx(0, 1): q0 kontrol, q1 hedef — q0’nın 1 bilgisi q1 üzerinde yeniden düzenlenir. Bu sıra, devrenin sonunda standart W kümesindeki üç “tek birlikli” bit dizisinin eş süperpozisyonunu oluşturur; ara adımlarda etiketler hedef formdan biraz farklı görünebilir, son X düzeltmesi bunu hizalar (bir sonraki aşama).

Aşama 3 temizlik

$X$ ile son düzeltme CH ve CNOT zinciri dolanıklığı kurar; fakat bu özel sırayla üretilen kübit etiketleri, okuduğumuz standart W yazımına (001, 010, 100) göre bazen bir kayma/pozisyon farkıyla gelir. Ölçüm öncesi q0’ya bir X (NOT) eklemek, genlikleri koruyarak bit dizilerini bu standart forma döndürür — yani olasılıkları yeniden dağıtmaz, yalnızca 0 / 1 etiketlerini hizalar. Böylece durum tam olarak $\ket{W}$ olur — üç tek‑birlik tabanın eşit süperpozisyonu; Matematiksel ifadesi kutusundaki tam yazılışla özdeştir.

Hızlı sezgi — önce bunu okuyun Bu liste doğrudan koda karşılık gelir; formüller gözünüzü korkutuyorsa şunu düşünün: önce q0’a “çoğunlukla uyuyor, üçte bir ihtimalle uyanıyor” karışımını veriyoruz ki sonra bu pay diğer kübitlere yayılınca üç “tek uyanık” dünya eşit (%33’er) olsun. Ardından kübitleri birbirine bağlıyoruz; küçük bir X ile yazdığımız bit sırasını düzgün isimlendiriyoruz; en sonda ölçümde yalnız 001, 010, 100 görmeniz gerekir.

1. 1

   İlk kübite Ry(θ) uygula — bu, q0’ı “hemen hemen 0 ( ~%67, uyuyor), bazen 1 (~%33, uyanık)” süperpozisyonuna getirir. Ölçmeden önce sistem henüz kararsızdır; önemli olan, 1 kolunun payının tam olarak 1/3 olmasıdır — çünkü W’de üç final dünya da eşit olasılıklıdır ve bu pay burada hazırlanır.

   İsterseniz sayılar: θ = $2\arccos(1/\sqrt{3})$; q0 durumu $\sqrt{2/3}\ket{0} + \sqrt{1/3}\ket{1}$ olur — soldaki kökler tam da bu yüzdendirler (2/3 ve 1/3 olasılıkları verirler).

2. 2

   İlk kübit kontrol, ikinci kübit hedef olacak şekilde CH (kontrollü Hadamard) uygula — olasılık q1'e dağılır.

3. 3

   CNOT(1, 2) ile q1 → q2 yansıması kur; ardından CNOT(0, 1) ile q0 üzerinden q1'e bir geri yansıma daha ekle.

4. 4

   q0'a son X uygula — durum artık tam olarak $\ket{W}$ formundadır.

5. 5

   Üç kübiti klasik bitlere ölç. Beklenen sonuç: 001, 010, 100 her biri ~%33.

Aşağıdaki örnek üç kübitlik W durumunu kurar, ölçer ve histogramı yazdırır. Reçete dört kapı türü kullanır: Ry, CH, CNOT ve son X. Açı seçimi numpy ile hesaplanır; bu yüzden bu sefer numpy opsiyonel değil zorunludur.

import numpy as np
from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator

# 1. Devre kurulumu: 3 kübit ve 3 klasik bit
qc = QuantumCircuit(3, 3)

# 2. W algoritması adımları
# Adım 1: İlk kübite özel rotasyon — 1/sqrt(3) genliği için
theta = 2 * np.arccos(1 / np.sqrt(3))
qc.ry(theta, 0)

# Adım 2: Kontrollü Hadamard — olasılığı q1'e paylaştır
qc.ch(0, 1)

# Adım 3: Dolanıklığı q2'ye yay ve q1'e geri yansıt
qc.cx(1, 2)
qc.cx(0, 1)

# Adım 4: Durumu tam olarak W formuna getirmek için son düzeltme
qc.x(0)

qc.barrier()

# 3. Ölçüm
qc.measure(range(3), range(3))

# 4. Çalıştırma
simulator = AerSimulator()
job = simulator.run(qc, shots=1024)
counts = job.result().get_counts()

print("\nW Durumu Ölçüm Sonuçları (001, 010, 100 beklenir):")
print(counts)

Kod Analizi

Importlar numpy bu sefer zorunludur: $\theta = 2\arccos(1/\sqrt{3})$ açısını Python'da hesaplamak için np.arccos ve np.sqrt gerekir. Diğer iki paket Bell ailesindekiyle aynı: QuantumCircuit devre nesnesi, AerSimulator yerel simülatör.

qc = QuantumCircuit(3, 3) Üç kübit ve üç klasik bit; üçünü de ölçeceğimiz için kayıt boyutunu kübit sayısına eşitledik. Kübit sırası önemli olacak: q0 ilk satırdan, q2 üçüncü satırdan ölçülür ve klasik bitlere yazılırken Qiskit konvansiyonuyla c0 sağ uçta görünür.

theta = 2 * np.arccos(1 / np.sqrt(3)) Açının matematiksel arka planı şudur: $R_y(\theta)$ kapısı $\ket{0}$'ı $\cos(\theta/2)\ket{0} + \sin(\theta/2)\ket{1}$ haline getirir. $\sin(\theta/2)$ büyüklüğünün $1/\sqrt{3}$ olmasını isteriz; buradan $\theta = 2\arccos(1/\sqrt{3})$ çıkar. Numerik olarak yaklaşık 1.9106 radyan (~109.47°). Sayıyı sabit yazmak yerine ifadeyi numpy ile hesaplatmak hem daha okunabilir hem de farklı boyutlu W'ler için kolay genişler.

qc.ry(theta, 0) q0'a yukarıda hesapladığımız açıda Ry rotasyonu uygular. Sonuç: $\sqrt{2/3}\ket{0} + \sqrt{1/3}\ket{1}$. Hadamard yerine Ry seçmemizin sebebi: Hadamard yalnızca eşit (%50–%50) süperpozisyon kurar; W için kontrollü bir asimetri (%66–%33) gerekiyor.

qc.ch(0, 1) — kontrollü Hadamard "Eğer q0 = 1 ise q1'e Hadamard uygula" demektir. Bu adım, q0'ın 1 olduğu dünyada q1'e olasılık parçalar; q0'ın 0 olduğu dünyada hiçbir şey değişmez. Sonuç, $1/\sqrt{3}$ ağırlığının iki kübit arasında pay ettiği bir ara durum. Üç kübitlik W için kaynaklarda farklı kapı dizileri görülür; “tek doğru şema” yoktur. Bu yüzden nihai kontrol, seçilen θ ve sırayla gerçekten eş genlikli |W⟩ elde edildiğini göstermektir — en kesin yöntem ölçüm öncesi Statevector ile olasılık dağılımına bakmaktır (aşağıdaki blok).

qc.cx(1, 2) + qc.cx(0, 1) İki ardışık CNOT, "uyanık olan kübitin" zincirini kurar. Birincisi q1 uyanıksa q2'yi uyandırır; ikincisi q0 uyanıksa q1'i uyandırır. Bu sıralama kritiktir — yer değiştirilirse devre artık W üretmez.

qc.x(0) — son düzeltme Yukarıdaki üç adımdan sonra q0 hâlâ "olasılık taşıyıcı" gibi davranıyor; X ile son halini "uyandırma" görevini diğer iki kübite tamamen devrederiz. Sonuç: $\ket{W} = (\ket{001} + \ket{010} + \ket{100})/\sqrt{3}$. Son X hem tabanı “kaydırır” hem de üç yolun genliğini bu hedef forma kilitlemek için gereklidir; dengeyi tartmak için yine Statevector (ölçümsüz devre) kullanın — histogram tek başına genlik cebirini kanıtlamaz.

qc.barrier() Hesaplamaya etkisi yok; sadece görsel/optimizasyon ayracı. Bu devrede özellikle işe yarar çünkü ölçüm öncesi son X kapısı transpiler tarafından öncesindeki CNOT'larla birleştirilmek istenebilir; barrier bunu engeller.

qc.measure(range(3), range(3)) Üç kübiti ilgili klasik bitlere ölç. range kullanımı, kod kübit sayısına ölçeklendiğinde otomatik genişler — ama dikkat: bu reçete sadece üç kübit için geçerlidir. Daha büyük W'ler için açı ve devre yapısı yeniden türetilir.

İdeal genlik: statevector doğrulaması

Histogram istatistiksel bir kontroldür (shot sayısı arttıkça ~1/3’e yaklaşır). Kesin kontrol için ölçüm ve barrier olmadan aynı hazırlığı çalıştırıp Statevector üzerinden olasılıkları okuyun: ideal simülatörde yalnızca 001, 010, 100 görünür ve her birinin olasılığı tam olarak 1/3 olmalı; diğer tabanların payı sıfırdır.

import numpy as np
from qiskit import QuantumCircuit
from qiskit.quantum_info import Statevector

qc_prep = QuantumCircuit(3)
theta = 2 * np.arccos(1 / np.sqrt(3))
qc_prep.ry(theta, 0)
qc_prep.ch(0, 1)
qc_prep.cx(1, 2)
qc_prep.cx(0, 1)
qc_prep.x(0)

print(Statevector(qc_prep).probabilities_dict())
# Örnek çıktı (sıra değişebilir): 001, 010, 100 için ~0.333…; diğerleri 0.0

Çalıştırma için tek bir Python ortamında qiskit, qiskit-aer ve numpy paketlerinin kurulu olması yeterlidir; kurulumun tek bakışta özeti ana sayfadaki IDE ve çalıştırma bölümündedir. Gerçek donanımda denemek için AerSimulator() satırını QiskitRuntimeService().backend("ibm_brisbane") gibi bir IBM cihazıyla değiştirin; CH kapısı doğal donanım kapısı değildir, transpiler onu Ry/CNOT kombinasyonuna açar — devre derinliği artar, sadakat biraz düşer.

Üç kübit için Qiskit metin çıktısı kapıları soldan sağa sıralar; ░ sütunu koddaki barrier() ile ölçüm arasındaki ayraçtır. Bariyer sütununun satır satır “tam düşey” görünmemesi terminal düzeninden kaynaklanabilir; mantıksal zaman dilimi yine de tüm hatlarda aynıdır. Sağdaki SVG aynı akışı kolon kolon okunur kılar.

     ┌────────────┐               ┌───┐ ░ ┌─┐      
q_0: ┤ Ry(1.9106) ├──■─────────■──┤ X ├─░─┤M├──────
     └────────────┘┌─┴─┐     ┌─┴─┐└───┘ ░ └╥┘┌─┐   
q_1: ──────────────┤ H ├──■──┤ X ├──────░──╫─┤M├───
                   └───┘┌─┴─┐└───┘      ░  ║ └╥┘┌─┐
q_2: ───────────────────┤ X ├───────────░──╫──╫─┤M├
                        └───┘           ░  ║  ║ └╥┘
c: 3/══════════════════════════════════════╩══╩══╩═
                                           0  1  2 

Bu şema, 5 · Aynı Devre (İki Temsil) bölümündeki akışı korur; üç kübitlik W reçetesini görselleştirir. Sol uçta q0'a Ry(θ) uygulanır; ardından CH ile q0 → q1 paylaşımı, iki CNOT ile yansıma, son X ile düzeltme; en sonda üç kübitin de ölçümü. Her kapı kutusu altında, kapının kuantum durumda yaptığı değişimin bir özetini görebilirsiniz.