Öğretici: Içinde Quantum Fourier Dönüşümünü Uygulama Q#

Bu öğreticide, tek tek kubitler üzerinde çalışan temel bir kuantum programının nasıl yazıldığını ve simülasyonunu nasıl gerçekleştirdiğiniz gösterilir.

Öncelikle büyük ölçekli kuantum programları için üst düzey bir programlama dili olarak oluşturulmuş olsa Q# da, kuantum programlamanın alt düzeyini, yani belirli kubitleri doğrudan ele almak için de kullanılabilir. Özellikle, bu öğretici birçok büyük kuantum algoritmasının ayrılmaz bir alt parçası olan Quantum Fourier Dönüşümü'ne (QFT) daha yakından bakar.

Bu öğreticide şunların nasıl yapılacağını öğreneceksiniz:

• Visual Studio Code'un en son sürümü veya Vs Code'un Web'de açılması.

• Azure Quantum Development Kit (QDK) uzantısının en son sürümü. Yükleme ayrıntıları için bkz. QDK uzantısını ayarlama.

• Jupyter Notebooks'u kullanmak istiyorsanız Pythonqsharpgerekir. Bunu yapmak için bir terminal açın ve aşağıdaki komutu çalıştırın:

  Bash Kopyala

  $ pip install --upgrade  qsharp
  

1. VS Code'da Dosya > Yeni Metin Dosyası'na tıklayın
2. Dosyayı QFTcircuit.qs olarak kaydedin. Bu dosya, programınızın Q# kodunu içerir.
3. QFTcircuit.qs dosyasını açın.

Bu öğreticinin ilk bölümü, üç kubit üzerinde kuantum Fourier dönüşümünü gerçekleştiren işlemini Q#tanımlamaktırMain. DumpMachine işlevi, üç kubitli sistemin simülasyon dalga işlevinin işlem genelinde nasıl geliştiğini gözlemlemek için kullanılır. Öğreticinin ikinci bölümünde ölçüm işlevselliği ekler ve kubitlerin ölçüm öncesi ve son durumlarını karşılaştırırsınız.

İşlemi adım adım oluşturursunuz. Aşağıdaki bölümlerde yer alan kodu kopyalayıp QFTcircuit.qs dosyasına yapıştırın.

Bu bölümün tam Q# kodunu başvuru olarak görüntüleyebilirsiniz.

Dosyanızın Q# içinde ilgili Microsoft.Quantum.* ad alanlarını içeri aktarın.

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Arrays.*;

// operations go here

Ardından işlemi tanımlayın Main :

operation Main() : Unit {
    // do stuff
}

İşlem Main() hiçbir zaman bağımsız değişken almaz ve şimdilik Python'da C# veya boş bir tanımlama grubu Unitdöndürmeye void benzer bir Tuple[()] nesne döndürür. Daha sonra, bir ölçüm sonuçları dizisi döndürmek için işlemi değiştirirsiniz.

İşlemin içinde Q# anahtar sözcüğüyle use üç kubitin bir kaydını ayırın. ile use, kubitler otomatik olarak $|0⟩$ durumunda ayrılır.

use qs = Qubit[3]; // allocate three qubits

Message("Initial state |000>:");
DumpMachine();

Gerçek kuantum hesaplamalarında olduğu gibi Q# kubit durumlarına doğrudan erişmenize izin vermez. Ancak, DumpMachine işlemi target makinenin geçerli durumunu yazdırır, böylece tam durum simülatörüyle birlikte kullanıldığında hata ayıklama ve öğrenme için değerli içgörüler sağlayabilir.

Ardından, işlemin kendisini oluşturan Main işlemleri uygularsınız. Q# zaten ad alanında Microsoft.Quantum.Intrinsic bunların çoğunu ve diğer temel kuantum işlemlerini içerir.

Uygulanan ilk işlem, ilk kubite (Hadamard) işlemidir H :

Bir yazmaçtan belirli bir kubite işlem uygulamak için (örneğin, bir dizideki Qubittek Qubit[] bir işlem), standart dizin gösterimini kullanın. Bu nedenle, kaydın H ilk kubitine qs işlemi uygulamak şu şekilde olur:

H(qs[0]);

QFT devresi, işlemi tek tek kubitlere uygulamanın H yanı sıra öncelikli olarak kontrollü R1 döndürmelerden oluşur. Genel olarak bir R1(θ, <qubit>) işlem, $|0⟩$ bileşenine $e^{i\theta }$ döndürme uygularken kubitin $|1⟩$ bileşenini değiştirmeden bırakır.

Q# bir işlemin çalışmasını bir veya birden çok denetim kubitine göre koşula bağlamayı kolaylaştırır. Genel olarak, çağrısı ile Controlledbaşlanır ve işlem bağımsız değişkenleri aşağıdaki gibi değişir:

Op(<normal args>) $\to$ Controlled Op([<control qubits>], (<normal args>))

Tek bir kubit için olsa bile denetim kubiti bağımsız değişkeninin bir dizi olması gerektiğini unutmayın.

QFT'deki denetlenen işlemler, ilk kubit üzerinde işlem gerçekleştiren (ve ikinci ve üçüncü kubitler tarafından denetlenen) işlemlerdir R1 :

Dosyanızda Q# bu işlemleri şu deyimlerle çağırarak:

Controlled R1([qs[1]], (PI()/2.0, qs[0]));
Controlled R1([qs[2]], (PI()/4.0, qs[0]));

PI() işlevi, döndürmeleri pi radyan açısından tanımlamak için kullanılır.

İlgili H işlemlerini ve denetimli döndürmeleri ikinci ve üçüncü kubitlere uyguladıktan sonra, devre şöyle görünür:

//second qubit:
H(qs[1]);
Controlled R1([qs[2]], (PI()/2.0, qs[1]));

//third qubit:
H(qs[2]);

Son olarak, devreyi tamamlamak için birinci ve üçüncü kubitlere bir SWAP işlem uygularsınız. Kuantum Fourier dönüşümü kubitleri ters sırada çıkardığından bu işlem gereklidir, bu nedenle değiştirme işlemleri alt düğümün daha büyük algoritmalarla sorunsuz tümleştirilmesine olanak tanır.

SWAP(qs[2], qs[0]);

Şimdi kuantum Fourier dönüşümünün kubit düzeyindeki işlemlerini işleminize yazmayı tamamladınız Q# :

Son adım, işlem sonrası durumunu görmek ve kubitleri serbest bırakmak için yeniden çağırmaktır DumpMachine() . Kubitleri ayırdığınızda $|0⟩$ durumundaydı ve işlemi kullanarak ResetAll ilk durumlarına sıfırlanması gerekiyor.

Tüm kubitlerin açıkça $|0⟩$ olarak sıfırlanması zorunluluğu, diğer işlemlerin Q#aynı kubitleri (kıt kaynak) kullanmaya başladığında durumlarını tam olarak bilmesini sağladığından temel bir özelliğidir. Ayrıca bunları sıfırlamak, sistemdeki diğer kübitlerle dolanık olmamalarını garanti eder. Sıfırlama bir use ayırma bloğunun sonunda gerçekleştirilmezse bir çalışma zamanı hatası ortaya çıkabilir.

Dosyanıza Q# aşağıdaki satırları ekleyin:

Message("After:");
DumpMachine();

ResetAll(qs); // deallocate qubits

Program Q# tamamlandı. QFTcircuit.qs dosyanız şu şekilde görünmelidir:

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Arrays.*;

operation Main() : Unit {

    use qs = Qubit[3]; // allocate three qubits

    Message("Initial state |000>:");
    DumpMachine();

    //QFT:
    //first qubit:
    H(qs[0]);
    Controlled R1([qs[1]], (PI()/2.0, qs[0]));
    Controlled R1([qs[2]], (PI()/4.0, qs[0]));

    //second qubit:
    H(qs[1]);
    Controlled R1([qs[2]], (PI()/2.0, qs[1]));

    //third qubit:
    H(qs[2]);

    SWAP(qs[2], qs[0]);

    Message("After:");
    DumpMachine();

    ResetAll(qs); // deallocate qubits

}                                                                                                                                                                               

Şimdilik işlem Main herhangi bir değer döndürmez, işlem değer döndürür Unit . Daha sonra, işlemi bir ölçüm sonuçları dizisi (Result[]) döndürecek şekilde değiştirirsiniz.

Diğer giriş durumlarının nasıl etkilendiğini merak ediyorsanız, dönüştürmeden önce diğer kubit işlemlerini uygulamayı denemeniz tavsiye edilir.

DumpMachine işlevinden görüntülenen görüntüde işlemin sonuçları gösterilir, ancak ne yazık ki kuantum mekaniğinin bir köşe taşı, gerçek bir kuantum sisteminin böyle bir DumpMachine işlevine sahip olmadığını belirtir. Bunun yerine, bilgiler ölçümler aracılığıyla ayıklanır ve genel olarak tam kuantum durumu hakkında bilgi sağlanmaz, aynı zamanda sistemin kendisini önemli ölçüde değiştirebilir.

Birçok tür kuantum ölçümü vardır, ancak buradaki örnek en temel ölçümlere odaklanır: tek kubitlerdeki yansıtıcı ölçümler. Belirli bir temelde ölçüldükten sonra (örneğin, hesaplama temeli $|0⟩,|1⟩$), kubit durumu ölçülen temel duruma yansıtılır ve bu nedenle ikisi arasındaki süper konum yok edilir.

Bir Q# program içinde ölçümler uygulamak için bir tür döndüren M işlemi kullanınResult.

İlk olarak, işlemi yerine bir ölçü sonuçları MainResult[]dizisi döndürecek şekilde değiştirinUnit.

operation Main() : Result[] {

Kubitleri ayırmadan önce üç öğeli bir dizi (her kubit için bir tane Result ) bildirin ve bağlayın:

mutable resultArray = [Zero, size = 3];

mutable Anahtar sözcük prefacing resultArray değişkeninin kodda daha sonra değiştirilmesini sağlar, örneğin ölçüm sonuçlarınızı eklerken.

QFT dönüştürme işlemlerden sonra aşağıdaki kodu ekleyin:

for i in IndexRange(qs) {
    resultArray w/= i <- M(qs[i]);
}

Bir IndexRange dizide çağrılan işlev (örneğin kubit dizisi), qsdizinin dizinleri üzerinde bir aralık döndürür. Burada, M(qs[i]) deyimini kullanarak her kubiti sıralı olarak ölçmek için for döngüsünde kullanılır. Ölçülen Result her tür ( Zero veya One) bir update-and-reassign deyimiyle içindeki ilgili dizin konumuna resultArray eklenir.

anahtar sözcüğü set her zaman kullanarak mutablebağlı değişkenleri yeniden atamak için kullanılır.

Üç kubitin de ölçülmesi ve sonuçların resultArray'a eklenmesiyle, kubitleri daha önce olduğu gibi sıfırlayabilir ve serbest bırakabilirsiniz. Ölçümleri döndürmek için şunu ekleyin:

return resultArray;

Şimdi işlevlerin yerleşimini DumpMachine değiştirerek ölçümlerden önceki ve sonraki durumu çıkış olarak belirleyin. Son Q# kodunuz şu şekilde görünmelidir:

import Microsoft.Quantum.Diagnostics.*;
import Microsoft.Quantum.Math.*;
import Microsoft.Quantum.Arrays.*;

operation Main() : Result[] {

    mutable resultArray = [Zero, size = 3];

    use qs = Qubit[3];

    //QFT:
    //first qubit:
    H(qs[0]);
    Controlled R1([qs[1]], (PI()/2.0, qs[0]));
    Controlled R1([qs[2]], (PI()/4.0, qs[0]));

    //second qubit:
    H(qs[1]);
    Controlled R1([qs[2]], (PI()/2.0, qs[1]));

    //third qubit:
    H(qs[2]);

    SWAP(qs[2], qs[0]);

    Message("Before measurement: ");
    DumpMachine();

    for i in IndexRange(qs) {
        resultArray w/= i <- M(qs[i]);
    }

    Message("After measurement: ");
    DumpMachine();

    ResetAll(qs);
    Message("Post-QFT measurement results [qubit0, qubit1, qubit2]: ");
    return resultArray;

}

Before measurement: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

After measurement: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |010⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Post-QFT measurement results [qubit0, qubit1, qubit2]: 

[Zero, One, Zero]

Bu çıkış birkaç farklı şeyi gösterir:

1. Ölçüm öncesi DumpMachineile döndürülen sonucu karşılaştırdığınızda, QFT sonrası süperpozisyonun temel durumlar üzerindeki açıkça gösterilmediği görülmektedir. Ölçüm, sistemin dalga işlevindeki bu durumun genliği tarafından belirlenen bir olasılıkla yalnızca tek bir temel durum döndürür.
2. Ölçüm DumpMachinesonrası durumundan ölçümün durumu değiştirdiğini ve bunu temel durumlar üzerinden ilk süper pozisyondan ölçülen değere karşılık gelen tek temel duruma yansıttığını görürsünüz.

Bu işlemi birçok kez tekrarlarsanız, sonuç istatistiklerinin her çekimde rastgele bir sonuca neden olan QFT sonrası durumunun eşit ağırlıklı süper konumunu göstermeye başladığına bakın. Ancak, verimsiz ve hala kusurlu olmasının yanı sıra, bu yine de aralarındaki göreli aşamaları değil, yalnızca temel durumların göreli genliklerini yeniden üretir. İkincisi bu örnekte bir sorun değildir, ancak QFT'ye $|000⟩$ durumundan daha karmaşık bir giriş verildiğinde göreli fazların ortaya çıktığını görürdünüz.

Girişte belirtildiği gibi, 'nin gücünün Q#çoğu, bireysel kubitlerle ilgilenme endişelerini soyutlamanıza olanak sağlaması gerçeğinde durmektedir. Aslında, tam ölçekli, geçerli kuantum programları geliştirmek istiyorsanız, bir işlemin belirli bir H döndürmeden önce mi yoksa sonra mı geçeceği konusunda endişelenmeniz sizi yalnızca yavaşlatır. Azure Quantum, istediğiniz sayıda kubit için kullanabileceğiniz ve uygulayabileceğiniz işlemi sağlar ApplyQFT .

1. İlk H işlemden işleme (dahil) kadar SWAP her şeyi şununla değiştirin:

   Q# Kopyala

   ApplyQFT(qs);
   

2. Kodunuz şimdi şöyle görünmelidir

   Q# Kopyala

   import Microsoft.Quantum.Diagnostics.*;
   import Microsoft.Quantum.Math.*;
   import Microsoft.Quantum.Arrays.*;
   
   operation Main() : Result[] {
   
       mutable resultArray = [Zero, size = 3];
   
       use qs = Qubit[3];
   
       //QFT:
       //first qubit:
   
       ApplyQFT(qs);
   
       Message("Before measurement: ");
       DumpMachine();
   
       for i in IndexRange(qs) {
           resultArray w/= i <- M(qs[i]);
       }
   
       Message("After measurement: ");
       DumpMachine();
   
       ResetAll(qs);
       Message("Post-QFT measurement results [qubit0, qubit1, qubit2]: ");
       return resultArray;
   
   }
   

3. Q# Programı yeniden çalıştırın ve çıkışın öncekiyle aynı olduğuna dikkat edin.

4. İşlemleri kullanmanın Q# gerçek avantajını görmek için kubit sayısını dışında 3bir şeyle değiştirin:

mutable resultArray = [Zero, size = 4];

use qs = Qubit[4];
//...

Böylece, her kubite yeni H işlemler ve döndürmeler ekleme konusunda endişelenmenize gerek kalmadan, belirli sayıda kubit için uygun QFT'yi uygulayabilirsiniz.

Diğer Q# öğreticileri keşfedin:

• Kuantum rastgele sayı oluşturucu , süper pozisyondaki kubitlerden rastgele sayılar oluşturan bir Q# programın nasıl yazıldığını gösterir.
• Grover arama algoritması, Grover arama algoritmasını kullanan bir Q# programın nasıl yazıldığını gösterir.
• Kuantum dolanıklığı , kubitleri işleyen ve ölçen ve süper pozisyon ile dolanıklığın etkilerini gösteren bir Q# programın nasıl yazıldığını gösterir.
• Kuantum Kataları, kuantum bilişimi ve programlama öğelerini aynı anda öğretmeyi amaçlayan kendi hızındaki öğreticiler ve Q# programlama alıştırmalarıdır.