Kuantum hata düzeltme — Mantıksal Bilgi · Fiziksel Yedek · Geri Bildirim

QEC’nin hedefi şudur: tek tek fiziksel kübitler kusurlu olsa bile bir mantıksal kübit olarak kodlanmış bilgiyi — süperpozisyon ve faz ilişkisi dahil — güvenilir biçimde yaşatmak; bunun bedeli ek fiziksel kübitler, ölçüm (çoğu zaman yardımcı hatlar) ve klasik işlemciden gelen geri bildirimdir. Öğretim örneği olarak seçilen üç kübitlik bit çevirme yapısı bu dramanın “kısılmış sahnesi”dir; endüstri vizyonundaki yüzey kodları veya gömülü döngüler ise çok daha yüksek çözünürlük ve bağlantı tasarımı ister. Fakat üç düzen de aynı cümleyi paylaşır: mantıksal bilgi, rastgele bir fiziksel kuşağın içinde çözülmez duracak şekilde düşük boyutlu ama koruyucu bir alt uzaya gömülür.

Bu sorun kübitleri susturmak mı?

Hayır; önce sorunun doğası başkadır. Kuantum evrim ünite iken donanım hatası bu süreyi kesikli kılar — sürekli zaman yerine kanıtlanmış CPTP adımlar kümesi düşünürüz. Hesaplama ilerledikçe küçük sapmalar birikir; algoritma yazmak için kullandığımız mantıksal kübit soyutu ise ancak kod katmanıyla bu sapmalardan “arındırılmış” bir değişken gibi davranabilir. QEC’nin işi tek tek transmon veya iyonun kusursuz olmasından çok, bu soyut değişkenin tanımını donanımın kusurları üzerinde yeniden kurmaktır.

Klasik “aynı dosyayı üç kez yaz” sezgisi neden yetmez?

Bilinmeyen bir kuantum durumunu bağımsız üç nüsha çıkaramazsınız — bu klonlama teoremi ile çelişir. Dolayısıyla dayanıklılık, klasik tekrarın kelimesi kelimesine kopyası değildir; yapılması gereken şey, bilgiyi deterministik bir çoğaltma ile değil, ünite bir kodlama ile çok kübitlik Hilbert uzayında seçilmiş bir alt uzaya yaymaktır. Bu alt uzayın içindeki iki farklı kod kelimesi birbirinden “yeterince uzak” olduğunda, belirli küçük Pauli müdahaleleri bir kod kelimesinden diğerine sıçramadan önce yakalanabilir; yakalanmanın aracı da doğrudan veriyi çökertmeden okunan sendrom etiketidir (somut tablo ve devre adımları bit-flip örneğinde).

“Parlak yüzey” metaforunu matematikle kısaca hizala

Kod uzayı bir projektörün görüntüsü gibidir: korunan mantıksal durumlar belirli yapısal denklemleri (+1 özdeğeri veren Pauli gözlemleri / stabilizer dili) otomatik olarak sağlar; kanalın ürettiği düşük ağırlıklı Pauli hataları ise bu denklemleri kaçıran bir “iz” bırakır. Ölçüm bu izi klasik bir bit desenine döker; klasik kontrol hangi telafi kapısının mantıklı olduğuna karar verir. Böylece üçgen tamamlanır: kodlama → sendrom → düzeltme — gerçek dünyada stabilizer turunun her adımı da kendi gürültüsünü taşıdığı için 6 · Hata toleransı ve eşik başlığı devreye girer.

“Tam sessizlik” mümkün mü?

Yine hayır — ölçüm ve kapılar zaten kuantum bilgisini yeniden dağıtır; çevre ile etkileşim ise sürekli bir kanal hayaliyle modellenir. QEC bu yüzden “sıfır gürültü” vaadi değildir; olasılıksal olarak yürütülen bir hesaplamanın güvenilirliğini polinom fazına sığdırmayı ve pratikte bir p bandının altında mantıksal hata oranını baskılamayı hedefleyen mühendislik katmanıdır.

Bir işlemcide gördüğünüz çizgiler çoğu zaman fiziksel kübitlerdir: gerçek osilatörler, tuzaklar veya kuantum noktaları üzerinde taşınan taşıyıcılara karşılık gelen kayıtlar. Aynı çizimi okuyan algoritma metni ise çoğu kez daha üst bir soyutlamada yazar — “bir mantıksal kübit üzerinde H uygula” cümlesi, hatasız dünyada tek bir iki boyutlu faktörü çağrıştırır. QEC devreye girdiğinde bu iki dil bilinçlice ayrılır: mantıksal kübit, korumayı tanımlayan kod tarafından seçilen çok kübitlik bir alt uzaya gömülmüş iki boyutluklu bir serbestlik derecesidir; fiziksel kübitler ise o gömülünün taşıyıcısıdır.

Üç katmanlı okuma (algoritma ↔ mantıksal ↔ fiziksel)

Üst katmanda algoritma yazarı “mantıksal işlem” düşünür — örneğin bir mantıksal kapının ünite olduğu ideal tablo. Orta katmanda QEC kodu, her mantıksal durumu seçilmiş fiziksel bir ket ile eşler; alt katmanda ise çip bağlantısı ve transpiler bu ketleri gerçek kapı grafiklerine yayar. Bir kaynak karışıklığı şudur: çizimde görünen fiziksel kübit sayısı doğrudan “bilgi biti sayısı” vermez; çünkü alt uzayın boyutu ve kodun parametreleri ([[n,k,d]] gösterimi bunun kısa adıdır — burada yalnızca şunu not edin: n taşıyıcı, k mantıksal derece ve d mesafe bir tasarım üçlüsü oluşturur; nicel çerçeve 5 · Kod mesafesi bölümünde toparlanır.

Kodlama haritası E ve süperpozisyon

Kodlama haritası E, mantıksal Hilbert uzayından fiziksel uzaya doğrusal bir gömülmedir ve ünite seçilir; bu yüzden süperpozisyon korunur: E(α|ψ⟩ + β|φ⟩) = α E(|ψ⟩) + β E(|φ⟩). Özetle “mantıksal olarak süperpoze” olan şey, fiziksel tarafta tek bir ket içinde birlikte durur — klasik anlamda iki ayrı diziyi üst üste bindirmek değildir. Küçük Pauli hataları bu fiziksel ket üzerinde yerel olarak işler; hangi hatanın “hangi sendroma düştüğünü” okuma işi ise kodun stabilizer düzenine bağlıdır (4 · Stabilizer düşüncesi).

Mantıksal kapı ile fiziksel devre farkı

Mantıksal dünyada yazdığınız bir kapı, fiziksel dünyada çoğu zaman bir gadget olarak gerçekleştirilir: birden çok fiziksel kapı, ölçüm ve (çoğu mimaride) klasik geri bildirim içeren uzun bir mikro program olabilir. Fault-tolerant rejimde bu gadget’ların kendi içinde kontrollü hataları vardır; üretim tasarımı bunları da kitaba yazmak zorundadır — burada yalnız şunu sabitleyin: mantıksal kübit “tek çizgi” olarak çizilse bile, altında çok hatlı bir protokol vardır.

Ölçümü doğru yere koymak

Kodlu bilgiyi doğrudan mantıksal Z_L veya X_L ekseninde ölçmek genelde hesap bilgisini sıçratır; çünkü bu gözlemler kod uzayını parçalar. Sendrom ölçümü ise kod uzayının yapısıyla uyumlu, bilgi taşıyan alt uzayı mümkün olduğunca koruyacak şekilde kurgulanır — işaret ettiği şey “hangi fiziksel hata sektöründeyiz?” sorusudur, “mantıksal klasik sonuç nedir?” sorusu değildir. Somut devre kalıpları yine bit-flip örneğinde toplanmıştır; burada yalnızca rol ayrımını net tutuyoruz.

Süperpozisyon hâlâ tek mantıksal kübittir

Mantıksal kübit α|0⟩_L + β|1⟩_L ise kodlu fiziksel durum uzun bir ket olabilir; korunan nesne yine tek bir ikilik kuantum derecesidir. Bu yüzden “çok fiziksel kübit kullanıyorum; demek ki çok kübitlik bir süper bilgisayarım var” çıkarımı yanıltıcıdır — önemli olan kodun güvenilir şekilde kaç mantıksal kübit sunduğudur; fazladan taşıyıcılar çoğu zaman yedek ve tanı için harcanmış kapasitedir.

Kapılar bir süre evrim üretir; donanım ise bunun üstüne olasılıksal karışımlar ekler. Öğretim metinleri sık sık Pauli tabanında düşünür: bir adımda kimliğin yanında küçük bir X, Y veya Z bileşeni ortaya çıkmış olabilir. Aer’de ise bu fikir doğrudan kapı listelerine bağlanabilir — önemli ayrıntı şudur: tek kübitlik bir hata modelini iki kübitlik bir kapıya yapıştırmak genelde yanlıştır; kapının arity’sine uygun kanal seçmelisiniz.

Somut örneğe köprü

Bit çevirme kanalına karşı tekrar kodunun tam tablosu ve Qiskit boru hattı adım adım bit-flip örneğinde anlatılır; burada kanalı yalnızca genel çerçeve olarak işaretliyoruz ki Pauli dilinden sapmadan ilerleyebilesiniz.

Stabilizer formalizmi, kod uzayını tek tek ketleri elle yazmak yerine Pauli gözlemleriyle tanımlamanın dilidir: seçilen bir küme çok kübitlik Pauli operatörü birbirleriyle komüt eder ([g_i, g_j] = 0) olacak şekilde seçilir ve kod uzayı, bu gözlemlerin hepsinin +1 öz uzaylarının kesişimi olarak düşünülür. Bu gözlemlerin çoğaldığı Abel alt grup — stabilizer grubu — kodun “hangi yapısal denklemleri koruduğunu” kodlar; ölçüm sonunda gelen klasik etiket ise sendrom adını alır: hangi denklemlerin kaçırıldığını söyler, düşük ağırlıklı Pauli hataları genelde bu etiketi tek tek bitleri çevirerek değiştirir ve klasik mantık hangi telafi Pauli’sinin uygun olduğunu seçer.

Kod uzayı = ortak +1 kabuğu

Sezgiyi şöyle sürdürebilirsiniz: her stabilizer gözlemi, fiziksel Hilbert uzayını iki yarımıza bölen bir ikilik sorudur — ancak soru, kodlanmış mantıksal bilgiyle çelişmeyecek şekilde seçilir (2 · Fiziksel ve mantıksal kübit bölümündeki ölçüm ayrımına geri dönün). Kod uzayındaki durumlar bu soruların tamamına “evet” (+1) yanıtı verir; kanalın eklediği küçük Pauli müdahalesi ise bazı soruların yanıtını “hayır” (−1) tarafına iter — işte bu işaret deseni sendromdur. Çok generator seçildiğinde desen uzar; bağımsız generator sayısı kadar klasik bit üretilebilir ve bu bitler hatanın hangi “sektöründe” olduğunuzu etiketlemeye yarar.

Hata ile stabilizer nasıl konuşur?

Bir Pauli hatası E, bazı stabilizer gözlemleriyle değişmeli ({E,S}=0), bazılarıyla uyumlu ([E,S]=0) olabilir — grup dilinde bu, E’nin hangi generatorlerin ölçüm sonucunu çevirdiğini belirler. İki farklı hata aynı sendroma düşerse ayırt edilemezler; kodun mesafesi tam da “hangi hataların hangi desenlerde karıştığı” geometrisini özetler. Bu yüzden stabilizer görmek yalnızca cebir değil; aynı zamanda “hangi parmak izleri ayrışır?” sorusudur.

Clifford çizimi ve Qiskit dünyası

Pauli stabilizer ölçümleri ve bunları hazırlayan yardımcı devreler Clifford ailesindedir; bu aile hem öğretim simülasyonlarında hem de yüzey kodu protokollerinin iskeletinde sık görülür. Qiskit’te stabilizer tabanlı bir düzeni okurken kapı listesi görünürde basit olsa bile arkadaki mantık şudur: hangi Pauli’nin hangi yardımcı hatta ölçüldüğü ve çıkan klasik dizinin hangi Pauli düzeltmesini tetiklediği — somut bir tablo ve çizim için yine bit-flip örneğine başvurabilirsiniz.

Burada tablo yok; mantıksal iskelet var

Üç kübitlik yapıda iki bağımsız stabilizer ölçümünün dört klasik sonuca düşmesi ve her birinin bir tek-X senaryosunu nasıl etiketlediği rakamlarıyla sendrom bölümünde yazılıdır. Bu sayfada amaç tabloyu kopyalamak değil; yüzey kodu veya daha büyük kodlara geçtiğinizde aynı “generator → ölçüm → etiket → düzeltme” akışının ölçeklendiğini görebilmektir — kelime değişir, iskelet kalır.

Kod mesafesi d, kod uzayı için seçilmiş iki ortonormal kod durumu düşünüldüğünde, birini diğerine götüren en düşük Pauli ağırlıklı operasyonun boyutu olarak özeti çıkarılır — klasik blok kodlarda iki kod kelimesi arasındaki Hamming mesafesi düşüncesinin kuantum karşılığıdır (tam tanım projektörler ve Pauli grubunun metriği ile yazılır; burada geometrik sezgi yeter). Bu sayı büyüdükçe küçük hataların birbirine ve doğru çözüme karışması zorlaşır; stabilizer dilinde hangi Pauli hatalarının hangi sendromları ürettiği §4 ile bağlantılıdır.

Pauli ağırlığı neyi sayar?

Çok kübitlik bir Pauli operatörü, her kübitte ya kimlik ya da X, Y, Z’den biri olarak yazar. Ağırlık, kimlik olmayan faktörlerin sayısıdır — örneğin üç kübitte yalnız ikincide X varsa ağırlık birdir; iki kübitte eşzamanlı X varsa iki olur. Kanal gerçek hayatta sürekli olsa da tasarım ve analiz sırasında düşük ağırlıklı Pauliler ana oyuncular olarak seçilir; mesafe bu oyuncuların kod kelimelerini ne kadar “ayırdığına” dair bir özet rakamdır.

Niçin t = ⌊(d − 1) / 2⌋?

Tek düşük-ağırlıklı hatayı düzelten düzenleri düşünün: yanlış Pauli tahmini doğru telafi ile iki katı hata üretir — çünkü uygulanmaması gereken bir kapı uygulanmış olur. Bu yüzden başarılı sınıflandırma için “hangi hatanın olduğunu” eşsiz söyleyebilmek gerekir; iki farklı t ağırlıklı hata senaryosu aynı sendroma düşerse ayırt edilemezler. Kabaca geometrik özet şudur: her kod kelimesi etrafında yarıçapı t olan Pauli “topları” birbirini kesmedikleri sürece çözüm tek kalır; bunun gerektirdiği ölçek ilişkisi giriş seviyesinde ezber olarak t = ⌊(d − 1) / 2⌋ ile yazılır (ayırt edici bağlantılar ve dejenere kodlar için daha ince sınırlar vardır; üretim metinde güçlendirilir).

Tespit ve düzeltme

Bazı kodlar için d − 1 ağırlığına kadar olan bazı hataları fark etmek mümkün olabilir; otomatik düzeltme ise genelde daha sıkı bir oyundur çünkü yanlış Pauli seçimi mantıksal bilgiyi taşıyan alt uzayı doğrudan zedeler. Öğretim amacıyla: mesafe “ne kadar dayanıklı?” sorusunun ilk rakamsal cevabıdır; pratikte derinlik eklemeniz ve gerçek fiziksel hatanın Pauli modelinden sapması tasarımı yeniden şekillendirir (6 · Eşik).

[[n,k,d]] ile ilişki

Özet parametre üçlüsü birbirini sıkıştırır: n taşıyıcı kübit, k mantıksal kübit ve d mesafe — daha fazla hata düzeltmek genelde daha fazla n ister; sürdürülebilir bir kuantum bilgisayar vizyonunda “aynı kalitede daha fazla mantıksal kübit” demek çoğu zaman bu üçgenin planlı mühendisliğidir (2 · Fiziksel ve mantıksal kübit).

Öğretim kodlarıyla ilişki

Üç kübitlik bit çevirme kodunda tek-X hataları için mesafe üç kabul edilir ve klasik senaryoda tek bir böyle hata güvenilir biçimde düzeltilir; iki veya daha fazla birlikte X aynı sendroma çökerek karışabilir — bu yüzden kod “tek hataya göre” anlatılır. Kod klasik bilginin iki baz durumu için faz bileşenlerini tam kodlamadığından saf Z (faz çevirme) hatalarına karşı koruma vaadi taşımaz; böyle bir kanalı görmek istiyorsanız birliktelik (X ve Z) düşünülmelidir. Bu sınırlılık kasıtlıdır — üç kübitlik yapı bir harita gibidir, pusula değildir. Rakamlı tablo ve okuma düzeni bit-flip sayfasında durur.

Öğretim diyagramlarında stabilizer ölçümü bazen “temiz bir klasik etiket üretir” gibi okunur; gerçek işlemcide ise ölçüm akışını oluşturan her fiziksel kapı ve bekletme adımı kendi hatasını taşır. Fault-tolerant (hataya dayanıklı) tasarımın özü şudur: kod uzayı düşüncesini (§5) korurken, stabilizer turunun kendisinin ürettiği ek müdahaleleri kontrollü tutmak — böylece tur tur mantıksal bilgi birikimli olarak bozulmasın. Bu denge için kritik bir ölçek sabiti eşik (p_th) olarak özetlenir: fiziksel hata oranı p bu değerin üzerindeyse, ek düzeltme katmanı eklemek mantıksal hatayı küçültmek yerine çoğaltabilir; altına indiğinizde ise uzun ölçekte iyileşme umudu (tasarıma bağlı biçimde) ortaya çıkar.

Gürültülü gadget’lar ve “temiz sendrom” illüzyonu

Bir stabilizer ölçümü pratikte Clifford gadget’larından oluşur; bunların içinde iki kübitlik kapılar, ölçüm ve klasik geri bildirim vardır (§2). Öğretim dosyasında tek satırlık ölçüm blokları görürsünüz; üretim dosyasında ise aynı bloğun fiziksel süresi ve hata bütçesi açılır. Sonuç: sendrom bitleri hem gerçek kanaldan hem ölçüm zincirinden beslenir — “hangi Pauli oldu?” sorusunu klasik taraf doğru etiketlemeyebilir. Bu yüzden toleranslı protokoller sıklıkla ölçümü tekrarlar, zaman içinde kararları çoğunluğa veya daha gelişkin çıkarıma bağlar ya da yüzey kodunda olduğu gibi yerel kurallarla hataları sınırlamayı hedefler.

Mantıksal hata oranına doğru ölçekleme

Amaç fiziksel p’yi sıfırlamak değil; mantıksal hata oranı P_L’nin sistem boyutu ve kod mesafesi ile nasıl değiştiğini kontrol etmektir. Eşik altında olduğunuzu düşündüğünüz rejimde, iyi tasarlanmış bir düzen için “mesafe büyüdükçe P_L baskılanır” sezgisi kurulur — bunun katsayıları kod ailesine ve hatanın fiziksel modeline göre değişir; rakamları tek bir tabloda toplamak yanıltıcıdır. Eşik üstünde ise tam tersine çoğu kez “daha büyük sistem daha kötü” görülür: düzeltme makinesi kendi gürültüsünü ekleyerek işi büyütür.

Nicel p_th tablosunu burada tutmuyoruz

Eşikler kod grafı, kapı seti, ölçüm zamanlaması ve hata modelinin bir fonksiyonudur; yüzey kodu, renk kodları veya gömülü döngüler birbirinden farklı düzlemlerde tartışılır. Bu yüzden burada tek bir “şu kadar yüzde” rakamı vermiyoruz — güncel makale ve donanım raporu şarttır. Sabitlemeniz gereken ana mesafe şudur: p_th, kod seçiminden bağımsız bir evrensel sabit değildir; “iyi görünen küçük bir devre” ile “ölçeklenebilir FT düzeni” aynı şey değildir.

Simülatör ile gerçek makine arasındaki uçurum

Aer tabanlı örnekler (§7) kanalı kontrollü keser ve çoğu zaman gerçek zamanlama, sıcaklık dalgalanması ve okuma çapraz konuşması gibi etkileri görmezden gelir. Simülatörde düzgün bir histogram görmek, donanımda otomatik olarak “toleranslı hesaplama” anlamına gelmez — transpile katmanı, bağlantısı kısıtlı grafik ve gerçek ölçüm hatası eklenince p sabiti bir metafor haline gelir. QEC’nin ayrı uzmanlık alanı olmasının nedeni budur: soyut kod uzayı ile fabrika çıkışlı işlemci arasında uzun bir mühendislik kolu vardır.

NoiseModel, seçilen kapılara CPTP hataları bağlar; AerSimulator(noise_model=…) transpile edilmiş devreyi bu kanalla yeniden örnekler. Öğretim için sık yapılan hata: tek kübitlik pauli_error çıktısını iki kübitlik cx hattına doğrudan yazmak — Aer bunu reddeder ya da yanlış yorumlar; ya tek kübit kapıları seçin ya da iki kübitlik bir kanal tanımlayın (örneğin iki kübitlik depolarizasyon).

Bu örnek neden tam bir QEC döngüsü değil?

Aşağıdaki betik yalnızca “kanalı devreye ekleyip histogramın nasıl kaydığını” gösterir; encoder + stabilizer ölçümü + klasik geri bildirim üçlüsünün somut hali bit-flip sayfasındadır. İkisini üst üste koyduğunuzda zihinde tam resim oluşur.

Hadamard ve ardından CNOT ile Bell hazırlığı yapılır; gürültü yalnızca h kapılarına küçük bir X sızdırması ekler. Ölçümde ideal durum 00 ve 11 üzerinde yoğunlaşır; kanal simetrik bozduğunda histogram dengesizleşir — deney düzeninizi p_x ve shots ile oynayarak gözlemleyin.

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, pauli_error

# Tek kübitlik Pauli hatasını yalnızca H kapılarına bağlıyoruz.
# CX iki kübitliktir; burada bilerek dokunmuyoruz (arity uyumu).
p_x = 0.08
noise_op = pauli_error([("X", p_x), ("I", 1 - p_x)])

noise_model = NoiseModel()
noise_model.add_all_qubit_quantum_error(noise_op, ["h"])

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

backend = AerSimulator(noise_model=noise_model)
tc = transpile(qc, backend)
counts = backend.run(tc, shots=4096, seed_simulator=11).result().get_counts()

print(noise_model)
print("Ölçüm histogramı:", dict(sorted(counts.items(), key=lambda kv: -kv[1])))

# Karşı deney: aynı devre için AerSimulator() (noise_model=None) ile çalıştırıp
# 00/11 yoğunluğunu bu çıktıyla kıyaslayın; tam Bell doğruluğu arıyorsanız fark burada okunur.

Bu bölüm §8’deki betiği satır öbekleri halinde okutur: önce veri yapıları ve Aer’ın gürültüyü nereye iliştirdiği, sonra çalışma zamanı parametreleri ve histogram yorumu. Amaç tek bir “doğru çıktı” ezberletmek değil; aynı iskelet üzerinde hangi çubuğu oynattığınızda sonucun nasıl kaydığını kendiniz tartmak.

İthalatlar ve devre iskeleti

QuantumCircuit iki kübitlik bir kayıt kurar; h(0) ardından cx(0, 1) ideal tabanda Bell çiftini hazırlar. measure_all() hem kuantum çizgileri ölçümle sonlandırır hem klasik sonuç kablolarını ayırır — Aer sonrasında histogram bu klasik dizgiler üzerinden gelir. Şimdilik ölçüm hatası modellemiyoruz; eklemek isterseniz ayrı bir QuantumError ile ölçüm satırlarına da kanal bağlanabilir (bu sayfa giriş düzeyinde kapı gürültüsünde kalır).

pauli_error

Liste biçimi [(Pauli, olasılık), …] olasılıkların toplamının bir olması beklenir; burada X ile I tamamlayıcıdır. Küçük p_x ile kimlik çoğunlukta kalır; ara sıra gelen X ise tek kübitlik kanalı CPTP olarak Aer’a yerleşir. Hatayı “Hadamard öncesi mi sonrası mı?” diye ayırmaya çalışmayın — Aer modelinde kanal seçilen kapının yerelleştirilmiş hatası olarak uygulanır; okuma birimi olarak “hangi kapı etiketi × hangi olasılık” ikilisini düşünün.

NoiseModel ve add_all_qubit_quantum_error(..., ["h"])

Boş bir model üzerine hatalar eklenir; böylece aynı nesneye ileride başka kapılar için başka kanallar iliştirmek kolaylaşır. İkinci argüman hangi kapı adlarında hatanın devreye gireceğini seçer — burada yalnız h. İki kübitlik bir kanal için önce iki kübitlik bir CPTP nesnesi üretmeniz gerekir; tek kübitlik pauli_error çıktısını cx üzerine yazmaya çalışmak boyut uyarısına düşer. İsterseniz belirli kübitlere özel kanal için Aer’ın yerel varyantlarına bakın; bu örnek “tüm çizgilerde aynı H gürültüsü” okumasını verir.

transpile(qc, backend)

Simülatör bile olsa seçilen backend’in bildirdiği yerel kapı kümesine göre devre yeniden yazılır. Basit örneklerde derinlik nadiren sürpriz yapar; ancak gürültünün hangi fiziksel kapılara iliştiğini ayırırken transpile çıktısı ile kaynak QuantumCircuit çizimini yan yana koymak iyi alışkanlıktır — özellikle donanım veya kısıtlı bağlantı örneklerinde kapı sayısı şişebilir ve dolaylı gürültü birikir.

run(..., shots, seed_simulator)

shots histogramın çözünürlüğünü belirler; çok düşük seçilirse tek örnek şansına düşersiniz. seed_simulator tekrarlanabilirlik için kullanılır — “aynı kod iki kez çalışınca sayılar değişmeli mi?” sorusunun cevabını kontrol eder. İstatistiksel belirsizlik için kabaca binomial yayılım düşünmek yeter: bin sayısı arttıkça göreceli dalgalanma azalır.

Histogram ve Bell referansı

Gürültüsüz durumda ölçüm çoğu kez yalnız 00 ve 11 gösterir; tek kübitlik X kanalı özellikle h üzerinden süzülünce dengede küçük kaymalar üretebilir, bazı modellerde 01/10 kuyrukları da görülebilir — bunların kökenini anlamak için ikinci kod kutusundaki iki kübitlik kanalı eklemeyi deneyin. Üç kübitlik encoder ve sendrom çıktılarıyla karşılaştırma için bit-flip örneğine geçin.

from qiskit import QuantumCircuit, transpile
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel, pauli_error, depolarizing_error

p_x = 0.08
nm = NoiseModel()
nm.add_all_qubit_quantum_error(pauli_error([("X", p_x), ("I", 1 - p_x)]), ["h"])
nm.add_all_qubit_quantum_error(depolarizing_error(0.03, 2), ["cx"])

qc = QuantumCircuit(2)
qc.h(0)
qc.cx(0, 1)
qc.measure_all()

backend = AerSimulator(noise_model=nm)
counts = backend.run(transpile(qc, backend), shots=8192, seed_simulator=7).result().get_counts()
print("H + CX birlikte:", dict(sorted(counts.items(), key=lambda kv: -kv[1])))

İkinci kutuda ne değişti?

depolarizing_error(p, 2) iki kübitlik Pauli karışımını üretir ve doğrudan cx etiketine yazılabilir — böylece iki kübitlik kapılar için gerekli CPTP boyutu ile tek kübitlik pauli_error çıktısını karıştıran arity tuzakları bertaraf edilir. Çıkan histogramda 01/10 payı genelde belirginleşir; bunun nedeni kanalın hem kontrol hem hedef hattına sirayet etmesidir. İki modeli (yalnız h, sonra birlikte) ayrı çalıştırarak hangi mekanizmanın histogramı ne kadar kaydırdığını sayısallaştırabilirsiniz.

Solda metinsel akış; sağda blok düzeyinde aynı hikâye — tam devre çizimi burada değil, somut kod sayfasında.

  mantıksal |ψ⟩_L
        │
        ▼  kodlama E  ···►  çok kübitlik |Ψ⟩
        │
        ├──► kanal 𝒩  (kapı başına CPTP)
        │
        ▼  stabilizer ölçümü
        │
        └──► klasik sendrom u  ──►  düzeltme kararı

Bu şema §10’daki dörtlü hikâyeyi tek satırda netleştirir: renkler rol değişmez (mor · kodlama, amber · kanal ve ünite evrim, yeşil · stabilizer ölçümü, kırmızı · klasik decode). Üstteki numaralar okuma sırasını sabitler; kesikli eğri ise gerçek makinede çoğu zaman zorunlu olan klasik geri bildirim ipini gösterir — Aer örneğinde bu döngünün tamamını kurmadık; §8–§9 yalnız kanalı gösterir. Aynı blok metinleri ve ok akışı §10 sağ paneldeki SVG ile örtüşür; gradyan kimlikleri yalnızca qec-dual-g / qec-wide-g ayrımı içindir.

Şema okuma reçetesi

1. 1

   Encoder kutusu mantıksal durumu fiziksel taşıyıcılara yayar — soyut E haritası (§2). Çizim tek bloktur; gerçek protokolde burası uzun bir Clifford / ölçüm zinciri olabilir.

2. 2

   Kanal + ünite evrim hem algoritmanın ünite kapılarını hem ortamın CPTP etkisini (𝒩) taşır; donanımda transpile bu katmanın gerçek grafik şeklini belirler (§7, §9).

3. 3

   Stabilizer ölçümü yeşil çerçeve ile vurgulanır: çıkan klasik dizi sendrom u’dur — hangi Pauli sektöründe olduğunuzu etiketler; cebirsel çerçeve §4, ayırt gücü §5.

4. 4

   Decode klasik mantıkta yapılır; seçilen Pauli telafisi kuantum işlemciye geri gönderilir — kesikli eğri bunu simgeler. Ölçümün ve gadget’ların kendi gürültüsü vardır; bu yüzden döngü “temiz çizgi” değildir (§6). Tam devre örneği bit-flip sayfasında.

Bu kartlar sayfanın “arka yüzü”dür: hangi konunun nerede işlendiğini ve bir sonraki okumanızı nasıl seçeceğinizi hatırlatır. Geniş ekranda dörtlü ızgara olarak düzenlenir.

• Çakışma politikası

  Üç kübitlik kod kelimeleri, sendrom–düzeltme tablosu ve tam veri kübiti akışı yalnızca bit-flip sayfasında tutulur; bu dosya ise çerçeve, stabilizer–mesafe–eşik hatları ile Aer tabanlı gürültü modelini taşır. Şema ve çift paneldeki bloklar özet içindir, öğretim devresi karşı sayfadadır.

• Okuma sırası

  Önce §1–§6 ile çatıyı kurun; Aer ve kod analizi için §7–§9’a geçin; boru hattını gözle tasvir etmek için §10 ve §11 şemalarını kullanın. Ardından bit-flip örneğini okuyarak soyuttan somuta inmiş olursunuz.

• Sınırlar

  Fault-tolerant evrensel kapı setleri, magic state damıtımı, yüzey kodları için graf tabanlı dekoder katmanları ve fabrika ölçeğinde kalibrasyon bu girişin kapsamı dışındadır — burada amaç giriş düzeyinde bir harita vermek, üretim QEC müfredatının yerine geçmek değildir.

• Çekirdek bağlantılar

  Özet akış şöyle kenetlenir: stabilizer dili (§4), kod mesafesi ve t ezberi (§5), eşik ve gürültülü ölçüm (§6), Aer modeli ve arity uyumu (§7–§9). Tekrar etmeyen somut tablo için bit-flip sayfasına geçin.