GHZ durumu — $N$ kübit, tek bir nefes ile dolanıklık

GHZ durumu, $N$ sayıda kübitin aynı anda maksimum düzeyde dolanık olduğu haldir: $\ket{GHZ_N} = \frac{1}{\sqrt{2}}\bigl(|00\ldots 0\rangle + |11\ldots 1\rangle\bigr)$. Tüm sistem ya kolektif olarak $|0\rangle$ ya da $|1\rangle$ ölçülür; aradaki karışık sonuçlar — $001$, $010$, $\ldots$ — ideal bir devrede hiç görünmez.

Qiskit tarafında bu zincir devrenin sonuna bir for döngüsüyle eklenir; kapıların hangi zaman diliminde çalıştığı yorumlanmaz, derleyiciye bırakılır. Cirq ise ters yönden yaklaşır: kapıları doğrudan operasyonlar listesi olarak verir, sonra her operasyonu uygun ilk momente yerleştirir. GHZ devresi bu mantıkta öğretici bir örnektir, çünkü her yeni CNOT bir önceki kübitin sonucuna bağımlıdır — Cirq da bunu görüp her halkayı yeni bir momente taşır.

• LineQubit düzeni

  GHZ'de kübitlerin fiziksel sırası önemlidir. Cirq'in LineQubit modeli, sinyalin bir kübitten diğerine nasıl aktığını koddan doğrudan görselleştirmeye yardımcı olur. Qiskit tarafında kübitler arası mesafe varsayılan olarak sıfır kabul edilirken, bu sayfada kullandığımız LineQubit kübitlerin yan yana dizildiği bir fiber optik hattı ya da atom dizisi gibi davranan bir donanım topolojisini modeller.

• Momentlerin birikimi

  Tipik GHZ hazırlığında zincir CNOT(q[0],q[1]), CNOT(q[1],q[2]), … şeklinde ilerir; her yeni iki kübitlik kapı, önceki kapının oluşturduğu ortak kuantum durumuna bakarak ilerlediği için aynı anda yürütülecek bir “paralel iş” değildir. Cirq bu yüzden bu kapıları aynı momente sıkıştırmaz; her halka için yeni bir zaman dilimi açar — üst üste bindirilecek tek şey, farklı kübitlere dokunan ve çakışmayan kapılardır (GHZ zincirinde böyle bir paralellik yoktur). Sonuç: bir H ve N−1 zincir CNOT için tipik olarak N moment derinliği (üstteki ana fikir kutusuyla uyumlu).

• Donanım tasarımı

  İki boyutlu süperiletken veya benzeri çiplerde aynı mantığı kurarken GridQubit(satır, sütun) ile fiziksel olarak komşu düğümleri seçmek, iki kübitlik kapıların doğrudan uygulanabileceği çiftleri kodda görünür kılar; rastgele uzak indeksler seçilirse derleyici aynı matematik için ek SWAP veya yönlendirme ekleyerek derinliği ve hata şansını artırır. Doğrusal GHZ zinciri için bazen satır veya sütun boyunca bitişik bir “yürüyüş” seçmek yeterlidir; daha karmaşık topolojilerde ise önce harita üzerinde komşuluk çizerek kübit ataması yapmak iyi bir pratikir.

• Ölçüm yoğunluğu · iki dal

  Ölçümden önce durum iki dalın süperpozisyonudur; hesaplama tabanında ölçüm yapılınca dalgalardan biri seçilir — ya bit dizisinin tamamı 0 ya tamamı 1. Histogramda iki yoğun tepe ve tam sayı kodlaması Devre ve doğrulama bölümünde; karışık klasik diziler temiz simülatörde beklenmez — donanımda görülürse gürültü okuması için yine aynı bölümdeki notlar yeterlidir.

GHZ devresinin matematiği, Bell kurulumunun doğrusal bir genişlemesidir: önce bir “lider” süperpozisyonu, sonra bu dal yapısını sırayla paylaşan CNOT halkaları. Bu bölümde odak kodun yazılış sırası ve hangi Cirq çağrısının neyi temsil ettiğidir; durumların satır satır cebiri Algoritmanın Cirq reçetesinde, moment ve topoloji sezgisi ise Cirq mimarisinde toplanır — böylece aynı hikâye üç kez tekrar etmez.

1. 1

   Iteratif Kübit Tanımlama

   İhtiyaç duyduğun $N$ kübit cirq.LineQubit.range(N) ile tek seferde oluşturulur; Python dilinde bu, 0 ile N−1 arası indeksli LineQubit nesneleri üretmek demektir. Böylece hem döngüde qubits[i] / qubits[i+1] yazmak kolaylaşır hem de soyut hat üzerinde soldan sağa ilerleyen bir zincir hayali kurulur.

2. 2

   Lider Kübitin Hazırlanması

   İlk kübit Hadamard ile süperpozisyona alınır: cirq.H(qubits[0]). Bu tek satır zincirin “tohumu”dur: sonraki CNOT adımları, tam olarak bu süperpozisyonun iki dalını çoğaltmayı hedefler; henüz başka kübite dokunulmamış olması, devre diyagramında da ilk momentte yalnız üst (veya ilk) hat üzerinde çalışan tek-kübit kapısı olarak görünür.

3. 3

   Dolanıklık Zinciri (Cascading)

   Örneğin for i in range(N - 1): içinde cirq.CNOT(qubits[i], qubits[i + 1]) eklersiniz: her yeni iki kübitlik kapı, önceki kapının oluşturduğu ortak kuantum durumu bir kübit daha uzağa taşır. Cirq bu yüzden tipik olarak her halkayı ayrı bir momente yazar — paralelleştirilecek kadar bağımsız iki işlem değildir (klasik bir “önce ölç, sonra karar ver” akışı değil, tam tersine tek bir sürekli devre zaman çizelgesi).

4. 4

   Kolektif Ölçüm

   Tüm kübitler tek bir klasik anahtar (key) altında ölçülür: cirq.measure(*qubits, key="ghz_sonuc"). Histogramda her tekrar için tek bir tamsayı görürsünüz; bu sayının ikilik gösterimi tüm kübitleri birlikte kodlar — örneğin üç kübitte yalnızca tam 000 veya tam 111 dizileri yoğunlaşır. Tam sayı–bit eşlemesi ve beklenen oranlar Devre ve doğrulama bölümünde özetlenir.

Burada yalnızca durum cebiri işlenir: önce $N = 3$ için satır satır tensör yazımı, en altta ise genel $\ket{GHZ_N}$ özeti. Hangi Cirq satırının hangi sırayla geldiğini Mantıksal akış anlatır; moment görünümü mimari bölümündedir — böylece aynı metin üç kez dönmez.

• Adım 1 · Başlangıç

  $N = 3$ için üç LineQubit seçilir: $q_0$, $q_1$, $q_2$. Kompakt yazım $|q_0 q_1 q_2\rangle = |000\rangle$, açık tensör olarak $|0\rangle \otimes |0\rangle \otimes |0\rangle$.

• Adım 2 · Hadamard ($q_0$)

  İlk kübit süperpozisyona alınır: $\frac{1}{\sqrt{2}}\bigl(|0\rangle + |1\rangle\bigr) \otimes |00\rangle$. Diğer iki kübit henüz ürün durumunda $|00\rangle$; henüz üçlü dolanıklık yoktur.

• Adım 3 · İlk CNOT ($q_0 \to q_1$)

  Kontrol $|1\rangle$ dalında hedef çevrilir: $\frac{1}{\sqrt{2}}\bigl(|00\rangle + |11\rangle\bigr) \otimes |0\rangle$. Bu ifade $q_0$–$q_1$ için Bell çekirdeğidir; $q_2$ henüz üründe ayrı bir faktör olarak $|0\rangle$’dadır.

• Adım 4 · İkinci CNOT ($q_1 \to q_2$)

  Önceki satırda iki dalda da $q_2$ için $|0\rangle$ ortaktır; kontrol $q_1$’in $|1\rangle$ dalında hedef $q_2$ çevrilerek üçüncü kübit de ilk iki ile kilitlenir: $\frac{1}{\sqrt{2}}\bigl(|000\rangle + |111\rangle\bigr) = \ket{GHZ_3}$. Üç kübitlik ket yazımında basamaklar birlikte ya hep 0 ya hep 1 olur; ara diziler (ör. 001) bu ideal süperpozisyonda yoktur.

  $$\ket{GHZ_N} = \frac{1}{\sqrt{2}}\bigl(\ket{0}^{\otimes N} + \ket{1}^{\otimes N}\bigr)$$

Aşağıdaki örnek 3 kübitlik bir GHZ devresi kurar, Cirq'in metin tabanlı çizimini yazdırır ve 1024 tekrar ile ölçüm histogramı üretir. $N$ değişkenini büyütmek, zinciri uzatmak için yeterlidir; geri kalan kod aynı kalır.

import cirq

# 1. Kübitlerin hazırlanması (örnek: 3 kübit)
n = 3
qubits = cirq.LineQubit.range(n)

# 2. GHZ devresinin inşası
# Operasyonları bir liste içinde topluyoruz.
ops = [cirq.H(qubits[0])]

# Zincirleme CNOT kapıları ekleniyor.
for i in range(n - 1):
    ops.append(cirq.CNOT(qubits[i], qubits[i + 1]))

# Kolektif ölçüm.
ops.append(cirq.measure(*qubits, key="ghz_sonuc"))

# Devreyi oluştur.
circuit = cirq.Circuit(ops)

# 3. Devre şemasını ve momentleri incele
print("Cirq GHZ Devre Şeması:")
print(circuit)

# 4. Simülasyon
simulator = cirq.Simulator()
result = simulator.run(circuit, repetitions=1024)

# 5. İstatistiksel sonuçlar
# 3 kübit için 0 (000) ve 7 (111) sonuçları beklenir.
counts = result.histogram(key="ghz_sonuc")
print(f"\nGHZ Ölçüm İstatistikleri: {counts}")

cirq.LineQubit.range(n) kübitleri otomatik olarak $0, 1, \ldots, n-1$ indekslerinde isimlendirir ve donanım üzerindeki doğrusal bir hattı temsil eder. GHZ zinciri için bu doğal bir seçimdir: ardışık kübitler birbirine komşu durur, derleyici fazladan swap eklemek zorunda kalmaz.

ops = [cirq.H(qubits[0])] ile devre operasyon listesi olarak başlatılır; sonra for döngüsü her kübiti komşusuna CNOT ile bağlar. Cirq bu listeyi cirq.Circuit(ops) içine aldığında her operasyonu uygun ilk momente yerleştirir. CNOT'lar aynı kübitleri paylaştığı için üst üste binemezler ve zincir doğal olarak $N$ momentlik bir derinliğe yayılır.

cirq.measure(*qubits, key="ghz_sonuc") satırındaki *qubits ifadesi Python'un "argüman açma" (unpacking) sözdizimidir; listedeki kübitleri measure'a tek tek argüman olarak gönderir. key, sonucun histogramda hangi etiket altında toplanacağını söyler.

Histogram çıktısı $N = 3$ için yalnızca 0 (binary $000$) ve 7 (binary $111$) görünür. Aradaki 1–6 arası değerlerin yokluğu, dolanıklığın tüm zincir boyunca korunduğunu kanıtlar. Daha büyük $N$ için beklenen iki sonuç sırasıyla $0$ ve $2^N - 1$ olur.

$N = 3$ için Cirq'in terminale yazdırdığı ASCII çıktı, devrenin moment yapısını doğrudan görselleştirir: ilk momentte yalnızca Hadamard, ikinci momentte ilk CNOT, üçüncü momentte ikinci CNOT ve son momentte kolektif ölçüm. SVG karşılığı ise aynı zincirin uzamsal akışını renk ve şekille kodlar.

0: ───H───@───────M('ghz_sonuc')───
          │       │
1: ───────X───@───M────────────────
              │   │
2: ───────────X───M────────────────

$N = 3$ için tam ölçekli devre şeması aşağıdadır. Aynı şablon $N = 4, 5, \ldots$ için yatay olarak genişletilebilir; her yeni kübit için zincire bir CNOT (yani bir moment) eklenir.

Şemayı adım adım oku

1. 1

   Moment 0’da H, ilk kübiti (q0) süperpozisyona alır.

2. 2

   Moment 1’de CNOT, q0 ile q1’i bağlayarak dolanıklık zincirini başlatır.

3. 3

   Moment 2’de ikinci CNOT, q1’den q2’ye yayılır ve üçlü GHZ korelasyonunu kurar.

4. 4

   Son momentte üç kübit ölçülür; idealde yalnızca 000 ve 111 yarı yarıya görünür.

• Beklenen sonuç

  Yeterli atışta histogram yalnızca $0$ ve $2^N - 1$ değerlerini ~%50–%50 oranında gösterir; gürültüsüz bir simülatörde aradaki tüm değerler sıfırdır.

• $N$'i büyütmek

  Sadece n = 3 satırını n = 5 yap; geri kalan kod aynı kalır. Devre $N$ moment derinliğinde uzar ve histogramda $0$ ile $2^N - 1$ değerlerini görürsün.

• Bell ile bağ

  İlk iki kübit zaten Bell durumundadır; her ek CNOT, bu Bell çekirdeğini bir kübit daha "büyüten" bir genişletme adımıdır.

• GridQubit varyantı

  Sycamore gibi 2D çiplerde aynı zinciri kurmak için cirq.GridQubit(0, i) ile bir satırı seçmek yeterlidir; topoloji uyumlu kaldığı sürece ek swap gerektirmez.