Nasıl kuantum devre diyagramlarını QDK ile görselleştirebilirim?

Kuantum devresi diyagramları, kuantum algoritmalarının görsel bir gösterimidir. Devre diyagramları, programın kubitler için geçerli olduğu geçitler ve ölçümler de dahil olmak üzere kuantum programı aracılığıyla kubit akışını gösterir.

Bu makalede, (Microsoft Quantum Development Kit) ve QDKkullanarak Visual Studio Code (VS Code) ile Jupyter Notebook Q# ve OpenQASM programları için devre diyagramları oluşturmayı öğreneceksiniz.

Kuantum devresi diyagramları hakkında daha fazla bilgi için bkz . Kuantum devresi diyagramı kuralları.

Önkoşullar

Q# ve OpenQASM dosyalarından devre diyagramları oluşturmak için VS Code içinde aşağıdakileri yükleyin:

VS Code uygulamasının en son sürümü veya Web için VS Code açın.
QDK içinde en son sürümü.

içinde Jupyter NotebookPython programlarından devre diyagramları oluşturmak için aşağıdakileri yükleyin:

Python uzantısı ve Jupyter uzantısıVS Code içindeki.
jupyter eklentisine sahip qdk Python paketinin en son sürümü.
```
pip install --upgrade "qdk[jupyter]"
```

içinde kuantum devrelerini görselleştirme VS Code

uzantısıyla QDKVS CodeQ# () ve OpenQASM (.qs.qasm) dosyaları için devre diyagramları oluşturabilirsiniz.

'de VS Codebir devre diyagramı görüntülemek için şu adımları izleyin:

içinde VS Codebir Q# veya OpenQASM dosyası açın ya da içindeki kuantum örneklerinden QDKbirini yükleyin.
Programınızın önündeki kod merceğinden Devre komutunu seçin.

DevreQDK penceresi açılır ve programınızın devre diyagramını görüntüler. Örneğin, aşağıdaki devre diyagramı rastgele bit üreten bir programa karşılık gelir. Devre, kubiti süper konum durumuna getirir ve ardından kubiti ölçer.

QDK Rastgele bir bit programı için devre diyagramını gösteren Devre penceresinin ekran görüntüsü.

Tavsiye

Devre öğesini oluşturan kodu vurgulamak için devre diyagramında bir öğe seçin.

Tek tek Q# işlemleri için devre diyagramlarını görüntüleme

Q# dosyasındaki tek bir işlemin kuantum devresini görselleştirmek için, işlemden önceki kod merceğinden Devre komutunu seçin.

Visual Studio Code Bir Q# programında tek bir Q# işleminin devresini görselleştirmeyi gösteren ekran görüntüsü.

Hata ayıklarken devre diyagramlarını görüntüleme

Bir Q# programında hata ayıklayıcısını VS Code kullandığınızda, kuantum devresini geçerli hata ayıklayıcı kesme noktasındaki programın durumuna göre görselleştirebilirsiniz.

Giriş noktası işleminizden önceki kod merceğinden Hata Ayıkla komutunu seçin.
Çalıştır ve Hata Ayıkla bölmesinde Kuantum Devresi açılır listesini DEĞİŞKENLER menüsünde genişletin. DevreQDK paneli açılır ve program boyunca ilerlerken devreyi gösterir.
Programınız çalışırken devrenin nasıl güncellendiğini görmek için kesme noktaları ayarlayın ve kodunuzda adım adım ilerleyin.

içinde kuantum devrelerini görselleştirme Jupyter Notebook

Jupyter Notebook'de, qdk.qsharp ve qdk.widgets Python modülleri ile Q# ve OpenQASM programları için kuantum devrelerini görselleştirebilirsiniz. Modül, widgets kuantum devresi diyagramını SVG görüntüsü olarak işleyen bir pencere öğesi sağlar.

'de Jupyter Notebookdevre diyagramı oluşturma hakkında daha fazla örnek için GitHub deposundaki QDK bakın.

Q# programları için devre diyagramlarını görüntüleme

içinde Jupyter Notebookbir Q# programının devre diyagramını görüntülemek için şu adımları izleyin:

içinde VS CodeGörünüm menüsünü açın ve Komut Paleti'ni seçin.
Oluştur: Yeni Jupyter Notebook'yi girin. Yeni bir sekmede boş Jupyter Notebook bir dosya açılır.
Not defterindeki ilk hücrede qdk.qsharp modülünü içe aktarın.
```
from qdk import qsharp
```

Yeni bir hücre oluşturun ve Q# kodunuzu girin. Örneğin, aşağıdaki kod bir Bell Durumu hazırlar.

%%qsharp

// Prepare a Bell State.
operation BellState() : Unit {
    use register = Qubit[2];
    H(register[0]);
    CNOT(register[0], register[1]);
}

Kuantum devresi diyagramını görüntülemek için Q# işlemini qsharp.circuit fonksiyonuna geçirin. Aşağıdaki kodu yeni bir hücrede çalıştırın:
```
qsharp.circuit("BellState()")
```
Çıkış şuna benzer:
```
q_0    ── H ──── ● ──
q_1    ───────── X ──
```
Kuantum devresinin SVG görüntüsünü işlemek için modülünü widgets kullanın. Yeni bir hücre oluşturun, ardından aşağıdaki kodu çalıştırarak önceki hücrede oluşturduğunuz bağlantı hattını görselleştirin.
```
from qdk.widgets import Circuit

Circuit(qsharp.circuit("BellState()"))
```
Devre diyagramı şöyle görünür:

Kubitleri giriş olarak kullanan işlemler için devre diyagramlarını görüntüleme

Önceki Bell durumu örneğinde işlem BellState, kubitleri giriş olarak almaz. İşlem kubitleri veya kubit dizilerini giriş olarak alıyorsa, devre diyagramları çizmek için işlemi geçirirken parantezleri atlayın.

Örneğin, kubitleri alan bir işlem için devre diyagramları çizmek için şu adımları izleyin:

Yeni bir hücrede aşağıdaki Q# kodunu çalıştırın. Bu kod, kuantum fiziğinde "kedi durumu" (cat state) hazırlar.

%%qsharp

operation PrepareCatState(register : Qubit[]) : Unit {
    H(register[0]);
    ApplyToEach(CNOT(register[0], _), register[1...]);
}

Devreyi metin diyagramı olarak çizmek için aşağıdaki kodu çalıştırın:
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```
Devre diyagramını SVG görüntüsü olarak işlemek için aşağıdaki kodu çalıştırın:
```
Circuit(qsharp.circuit(operation="PrepareCatState"))
```

İşlem bir kubit (Qubit[])dizisi aldığında, devre diziyi iki kubitin bir yazmaç olarak gösterir.

OpenQASM programları için devre diyagramlarını görüntüleme

Bir OpenQASM programının Jupyter Notebook devre diyagramını görüntülemek için şu adımları izleyin:

içinde VS CodeGörünüm menüsünü açın ve Komut Paleti'ni seçin.
Oluştur: Yeni Jupyter Notebook'yi girin. Yeni bir sekmede boş Jupyter Notebook bir dosya açılır.
Not defterinin ilk hücresinde, Python paketiyle QDK OpenQASM işlevlerini oluşturmak ve çağırmak için gerekli nesneleri içeri aktarmak için aşağıdaki kodu çalıştırın:
```
from qdk.openqasm import import_openqasm, ProgramType
```
Yeni bir hücrede, OpenQASM programınızı bir Python dizesine yazın ve dizeyi işleve import_openqasm geçirin. Python kodunuzda programı çağırmak için fonksiyona bir ad verin ve program_type öğesini ProgramType.File olarak ayarlayın.
```
source = """
    include "stdgates.inc";
    bit[2] c;
    qubit[2] q;
    h q[0];
    cx q[0], q[1];
    c = measure q;
"""

import_openqasm(source, name="bell", program_type=ProgramType.File)
```
Yeni bir hücrede OpenQASM programını Python işlevi olarak içeri aktarın ve ölçü sonuçlarını almak için programı çağırın.
```
from qdk.code.qasm_import import bell

bell()
```

Devreyi metin diyagramı olarak çizmek için aşağıdaki kodu yeni bir hücrede çalıştırın:

from qdk.qsharp import circuit

circuit(bell)

Çıkış şuna benzer:

q_0    ── H ──── ● ──── M ──
             │      ╘═══
q_1    ───────── X ──── M ──
                    ╘═══

Devre diyagramını SVG görüntüsü olarak işlemek için aşağıdaki kodu yeni bir hücrede çalıştırın:
```
from qdk.widgets import Circuit

Circuit(qsharp.circuit(bell))
```
Devre diyagramı şöyle görünür:

Uyarı

OpenQASM programları için tek tek işlevler için devre diyagramlarını görüntüleyemezsiniz. Devre diyagramlarını yalnızca programın tamamı için görüntüleyebilirsiniz.

Geri Bildirim

Bu sayfayı yararlı buldunuz mu?

Last updated on 2026-06-22