Öğretici: içinde kuantum rastgele sayı oluşturucu uygulama Q#

  • Makale

Not

Microsoft Quantum Development Kit (Klasik QDK) artık 30 Haziran 2024'dan sonra desteklenmeyecektir. Mevcut bir QDK geliştiricisiyseniz kuantum çözümleri geliştirmeye devam etmek için yeni Azure'a Quantum Development Kit (Modern QDK) geçmenizi öneririz. Daha fazla bilgi için bkz. Kodunuzu Modern QDK'ye geçirmeQ#.

rastgele bir sayı üretmek için kuantum mekaniğinin doğasından yararlanan temel bir kuantum programı Q# yazmayı öğrenin.

Bu öğreticide şunları yapacaksınız:

  • Program Q# oluşturma.
  • Bir Q# programın ana bileşenlerini gözden geçirin.
  • Bir sorunun mantığını tanımlayın.
  • Bir sorunu çözmek için klasik ve kuantum işlemlerini birleştirin.
  • Bir kuantum rastgele sayı oluşturucu derlemek için qubitlerle ve süper konumla çalışın.

İpucu

Kuantum bilişimi yolculuğunuzu hızlandırmak istiyorsanız Azure Quantum web sitesinin benzersiz bir özelliği olan Azure Quantum ile kod bölümüne göz atın. Burada yerleşik Q# örnekleri veya kendi Q# programlarınızı çalıştırabilir, istemlerinizden yeni Q# kod oluşturabilir, kodunuzu tek tıklamayla Web için VS Code'da açıp çalıştırabilir ve Copilot'a kuantum bilişimi hakkında herhangi bir soru sorabilirsiniz.

Önkoşullar

Sorunu tanımlama

Klasik bilgisayarlar rastgele sayılar değil, sözde sayılar üretir. Takma ad sayı oluşturucu, bir ilk değere göre (tohum olarak adlandırılan) belirleyici bir sayı dizisi oluşturur. Bu çekirdek, rastgele değerleri daha iyi tahmin etmek için genellikle CPU saatinin geçerli zamanıdır.

Öte yandan kuantum bilgisayarlar gerçekten rastgele sayılar oluşturabilir. Bunun nedeni, bir kubitin süper pozisyondaki ölçülmesi olasılığa dayalı bir işlemdir. Ölçümün sonucu rastgeledir ve sonucu tahmin etmenin bir yolu yoktur. Bu, kuantum rastgele sayı oluşturucularının temel ilkesidir.

Kubit, süper pozisyonda olabilecek kuantum bilgilerinden oluşan bir birimdir. Ölçüldüyse kubit yalnızca 0 durumunda veya 1 durumunda olabilir. Ancak, ölçümden önce kubitin durumu, ölçümle 0 veya 1 okuma olasılığını temsil eder.

Başlangıç olarak sıfır gibi temel bir durumda bir kubit alırsınız. Rastgele sayı oluşturucunun ilk adımı, kubiti eşit bir süper pozisyona yerleştirmek için hadamard işlemi kullanmaktır. Bu durumun ölçümü, her sonucun %50 olasılığı olan bir sıfır veya bir sonuç verir( gerçekten rastgele bir bit).

Süper pozisyondaki kubitin ölçümünden sonra ne elde edeceğinizi bilmenin hiçbir yolu yoktur ve kod her çağrıldığında sonuç farklı bir değerdir. Ancak daha büyük rastgele sayılar oluşturmak için bu davranışı nasıl kullanabilirsiniz?

Şu ikili sayı dizisini oluşturarak işlemi dört kez yinelediğinizi varsayalım:

$${0, 1, 1, 0}$$

Bu bitleri bir bit dizesine ekler veya birleştirirseniz, daha büyük bir sayı oluşturabilirsiniz. Bu örnekte, ${0110}$ bit dizisi ondalık sayı sisteminde altıya eşdeğerdir.

$${0110_{\ binary} \equiv 6_{\ decimal}}$$

Bu işlemi birçok kez tekrarlarsanız, birden çok biti birleştirerek büyük bir sayı oluşturabilirsiniz. Artık üstlerinize bu sayıyı güvenli bir parola olarak sağlayabilirsiniz, çünkü hiçbir uzay korsanının ölçüm sırasının sonuçlarını belirleyemediğinden emin olabilirsiniz.

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

Rastgele bir bit oluşturucumuz olması koşuluyla rastgele bir sayı oluşturucunun mantığının ne olması gerektiğini özetleyelim:

  1. Oluşturmak istediğiniz maksimum sayı olarak tanımlayın max .
  2. Oluşturmanız gereken rastgele bit sayısını tanımlayın. Bu işlem, max adede kadar ifade etmemiz gereken tamsayılar için kaç bit (nBits) gerektiği hesaplanarak yapılır.
  3. nBits uzunluğunda rastgele bir bit dizesi oluşturun.
  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.

Örnek olarak max, 12 olarak ayarlandığında: Yani 12, güvenli parola olarak kullanmak istediğiniz en büyük sayıdır.

${\lfloor ln(12) / ln(2) + 1 \rfloor}$ veya 0 ile 12 arasında bir sayıyı temsil etmek için 4 bit gerekir. (Konuyu kısa tutmak için bu denklemin nasıl türetildiğini atlayacağız.)

${13_{\ decimal}}$ denklemine eşdeğer olan ${1101_{\ binary}}$ bit dizesini oluşturduğunuzu varsayalım. 13, 12'den büyük olduğu için işlemi tekrarlamanız gerekir.

Daha sonra, ${6_{\ decimal}}$ denklemine eşdeğer olan ${0110_{\ binary}}$ bit dizesini oluşturuyorsunuz. 6, 12'den küçük olduğu için işlem tamamlanır.

Kuantum rastgele sayı oluşturucu, parolanız olarak 6 sayısını döndürür. Pratikte, mümkün olan tüm parolaları deneyerek daha düşük sayıların kolayca kırılabileceğinden, en yüksek sayı olarak daha büyük bir sayı ayarlayın. Aslında, parolanızı tahmin etme veya kırma zorluğunu artırmak için ikiliyi metne dönüştürmek ve sayılar, simgeler ve karışık harf kullanarak parola oluşturmak için ASCII kodu kullanabilirsiniz.

Rastgele bit oluşturucu yazma

İlk adım, rastgele bir bit oluşturan bir Q# işlem yazmaktır. Bu işlem, rastgele sayı oluşturucunun yapı taşları arasında yer alır.

operation GenerateRandomBit() : Result {
    // Allocate a qubit.
    use q = Qubit();

    // Set the qubit into superposition of 0 and 1 using the Hadamard 
    H(q);

    // At this point the qubit `q` has 50% chance of being measured in the
    // |0〉 state and 50% chance of being measured in the |1〉 state.
    // Measure the qubit value using the `M` operation, and store the
    // measurement value in the `result` variable.
    let result = M(q);

    // Reset qubit to the |0〉 state.
    // Qubits must be in the |0〉 state by the time they are released.
    Reset(q);

    // Return the result of the measurement.
    return result;
}

Şimdi yeni koda göz atın.

  • Giriş içermeyen ve türünde Resultbir değer üreten işlemi tanımlarsınızGenerateRandomBit. Tür Result bir ölçümün sonucunu temsil eder ve iki olası değere sahip olabilir: Zero veya One.
  • Anahtar sözcüğüyle use tek bir kubit ayırırsınız. Ayrıldığında, kubit her zaman Zero durumunda olur.
  • Kubiti H eşit bir süper konuma yerleştirmek için işlemini kullanırsınız.
  • kubiti M ölçmek, ölçülen değeri (Zero veya One) döndürmek için işlemini kullanırsınız.
  • Kubiti Reset |0〉 durumuna sıfırlamak için işlemini kullanırsınız.

Kubiti işlemle süper konuma yerleştirip işlemle HM ölçerek, kod her çağrıldığında sonuç farklı bir değer olur.

Bloch küresi Q# 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ğıdaki şekildeki okla temsil edilen kubit durumunun, ölçerseniz 0 değerini verme olasılığı daha yüksektir.

Sıfır ölçme olasılığı yüksek olan kubit durumunu gösteren diyagram.

Kodun ne yaptığını görselleştirmek için bu gösterimi kullanabilirsiniz:

  1. İlk olarak, 0 durumunda başlatılan bir kubitle başlayın ve 0 ve 1 olasılıklarının aynı olduğu eşit bir süper pozisyon oluşturmak için bir H işlem uygulayın.

    Hadamard kapısı uygulanarak süper pozisyondaki kubitin hazırlanmasını gösteren diyagram.

  2. Ardından kubiti ölçün ve çıkışı kaydedin:

    Kubitin ölçülerek çıkışın kaydedildiği diyagram.

Ölçümün sonucu rastgele olduğundan ve 0 ile 1'i ölçme olasılıkları aynı olduğundan, tamamen rastgele bir bit elde etmişsinizdir. Tamsayılar oluşturmak için bu işlemi birkaç kez çağırabilirsiniz. Örneğin, üç rastgele bit elde etmek için işlemi üç kez çağırırsanız, rastgele 3 bit sayılar (0 ile 7 arasında rastgele bir sayı) oluşturabilirsiniz.

Tam bir rastgele sayı oluşturucu yazma

  1. İlk olarak, gerekli Q# ad alanlarını programa eklemeniz gerekir. Tam rastgele sayı oluşturucu için üç Q# ad alanı eklemeniz gerekir: Microsoft.Quantum.Math, Microsoft.Quantum.Intrinsicve Microsoft.Quantum.Convert.

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

  2. Ardından işlemi tanımlarsınız GenerateRandomNumberInRange . Bu işlem bir bit dizesi derlemek için GenerateRandomBit işlemini tekrar tekrar çağırır.

        /// Generates a random number between 0 and `max`.
    operation GenerateRandomNumberInRange(max : Int) : Int {
        // Determine the number of bits needed to represent `max` and store it
        // in the `nBits` variable. Then generate `nBits` random bits which will
        // represent the generated random number.
        mutable bits = [];
        let nBits = BitSizeI(max);
        for idxBit in 1..nBits {
            set bits += [GenerateRandomBit()];
        }
        let sample = ResultArrayAsInt(bits);

        // Return random number if it is within the requested range.
        // Generate it again if it is outside the range.
        return sample > max ? GenerateRandomNumberInRange(max) | sample;
    }

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

    • 'a kadar maxolan tamsayıları ifade etmek için gereken bit sayısını hesaplamanız gerekir. BitSizeI Ad alanından işleviMicrosoft.Quantum.Math, bir tamsayıyı temsil etmek için gereken bit sayısına dönüştürür.
    • SampleRandomNumberInRange işlemi, max'e eşit veya ondan küçük bir sayı oluşturana kadar rastgele sayılar oluşturmak için bir for döngüsü kullanır. Döngü, for diğer programlama dillerindeki bir for döngüyle tam olarak aynı şekilde çalışır.
    • değişken bits , değiştirilebilir bir değişkendir. Değiştirilebilir değişken, hesaplama sırasında değişebilen değişkendir. Değiştirilebilir bir değişkenin değerini değiştirmek için set yönergesini kullanın.
    • ResultArrayAsInt işlevi ad alanından Microsoft.Quantum.Convert gelir. Bu işlev, bit dizesini pozitif tamsayıya dönüştürür.

  3. Son olarak, bir giriş noktası eklersiniz. Bu örnekte, Main işlem programın giriş noktasıdır. 0 ile 100 arasında rastgele bir sayı oluşturmak için işlemini çağırır GenerateRandomNumberInRange .

        @EntryPoint()
    operation Main() : Int {
        let max = 100;
        Message($"Sampling a random number between 0 and {max}: ");

        // Generate random number in the 0..max range.
        return GenerateRandomNumberInRange(max);
    }

    let yönergesi, hesaplama sırasında değişmeyen değişkenleri bildirir. Burada maksimum değeri 100 olarak tanımlayacağız.

  4. Rastgele sayı oluşturucunun tam kodu aşağıdaki gibidir:

namespace QuantumRandomNumberGenerator {
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;

    @EntryPoint()
    operation Main() : Int {
        let max = 100;
        Message($"Sampling a random number between 0 and {max}: ");

        // Generate random number in the 0..max range.
        return GenerateRandomNumberInRange(max);
    }

    /// Generates a random number between 0 and `max`.
    operation GenerateRandomNumberInRange(max : Int) : Int {
        // Determine the number of bits needed to represent `max` and store it
        // in the `nBits` variable. Then generate `nBits` random bits which will
        // represent the generated random number.
        mutable bits = [];
        let nBits = BitSizeI(max);
        for idxBit in 1..nBits {
            set bits += [GenerateRandomBit()];
        }
        let sample = ResultArrayAsInt(bits);

        // Return random number if it is within the requested range.
        // Generate it again if it is outside the range.
        return sample > max ? GenerateRandomNumberInRange(max) | sample;
    }

    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit();

        // Set the qubit into superposition of 0 and 1 using the Hadamard 
        H(q);

        // At this point the qubit `q` has 50% chance of being measured in the
        // |0〉 state and 50% chance of being measured in the |1〉 state.
        // Measure the qubit value using the `M` operation, and store the
        // measurement value in the `result` variable.
        let result = M(q);

        // Reset qubit to the |0〉 state.
        // Qubits must be in the |0〉 state by the time they are released.
        Reset(q);

        // Return the result of the measurement.
        return result;
    }
}

Rastgele sayı oluşturucu programını çalıştırma

Programı Azure Quantum'daki Copilot'ta ve Visual Studio Code'da tek başına Q# bir uygulama olarak veya Python konak programı kullanarak çalıştırabilirsiniz.

Kodunuzu Azure Quantum'da Copilot ile ücretsiz olarak test Q# edebilirsiniz. Tek ihtiyacınız olan bir Microsoft (MSA) e-posta hesabıdır. Azure Quantum'da Copilot hakkında daha fazla bilgi için bkz. Azure Quantum'u keşfetme.

  1. Copilot'i tarayıcınızda Azure Quantum'da açın.

  2. Aşağıdaki kodu kopyalayıp kod düzenleyicisine yapıştırın.

    namespace Tutorial {
    open Microsoft.Quantum.Convert;
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Math;

    @EntryPoint()
    operation Main() : Int {
        let max = 100;
        Message($"Sampling a random number between 0 and {max}: ");

        // Generate random number in the 0..max range.
        return GenerateRandomNumberInRange(max);
    }

    /// # Summary
    /// Generates a random number between 0 and `max`.
    operation GenerateRandomNumberInRange(max : Int) : Int {
        // Determine the number of bits needed to represent `max` and store it
        // in the `nBits` variable. Then generate `nBits` random bits which will
        // represent the generated random number.
        mutable bits = [];
        let nBits = BitSizeI(max);
        for idxBit in 1..nBits {
            set bits += [GenerateRandomBit()];
        }
        let sample = ResultArrayAsInt(bits);

        // Return random number if it is within the requested range.
        // Generate it again if it is outside the range.
        return sample > max ? GenerateRandomNumberInRange(max) | sample;
    }

    /// # Summary
    /// Generates a random bit.
    operation GenerateRandomBit() : Result {
        // Allocate a qubit.
        use q = Qubit();

        // Set the qubit into superposition of 0 and 1 using the Hadamard 
        // operation `H`.
        H(q);

        // At this point the qubit `q` has 50% chance of being measured in the
        // |0〉 state and 50% chance of being measured in the |1〉 state.
        // Measure the qubit value using the `M` operation, and store the
        // measurement value in the `result` variable.
        let result = M(q);

        // Reset qubit to the |0〉 state.
        // Qubits must be in the |0〉 state by the time they are released.
        Reset(q);

        // Return the result of the measurement.
        return result;

        // Note that Qubit `q` is automatically released at the end of the block.
    }
}

  3. Çalıştırılacak çekim sayısını seçin ve Çalıştır'a tıklayın.

  4. Sonuçlar histogramda ve Sonuçlar alanlarında görüntülenir.

  5. Copilot'un kodu size açıklamasını istemesi için Kodu açıkla'ya tıklayın.

İpucu

Azure Quantum'daki Copilot'tan, kod düzenleyicisinin sağ köşesindeki VS Code logosu düğmesine tıklayarak programınızı Web için VS Code'da açabilirsiniz.

Not

Çağrılabilen ResultArrayAsInt tam hesaplama profiline sahip bir QPU gerektirdiğinden, bu kod parçacığı şu anda kullanılabilir herhangi bir Azure Quantum donanımı targetsüzerinde çalışmaz.

Sonraki adımlar

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