Öğretici: Q# dilinde Kuantum Rastgele Sayı Oluşturucusu uygulama

Bu öğreticide, Quantum Development Kit'i (QDK) kullanarak ilk kuantum programınızı yazacağız. içinde yazılmış bir kuantum algoritmasının basit bir Q# örneği, kuantum rastgele sayı oluşturucus dur. Bu algoritma, kuantum mekaniklerinin özelliklerinden faydalanarak rastgele bir sayı üretir.

Ön koşullar

• Tercih ettiğiniz dili ve geliştirme ortamını kullanarak Quantum Development Kit'i (QDK) yükleyin.
• QDK zaten yüklüyse, en son sürüme güncelleştirilmiş olduğundan emin olun.

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

Proje Q# oluşturma

İlk olarak yeni bir proje oluşturmanız Q# gerekir. Bu öğreticide, ortamı ile Q# birlikte VS Codekullanır, ancak tercih ettiğiniz IDE'leri kullanabilirsiniz.

Yeni bir proje oluşturmak için VS Code:

1. Görünüm -> Komut Paleti’ne tıklayın ve Q#: Yeni Proje Oluştur’u seçin.
2. Bağımsız konsol uygulaması’na tıklayın.
3. Projenin kaydedileceği konuma gidin ve Proje Oluştur’a tıklayın.
4. Proje başarıyla oluşturulduğunda, sağ alt kısımdaki Yeni proje aç... seçeneğine tıklayın.

Bu durumda proje olarak adlandırılan bir Qrng projedir. Bu işlem iki dosya oluşturur: , proje dosyası ve , uygulamamızı yazmak için Qrng.csproj bir Program.qs Q# uygulamanın şablonu. içeriğinin Program.qs şöyle olması gerekir:

   namespace Qrng {

      open Microsoft.Quantum.Canon;
      open Microsoft.Quantum.Intrinsic;
      
      @EntryPoint()
      operation HelloQ() : Unit {
          Message("Hello quantum world!");
      }
   }

Q işlemi # yazma

Program.qs dosyasının içeriğini aşağıdaki kodla değiştirin:

namespace Qrng {
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    
    @EntryPoint()
    operation GenerateRandomBit() : Result {
        use q = Qubit();   // Allocate a qubit.
        H(q);              // Put the qubit to superposition. It now has a 50% chance of being 0 or 1.
        return MResetZ(q); // Measure the qubit value.
    }
}

Şimdi bu koda göz atabilirsiniz. Hiçbir giriş GenerateRandomBit alan ve türünde bir değer üreten işlemi tanımlarsiniz. Result Result türü bir ölçümün sonucunu temsil eder ve iki olası değere sahip olabilir: Zero ve One. EntryPoint derleyiciye Q# programı burada yürütmeye başlamayı söyler. içinde, Q# kubitler anahtar sözcüğü aracılığıyla use ayrılır. H işlemi qubiti süper konuma yerleştirir. işlemi M kubiti ölçer ve ölçülen değeri (sıfır veya bir) döndürür.

Kuantum bilişimi anlama makalesinde belirtildiği gibi kubit, süper konumlandırmada yer alan kuantum bilgileri birimidir. Bir kubit ölçüldüğünde yalnızca 0 veya 1 olabilir. Ancak, ölçümden önce kubitin durumu, ölçüm ile 0 veya 1 okuma olasılığını temsil eder. Olasılığa dayalı olan bu durum, süper konum olarak adlandırılır. Rastgele sayılar oluşturmak için bu olasılığı kullanabilirsiniz.

Bu Q# işlem, yerel Qubit olan veri türüne yöneliktir. Q# Qubit ayırmak için use deyimi kullanmamız gerekir. Ayrılan kubit her zaman Zero durumunda olur.

ile süper konumlandırarak ve iç işlemle ölçerek, kod her çağrıldığında sonuç farklı Qubit H bir değer M olur.

Qubit serbest bırakıldığında yeniden açıkça Zero durumuna ayarlanmalıdır, aksi halde simülatörde çalışma zamanı hatası bildirilir. Bunu yapmanın kolay yollarından biri Reset çağırmaktır.

Bloch küresi ile kodu görselleştirme

Bloch küresinde kuzey kutbu klasik 0 değerini, güney kutbu ise klasik 1 değerini temsil eder. Süper konum, küredeki bir nokta ile gösterilebilir (ok simgesi kullanılır). Okun ucu kutba ne kadar yakın olursa kubitin ölçüm sonrasında o kutba atanmış olan klasik değeri alma ihtimali o kadar yüksek olur. Örneğin aşağıda kırmızı ok ile gösterilen kubit durumunun ölçüldüğünde 0 değerini verme olasılığı yüksektir.

Kodun gerçekleştirdiği işlemleri görselleştirmek için şu gösterimi kullanabiliriz:

• İlk olarak 0 durumunda başlatılan bir kubitle başlıyoruz ve 0 ile 1 olasılıklarının aynı olduğu bir süper konum oluşturmak için buna H uyguluyoruz.

• Ardından kubiti ölçüp çıktıyı kaydediyoruz:

Ölçümün sonucu tamamen rastgele olduğundan rastgele bir bit elde ettik. Bu işlemi birkaç kere çağırarak farklı tamsayılar oluşturabiliriz. Örneğin üç rastgele bit elde etmek için işlemi üç kez çağırarak rastgele 3 bitlik sayılar (0 ile 7 arasında rastgele bir sayı) oluşturabiliriz.

Tam bir rastgele sayı oluşturucu oluşturma

Artık rastgele bitler oluşturan bir işleminiz olduğu için, tam bir kuantum rastgele sayı oluşturucu oluşturmak için Q# birden çok rastgele biti birleştirin. Bir uygulama kullanabilir Q# veya bunu yapmak için bir konak programı kullanabilirsiniz.

Rastgele sayı oluşturucu mantığını tanımlama

İlk olarak, zaten bir rastgele bit oluşturucu varsa rastgele bir sayı oluşturucu mantığının ne olması gerektiğini özetle bakalım:

1. Oluşturmak max istediğiniz maksimum sayı olarak tanımlayın.
2. Oluşturmak için ihtiyacınız olan rastgele bit sayısını tanımlayın. Bu, maksimuma kadar tamsayıları ifade etmek için gereken bit () nBits sayısı hesaplanmasıyla yapılır.
3. Uzunluğunda rastgele bir bit nBits dizesi oluşturma.
4. Bit dizesi max üst sınırından yüksek bir sayıyı temsil ediyorsa üçüncü adıma geri dönün.
5. Aksi takdirde işlem tamamlanır. Oluşturulan sayıyı tamsayı olarak döndürün.

İşlemi tanımlama

Bit SampleRandomNumberInRange dizesi oluşturmak için işlemi tekrar GenerateRandomBit tekrar çağıran işlemi tanımlayın.

Şu Program.qs şekilde değiştir:

namespace Qrng {

    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit(); 
        // Put the qubit to superposition.
        H(q);
        // It now has a 50% chance of being measured 0 or 1.
        // Measure the qubit value.
        return M(q);
    }

    operation SampleRandomNumberInRange(max : Int) : Int {
        mutable output = 0; 
        repeat {
            mutable bits = new Result[0]; 
            for idxBit in 1..BitSizeI(max) {
                set bits += [GenerateRandomBit()]; 
            }
            set output = ResultArrayAsInt(bits);
        } until (output <= max);
        return output;
    }
}

Yeni kodu kısaca gözden geçirelim.

Kitaplık, tamsayıları en yüksek değere kadar ifade etmek için gereken bit sayısını hesaplamak Microsoft.Quantum.Math için bu görevi gerçekleştirme işlevini BitSizeI sağlar.

işlemi, maksimuma eşit veya daha küçük bir sayı oluşturana kadar rastgele sayılar oluşturmak SampleRandomNumberInRange repeat için bir döngü kullanır.

içindeki for repeat döngüsü, diğer programlama dillerinde for döngüsüyle tam olarak aynı şekilde çalışır.

Bu örnekte, output ve bits değiştirilebilir değişkenlerdir. Değiştirilebilir değişken, hesaplama sırasında değişebilen değişkendir. Değişebilir bir değişkenin değerini değiştirmek için set yönergesini kullanırsiniz.

İşlev, ResultArrayAsInt 'den Microsoft.Quantum.Convert library gelir. Bu işlev, bit dizesini pozitif tamsayıya dönüştürür.

Program Qrng artık rastgele sayılar üretebilirsiniz. Giriş Program.qs noktasını tanımlamak için bu şekilde değiştirme.

namespace Qrng {

    open Microsoft.Quantum.Canon;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Measurement;
    open Microsoft.Quantum.Math;
    open Microsoft.Quantum.Convert;

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit();
        // Put the qubit to superposition.
        H(q);
        // It now has a 50% chance of being measured 0 or 1.
        // Measure the qubit value.
        return M(q);
    }

    operation SampleRandomNumberInRange(max : Int) : Int {
        mutable output = 0; 
        repeat {
            mutable bits = new Result[0]; 
            for idxBit in 1..BitSizeI(max) {
                set bits += [GenerateRandomBit()]; 
            }
            set output = ResultArrayAsInt(bits);
        } until (output <= max);
        return output;
    }

    @EntryPoint()
    operation SampleRandomNumber() : Int {
        let max = 50;
        Message($"Sampling a random number between 0 and {max}: ");
        return SampleRandomNumberInRange(max);
    }
}

dotnet build

dotnet run --no-build

import qsharp
from Qrng import SampleQuantumRandomNumberGenerator # We import the 
# quantum operation from the namespace defined in the file Qrng.qs
max = 50 # Here we set the maximum of our range
output = max + 1 # Variable to store the output
while output > max:
    bit_string = [] # We initialize a list to store the bits that
    # will define our random integer
    for i in range(0, max.bit_length()): # We need to call the quantum
        # operation as many times as bits are needed to define the
        # maximum of our range. For example, if max=7 we need 3 bits
        # to generate all the numbers from 0 to 7. 
        bit_string.append(SampleQuantumRandomNumberGenerator.simulate()) 
        # Here we call the quantum operation and store the random bit
        # in the list
    output = int("".join(str(x) for x in bit_string), 2) 
# Transform bit string to integer

print("The random number generated is " + str(output))
# We print the random number

$ python host.py
Preparing Q# environment...
..The random number generated is 42

using System;
using Microsoft.Quantum.Simulation.Core;
using Microsoft.Quantum.Simulation.Simulators;
using System.Linq;

namespace Qrng
{
    class Driver
    {
        static void Main(string[] args)
        {
            using (var sim = new QuantumSimulator())
            {
                // First we initialize all the variables:
                var bitString = "0"; // To save the bit string
                int max = 50; // The maximum of the range
                int size = Convert.ToInt32(Math.Floor(Math.Log(max, 2.0) + 1));
                // To calculate the amount of needed bits
                int output = max + 1; // Int to store the output
                while (output > max)  // Loop to generate the number
                {
                    bitString = "0"; // Restart the bit string if fails
                    bitString = String.Join("", Enumerable.Range(0, size).Select(idx =>
                        SampleQuantumRandomNumberGenerator.Run(sim).Result == Result.One ? "1" : "0"
                    ));
                    // Generate and concatenate the bits using the Q# operation
                    // Convert the bit string to an integer
                    output = Convert.ToInt32(bitString, 2);
                }
                // Print the result
                Console.WriteLine($"The random number generated is {output}.");
            }
        }
    }
}

$ dotnet run
The random number generated is 42

Sonraki adımlar

ile dolamentı Q# keşfetme öğreticisi, kubitleri yönlendiren ve ölçüp süper konumlandırın ve doyma etkilerini gösteren bir programın nasıl Q# yaz olduğunu gösterir.

Bu Azure Quantum, öğrenmenin ve kuantum programlamanın daha Q# fazla yolu önerilmez.