Süper yoğun kodlama — tek kübitle iki klasik bit

Süper yoğun kodlama, tek bir kübit kullanarak iki klasik bitlik bilgi göndermeyi mümkün kılan bir kuantum iletişim protokolüdür. 1992'de Charles Bennett ve Stephen Wiesner tarafından tanıtıldı; klasik kanalın temel kuralı olan "bir taşıyıcı = bir bit" sınırını dolanıklık yardımıyla ikiye katlar.

Temel kurallar

Önceden paylaşılmış dolanıklık şarttır Protokol çalışmadan önce Alice ve Bob bir Bell çifti ($\ket{\Phi^+}$) paylaşmış olmalıdır — kübitlerin biri Alice'te, diğeri Bob'ta. Bu paylaşım, mesaj gönderiminden çok önce yapılabilir; örneğin geceden hazırlanır, sabah kullanılır. Mesaj anına kadar kübitler atıl bekler.

Yerel işlem, kollektif sonuç Alice mesajını kodlarken yalnızca kendi kübitine kapı uygular — Bob'un kübitine dokunmaz, sinyal göndermez. Buna rağmen tüm sistemin Bell durumu değişir; çünkü dolanık iki kübit tek bir kuantum nesnesi gibi davranır. Alice'in yerel hamlesi, Bob'un kübitine "uzaktan" değil, sistemin bütününe yapılır.

Teleportasyonun aynası Kuantum teleportasyonda iki klasik bit kullanarak bir kübit taşırız; süper yoğun kodlamada ise bir kübit kullanarak iki klasik bit taşırız. İki protokol birbirinin tersidir — ikisi de aynı kaynağı (Bell çifti) farklı yönde harcar. Bu simetri, kuantum bilgi teorisinin en şık denklemlerinden biri olan kanal kapasite ilişkisinin temelidir.

Alice'in dört olası mesajı için ($00, 01, 10, 11$) yapacağı tek şey kendi kübitine doğru Pauli kapısını uygulamak. Her kapı, Bell çiftini farklı bir Bell durumuna döndürür; dört Bell durumu birbirine ortogonal olduğu için Bob bunları ayırt edebilir. İşte protokolün tüm kalbi.

Dört kapı, dört durum

$00 \to I$ (kimlik) Alice hiçbir şey yapmaz; sistem |Φ⁺⟩ = (|00⟩ + |11⟩)/√2 olarak kalır. Klasik mesajın "olmaması" da fiziksel bir bilgidir.

$01 \to X$ (bit-flip) Alice kendi kübitine $X$ uygular; sistem |Ψ⁺⟩ = (|01⟩ + |10⟩)/√2 haline gelir.

$10 \to Z$ (faz-flip) Alice $Z$ uygular; sistem |Φ⁻⟩ = (|00⟩ − |11⟩)/√2 olur. Görünürdeki olasılık dağılımı $\ket{\Phi^+}$ ile aynıdır; aradaki tek fark fazda saklı.

$11 \to ZX$ (her ikisi) Alice önce $Z$ sonra $X$ uygular (eşdeğer olarak $iY$); sistem |Ψ⁻⟩ = (|01⟩ − |10⟩)/√2 haline gelir. Bu dört Bell durumu Hilbert uzayında birbirine dik (ortonormal) olduğu için Bob hangisi olduğunu tek bir Bell-baz ölçümünde bulabilir.

Süper yoğun kodlama dört net aşamadan oluşur: dolanıklığın kurulması, Alice'in kodlaması, kübitin Bob'a fiziksel olarak iletimi ve Bob'un Bell-baz ölçümüyle kod çözmesi. Her adım, devrenin görünür bir parçasına karşılık gelir.

Aşama 1 · dolanıklık hazırlığı

Önceden kurulmuş Bell çifti Bir aracı (ya da Alice) bir Bell çifti üretir: H + zincirleme CNOT ile $\ket{\Phi^+}$ kurulur. Birinci kübit Alice'e, ikincisi Bob'a verilir. Bu adım mesaj gönderiminden bağımsızdır; kaynak hazırlığı gibidir.

Aşama 2 · Alice'in kodlaması

Bir kapı, dört seçenek Alice mesajının iki bitine bakar ve ikinci bölümdeki tabloya göre kendi kübitine uygun Pauli kapısını uygular: $I$, $X$, $Z$ veya $ZX$. Bu işlem son derece yereldir; Alice Bob'a fiziksel olarak hiçbir sinyal yollamaz. Sistem yine de farklı bir Bell durumuna geçer.

Aşama 3 · kübitin gönderilmesi

Tek fiziksel taşıyıcı Alice, kodlamasını bitirdiği kendi kübitini Bob'a fiziksel olarak gönderir. Optik fiber, foton, soğuk atomlar, hangi medyum varsa onun üzerinden bir tek kuantum nesnesi taşınır. Bu adım protokolün klasik dünyaya en yakın kısmıdır — bir paket gönderimi gibi.

Aşama 4 · Bob'un kod çözmesi

Bell-baz ölçümü Bob'un elinde artık iki kübit var: kendi orijinal kübiti ve Alice'ten gelen yeni kübit. Bob bunlara CNOT + H uygulayıp ardından standart Z-baz ölçümü yapar. Bu kombinasyon, Bell durumlarını klasik etiketlere geri çevirir; tek bir ölçümde Alice'in iki bitlik mesajı klasik kayda düşer.

1. 1

   Aracı (ya da Alice) bir Bell çifti hazırlar (H + zincirleme CNOT) ve kübitlerden birini Alice'e, diğerini Bob'a teslim eder.

2. 2

   Alice mesajına göre kendi kübitine Pauli kapısı uygular: $00 \to I$, $01 \to X$, $10 \to Z$, $11 \to ZX$.

3. 3

   Alice kendi kübitini Bob'a fiziksel olarak gönderir (kuantum kanal üzerinden).

4. 4

   Bob Bell-baz ölçümü yapar: önce CNOT (kontrol: Alice'ten gelen kübit, hedef: kendi kübiti), sonra H (Alice'ten gelen kübitte), ardından her ikisini ölçer.

5. 5

   Klasik kayıttaki iki bit doğrudan Alice'in mesajıdır. İdeal ortamda %100 sadakatle eşleşir.

Aşağıdaki örnek tek bir mesaj için süper yoğun kodlama devresini parametrik bir fonksiyon olarak kurar. Devre üç bölümden oluşur — Bell çifti hazırlığı, Alice'in mesaj-temelli kodlaması ve Bob'un Bell-baz ölçümü. "00", "01", "10" ve "11" mesajlarını sırayla deneyebilirsiniz; histogramda her seferinde tek bir kombinasyon yükselir.

from qiskit import QuantumCircuit
from qiskit_aer import AerSimulator


def create_superdense_coding(message):
    qc = QuantumCircuit(2, 2)

    # 1. Adım: Bell çifti oluştur (Alice ve Bob arasında paylaştırıldı)
    qc.h(0)
    qc.cx(0, 1)
    qc.barrier()

    # 2. Adım: Alice'in kodlaması (mesaja göre kapı uygula)
    if message == "00":
        pass  # Identity
    elif message == "01":
        qc.x(0)
    elif message == "10":
        qc.z(0)
    elif message == "11":
        qc.z(0)
        qc.x(0)

    qc.barrier()  # Alice kübitini Bob'a gönderir

    # 3. Adım: Bob'un kod çözmesi (Bell ölçümü)
    qc.cx(0, 1)
    qc.h(0)
    qc.barrier()

    # 4. Adım: Ölçüm
    qc.measure([0, 1], [0, 1])
    return qc


# "11" mesajını gönderelim
message = "11"
qc = create_superdense_coding(message)

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

print(f"\nAlice'in gönderdiği mesaj: {message}")
print(f"Bob'un aldığı sonuç: {result}")

Kod analizi · satır satır

Importlar Yalnızca QuantumCircuit ve AerSimulator; bu örnekte numpy'a ihtiyaç yok çünkü tüm kapılar sabit Pauli'leri.

create_superdense_coding(message) Devreyi parametrik bir fonksiyon olarak yazmak protokolün esnekliğini taşır; aynı şablonu dört mesaj için ayrı ayrı çağırarak hepsini doğrulayabilirsiniz. message "00", "01", "10" veya "11" olabilir.

qc.h(0) + qc.cx(0, 1) Bell çiftini kuran iki kapı. Burada bir simülasyon kolaylığı kullandık: Alice ve Bob'un kübitleri aynı devrenin parçası gibi görünüyor; gerçek bir uygulamada bu adım üçüncü bir tarafın yaptığı, sonra fiziksel olarak iki tarafa dağıttığı bir sürece karşılık gelir.

Birinci qc.barrier() "Bell çifti hazır, mesaj kodlamasına geçiyoruz" görsel ayracı. Aynı zamanda transpiler'ın kodlama kapılarını Bell hazırlık kapılarıyla karıştırmasını engeller — Pauli kapılarının yerini değiştirmesi sonucu tamamen bozar.

if message == "00": pass "Hiçbir şey yapma" da bilinçli bir kuantum işlemidir. $I$ kapısı bir kübite uygulanması gereken yasal bir matematiksel operasyondur; sonucu değiştirmez ama protokol sözlüğünde "$00$" mesajına karşılık gelir. Sistem $\ket{\Phi^+}$ olarak kalır.

qc.x(0) ve qc.z(0) Alice'in tüm yetenekleri sadece kendi kübiti üzerinde Pauli kapıları; iki kübitlik bir kapıya ihtiyaç duymadığı için protokol fiziksel olarak son derece "ucuzdur". Bell çifti hazırlığı pahalı, ama kodlama anı mininaldir.

"11" dalı: qc.z(0); qc.x(0) Önce $Z$ sonra $X$ uygulanır. Sırayı değiştirirseniz devre yine çalışır ama küresel bir faz farkı kalır; ölçüm istatistiği aynı çıkar (genel faz gözlemlenemezdir). Yine de bilinçli sıralama, kodu okuyan herkesin protokolü doğru anlamasına yardım eder.

İkinci qc.barrier() "Alice kübitini Bob'a gönderdi" sahnesinin sınırı. Pratik bir simülasyonda bu satır görünmüyor olabilir, ama mantıksal olarak orada; gerçek bir laboratuvarda fiziksel bir transferin (foton uçuşu vs.) tam yeri.

qc.cx(0, 1) + qc.h(0) Bob'un Bell-baz ölçümü. Bell çifti hazırlığının tersi kapı sırası uygulanır: önce CNOT, sonra Hadamard. Bu kombinasyon dört Bell durumunu klasik dört bitlik etikete (00, 01, 10, 11) eşler. Tek bir standart Z-baz ölçümü artık yeterlidir.

qc.measure([0, 1], [0, 1]) İki kübit klasik bitlere yazılır. İdeal simülatörde sonuç her atışta Alice'in mesajıyla bire bir aynıdır; histogramda yalnızca tek bir sütun (mesajla aynı) yükselir. Bu, klasik bir gönderim/alım kanalında görmeyi beklediğimiz davranış ama gönderici tarafta tek bir kübit harcadık.

Çalıştırma için tek bir Python ortamında qiskit ve qiskit-aer paketleri 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; süper yoğun kodlama, dolanıklık ve Bell-baz ölçümünün birlikte çalıştığı bir "uçtan uca" testtir, donanım sadakat ölçütü olarak da kullanılabilir.

Aşağıdaki şema "11" mesajının süper yoğun kodlamasını uçtan uca görselleştirir. Sol uçta Bell çifti hazırlığı; ortada Alice'in $Z$ ve $X$ kodlaması (kesikli mor çizgi Alice → Bob fiziksel taşımayı simgeler); sağ tarafta Bob'un Bell-baz ölçümü (CNOT + H) ve son ölçüm.