Öğretici: Ile kuantum dolanıklığı keşfetme Q#

Makale
21.12.2024

Bu öğreticide kubitleri işleyen ve ölçen ve süper pozisyon ve dolanıklığın etkilerini gösteren bir Q# program yazacaksınız. Belirli bir kuantum durumunda iki kubit hazırlar, durumlarını değiştirmek için ile kubitler Q# üzerinde nasıl çalışacağınızı öğrenir ve süper pozisyon ile dolanıklığın etkilerini gösterirsiniz. Kubit durumlarını, işlemlerini ve ölçümlerini tanıtmak için programınızı Q# parça parça oluşturursunuz.

Başlamadan önce anlamanız gereken bazı önemli kavramlar şunlardır:

Klasik bitlerin 0 veya 1 gibi tek bir ikili değeri barındırdığı durumlarda kubitin durumu 0 ve 1 olmak üzere iki kuantum durumunun süper konumunda olabilir. Her olası kuantum durumunun ilişkili bir olasılık genliği vardır.
Kubit ölçme işlemi, belirli bir olasılığa sahip ikili bir sonuç üretir ve kubitin durumunu süper pozisyonun dışında değiştirir.
Birden çok kubit birbirinden bağımsız olarak tanımlanamaz şekilde dolanık olabilir. Başka bir deyişle dolanık bir çiftteki bir kubite ne olursa olsun diğer kubite de olur.

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

Kubiti istenen duruma başlatmak için işlemler oluşturun Q# .
Bir kubiti süper pozisyona yerleştirin.
Bir kubit çiftini dolandırın.
Kubiti ölçün ve sonuçları gözlemleyin.

İpucu

Kuantum bilişim yolculuğunuzu hızlandırmak istiyorsanız Azure Quantum web sitesinin benzersiz bir özelliği olan Azure Quantum ile kod bölümüne bakı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 sorular sorabilirsiniz.

Önkoşullar

Azure Quantum için Copilot'ta kod örneğini çalıştırmak için şunları yapmanız gerekir:

Microsoft (MSA) e-posta hesabı.

Copilot hakkında daha fazla bilgi için bkz . Azure Quantum'u keşfetme.

Bilinen bir duruma kubit başlatma

İlk adım, bir kubiti bilinen bir Q# duruma başlatan bir işlem tanımlamaktır. Bu işlem, kubiti klasik duruma ayarlamak için çağrılabilir; yani ölçüldüğünde zamanın %100'ünün döndürüldüğü Zero veya zamanın %100'ünün döndürüldüğü anlamına gelir One . Kubitin ölçülmesi, yalnızca veya Q#değerine Result sahip olabilecek bir Zero türü Onedöndürür.

Azure Quantum için Copilot'ı açın ve aşağıdaki kodu kod düzenleyicisi penceresine kopyalayın. çalıştır henüz seçmeyin; kodu öğreticinin ilerleyen bölümlerinde çalıştıracaksınız.

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

Kod örneği, M kubitin durumunu dönüştüren ve Xolmak üzere iki standart işlemi tanıtır.

İşlem SetQubitState :

İki parametre alır: kubitin içinde ( veya Result) olmasını istediğiniz durumu temsil eden adlı desiredbir tür Zerove bir türüOne.Qubit
Kubitin (M veya Zero) durumunu ölçen ve sonucu içinde Onebelirtilen değerle karşılaştıran bir ölçüm işlemi desiredgerçekleştirir.
Ölçüm, karşılaştırılan değerle eşleşmiyorsa, kubitin durumunu döndüren X ve Zero ters çevrilen bir ölçümün olasılıklarını çeviren bir işlem çalıştırırOne. Bu şekilde hedef SetQubitState kubiti her zaman istenen duruma getirir.

Bell durumunu test etmek için bir test işlemi yazma

Ardından, işlemin etkisini SetQubitState göstermek için adlı Mainbaşka bir işlem oluşturun. Bu işlem iki kubit ayıracak, ilk kubiti bilinen bir duruma ayarlamak için çağrısı SetQubitState yapacak ve ardından sonuçları görmek için kubitleri ölçecektir.

Aşağıdaki kodu işlemin altındaki kod düzenleyicisi penceresine SetQubitState kopyalayın.

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Kodda ve countinitial değişkenleri sırasıyla ve 1000 olarak One ayarlanır. Bu, ilk kubiti One başlatır ve her kubiti 1000 kez ölçer.

İşlem Main:

Sayaç ve ilk kubit durumu için değişkenleri ayarlar.
use İki kubit başlatmak için deyimini çağırır.
Yinelemeler için count döngüler. Her döngü için
1. İlk kubitte belirtilen SetQubitState değeri ayarlamak için çağrılarinitial.
2. İkinci kubiti bir SetQubitState duruma ayarlamak için yeniden çağırırZero.
3. Her kubiti M ölçmek için işlemini kullanır.
4. döndüren Oneher kubit için ölçü sayısını depolar.
Döngü tamamlandıktan sonra, diğer kullanıcıların kubitleri bilinen bir durumda ayırmasına izin vermek için kubitleri bilinen bir duruma (SetQubitState) sıfırlamak için yeniden çağırırZero. Sıfırlama deyimi için use gereklidir.
Son olarak, sonuçları döndürmeden önce Copilot çıkış pencerelerine sonuçları yazdırmak için işlevini kullanır Message .

Azure Quantum için Copilot'ta kodu çalıştırma

Süper pozisyon ve dolanıklık yordamlarına geçmeden önce, kubitlerin başlatılmasını ve ölçülmesi için kodu bu noktaya kadar test edebilirsiniz.

Kodu tek başına bir program olarak çalıştırmak için Copilot'taki derleyicinin Q# programı nereden başlatacaklarını bilmesi gerekir. Ad alanı belirtilmediğinden, derleyici varsayılan giriş noktasını işlem olarak Main tanır. Daha fazla bilgi için bkz . Projeler ve örtük ad alanları.

Bu noktaya kadar olan programınız Q# şu şekilde görünmelidir:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
        
    
    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

}

Tam kod örneğini kopyalayıp Azure Quantum için Copilot kod penceresine yapıştırın, çekim sayısı için kaydırıcıyı "1" olarak ayarlayın ve çalıştır'ı seçin. Sonuçlar histogramda ve Sonuçlar alanlarında görüntülenir.

Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0

Kubitler henüz işlenmediğinden, ilk değerlerini korumuşlardır: ilk kubit her seferinde döndürür One ve ikinci kubit döndürür Zero.

değerini initialZero olarak değiştirir ve programı yeniden çalıştırırsanız, ilk kubitin de her seferinde döndürdüğünü Zero gözlemlemeniz gerekir.

Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0

İpucu

Ctrl-Z veya Geri Almayı Düzenle'yi > seçin ve yeniden çalıştırmadan önce koda bir test değişikliği eklediğinizde dosyanızı kaydedin.

Kubiti süper konuma yerleştirme

Şu anda, programdaki kubitlerin tümü klasik durumdadır, yani 1 veya 0'dır. Bunu biliyorsunuz çünkü program kubitleri bilinen bir duruma başlatır ve bunları işlemek için herhangi bir işlem eklememişsinizdir. Kubitleri dolanık hale getirilmeden önce, ilk kubiti süper konum durumuna koyarsınız; burada kubitin ölçümü zamanın yaklaşık %50'sini ve Zero zamanın yaklaşık %50'sini döndürür One . Kavramsal olarak, kubitin veya Zeroölçme One olasılığının eşit olduğu düşünülebilir.

Bir kubiti süper konuma yerleştirmek için , Q# veya H, işlemini sağlar. X Daha önce bir kubiti 0'dan 1'e çeviren (veya tam tersi) bilinen bir durum yordamına kadar olan işlemi hatırlayın; H işlem, kubiti . Ölçüldüyse, süper pozisyondaki bir kubit yaklaşık olarak eşit sayıda Zero ve One sonuç döndürmelidir.

İlk değeri Main sıfırlayarak ve işlem için bir satır ekleyerek işlemdeki One kodu H değiştirin:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Artık programı çalıştırdığınızda, süper pozisyondaki ilk kubitin sonuçlarını görebilirsiniz.

Q1 - Zeros: 523            // results vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0

Programı her çalıştırdığınızda, ilk kubitin sonuçları biraz değişir, ancak %50 ve % OneZero50'ye yakın olurken, ikinci kubitin sonuçları her zaman kalır Zero .

Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0

İlk kubitin başlatılması Zero benzer sonuçlar döndürür.

Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0

Not

Azure Quantum için Copilot'taki kaydırıcıyı hareket ettirerek ve çekim sayısını artırarak süper pozisyon sonuçlarının çekimlerin dağılımına göre biraz değiştiğini görebilirsiniz.

İki kubiti dolanıklık

Daha önce belirtildiği gibi dolanık kubitler birbirinden bağımsız olarak tanımlanamayacak şekilde bağlanır. Başka bir ifadeyle, bir kubite ne olursa olsun işlem dolanık kubite de gerçekleşir. Bu, yalnızca diğer kubitin durumunu ölçerek bir kubitin elde edilen durumunu ölçmeden bilmenize olanak tanır. (Bu örnekte iki kubit kullanılır; ancak üç veya daha fazla kubiti dolanık hale getirmek de mümkündür).

Dolanıklığı Q# etkinleştirmek için, Controlled-NOTCNOTolan işlemi sağlar. Bu işlemi iki kubit üzerinde çalıştırmanın sonucu, ilk kubit ise ikinci kubiti çevirmektir One.

İşlemi, işlemden CNOT hemen sonra H programınıza ekleyin. Tam programınız şu şekilde görünmelidir:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
    
        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }

Şimdi programı çalıştırdığınızda aşağıdakine benzer bir şey görmeniz gerekir:

Q1 - Zeros: 502           // results will vary
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

İlk kubitin istatistiklerinin değişmediğine dikkat edin (yine de bir veya Zero daha sonra ölçüm için yaklaşık 50/50 olasılık One vardır), ancak ikinci kubitin ölçüm sonuçları, programı kaç kez çalıştırdığınızdan bağımsız olarak her zaman ilk kubitin ölçümüyle aynıdır. İşlem CNOT iki kubiti dolanık yaptı, böylece bunlardan birine ne olursa olsun, diğerine de olur.

Önkoşullar

Kod örneğini yerel geliştirme ortamınızda geliştirmek ve çalıştırmak için:

Visual Studio Code'un en son sürümü veya Vs Code'un Web'de açılması.
Azure Quantum Geliştirme Seti uzantısının en son sürümü. Yükleme ayrıntıları için bkz. QDK uzantısını ayarlama.

Yeni Q# dosya oluşturma

Visual Studio Code'u açın ve Yeni Metin Dosyası Oluştur'u > seçerek yeni bir dosya oluşturun.
Dosyayı CreateBellStates.qs olarak kaydedin. Bu dosya, programınızın kodunu içerir Q# .

Bilinen bir duruma kubit başlatma

İlk adım, bir kubiti bilinen bir Q# duruma başlatan bir işlem tanımlamaktır. Bu işlem, kubiti klasik duruma ayarlamak için çağrılabilir; yani zamanın %100'ünün döndürüldüğü Zero veya %100'ünün döndürüldüğü anlamına gelir One . Zero ve One bir Q# kubit ölçümünün yalnızca iki olası sonucunu temsil eden değerlerdir.

Aşağıdaki kodu açın CreateBellStates.qs ve kopyalayın:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

Kod örneği, M kubitin durumunu dönüştüren ve Xolmak üzere iki standart işlemi tanıtır.

İşlem SetQubitState :

İki parametre alır: kubitin içinde ( veya Result) olmasını istediğiniz durumu temsil eden adlı desiredbir tür Zerove bir türüOne.Qubit
Kubitin (M veya Zero) durumunu ölçen ve sonucu içinde Onebelirtilen değerle karşılaştıran bir ölçüm işlemi desiredgerçekleştirir.
Ölçüm, karşılaştırılan değerle eşleşmiyorsa, kubitin durumunu döndüren X ve Zero ters çevrilen bir ölçümün olasılıklarını çeviren bir işlem çalıştırırOne. Bu şekilde hedef SetQubitState kubiti her zaman istenen duruma getirir.

Bell durumunu test etmek için bir test işlemi yazma

Ardından, işlemin etkisini SetQubitState göstermek için adlı Mainbaşka bir işlem oluşturun. Bu işlem iki kubit ayırır, ilk kubiti bilinen bir duruma ayarlamak için çağrısı SetQubitState yapın ve ardından sonuçları görmek için kubitleri ölçün.

İşlemden sonra CreateBellStates.qs dosyanıza SetQubitState aşağıdaki işlemi ekleyin:

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);
        
        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);
    

    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Kodda ve countinitial değişkenleri sırasıyla ve 1000 olarak One ayarlanır. Bu adım ilk kubiti One başlatır ve her kubiti 1000 kez ölçer.

İşlem Main:

İki parametre alır: count, ölçümü çalıştırma sayısı ve initialkubitin başlatılması için istenen durum.
use İki kubit başlatmak için deyimini çağırır.
Yinelemeler için count döngüler. Her döngü için
1. İlk kubitte belirtilen SetQubitState değeri ayarlamak için çağrılarinitial.
2. İkinci kubiti bir SetQubitState duruma ayarlamak için yeniden çağırırZero.
3. Her kubiti M ölçmek için işlemini kullanır.
4. döndüren Oneher kubit için ölçü sayısını depolar.
Döngü tamamlandıktan sonra, diğer kullanıcıların kubitleri bilinen bir durumda ayırmasına izin vermek için kubitleri bilinen bir duruma (SetQubitState) sıfırlamak için yeniden çağırırZero. Deyimi kubiti sıfırlamak use için gereklidir.
Son olarak, sonuçları döndürmeden önce konsola bir ileti yazdırmak için işlevini kullanır Message .

Kodu çalıştırma

Süper pozisyon ve dolanıklık yordamlarına geçmeden önce kubitlerin başlatılmasını ve ölçülmesi için kodu bu noktaya kadar test edin.

Kodu tek başına bir program olarak çalıştırmak için derleyicinin Q# programı nereden başlatacaklarını bilmesi gerekir. Ad alanı belirtilmediğinden, derleyici varsayılan giriş noktasını işlem olarak Main tanır. Daha fazla bilgi için bkz . Projeler ve örtük ad alanları.

Bu noktaya kadar olan dosyanız CreateBellStates.qs şu şekilde görünmelidir:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

operation SetQubitState(desired : Result, target : Qubit) : Unit {
    if desired != M(target) {
        X(target);
    }
}

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = One;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);


    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );
}

Programı çalıştırmadan önce hedef profilin Sınırsız olarak ayarlandığından emin olun. Görünüm - Komut Paleti'ni>, QIR'yi arayın, öğesini seçinQ# ayarlayın ve ardından : sınırsız'ı seçinQ#.

Not

Hedef profil Kısıtlanmamış olarak ayarlanmamışsa, programı çalıştırdığınızda bir hata alırsınız.
Programı çalıştırmak için sağ üstteki yürütme simgesi açılan listesinden Dosyayı Çalıştır'ı seçin, işlemden önceki Q# komut listesinden Çalıştır'ı seçin veya Ctrl+F5 tuşlarına basın.Main Program, Main işlemi varsayılan simülatörde çalıştırır.
Çıkışınız hata ayıklama konsolunda görünür.
```
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Kubitler henüz işlenmediğinden, ilk değerlerini korumuşlardır: ilk kubit her seferinde döndürür One ve ikinci kubit döndürür Zero.
değerini initialZero olarak değiştirir ve programı yeniden çalıştırırsanız, ilk kubitin de her seferinde döndürdüğünü Zero gözlemlemeniz gerekir.
```
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
```

İpucu

Ctrl-Z veya Geri Almayı Düzenle'yi > seçin ve yeniden çalıştırmadan önce koda bir test değişikliği eklediğinizde dosyanızı kaydedin.

Kubiti süper konuma yerleştirme

Şu anda, programdaki kubitlerin tümü klasik durumdadır, yani 1 veya 0'dır. Bunu biliyorsunuz çünkü program kubitleri bilinen bir duruma başlatır ve bunları işlemek için herhangi bir işlem eklememişsinizdir. Kubitleri dolanık hale getirilmeden önce, ilk kubiti süper konum durumuna koyarsınız; burada kubitin ölçümü zamanın %50'sini ve Zero %50'sini döndürürOne. Kavramsal olarak, kubit ile Zeroarasında One bir yarı olarak düşünülebilir.

Bir kubiti süper konuma yerleştirmek için , Q# veya H, işlemini sağlar. X Daha önce bir kubiti 'den (veya tersine) çeviren bilinen bir durum yordamına Zero kubiti One başlatma işleminden H işlemi hatırlayın; işlem, kubiti . Ölçüldüyse, süper pozisyondaki bir kubit yaklaşık olarak eşit sayıda Zero ve One sonuç döndürmelidir.

İşlemdeki Main kodu, işlemi içerecek şekilde H değiştirin:

for test in 1..count {
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        H(q1);                // Add the H operation after initialization and before measurement

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2); 
        ...

Artık programı çalıştırdığınızda süper pozisyondaki ilk kubitin sonuçlarını görebilirsiniz:
```
Q1 - Zeros: 523            // results will vary
Q1 - Ones: 477
Q2 - Zeros: 1000
Q2 - Ones: 0
```
Programı her çalıştırdığınızda, ilk kubitin sonuçları biraz değişir, ancak %50 ve % OneZero50'ye yakın olurken, ikinci kubitin sonuçları her zaman kalır Zero .
```
Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
```

İlk kubitin başlatılması Zero benzer sonuçlar döndürür.

Q1 - Zeros: 504           
Q1 - Ones: 496
Q2 - Zeros: 1000
Q2 - Ones: 0

İki kubiti dolanıklık

Dolanıklığı Q# etkinleştirmek için, Controlled-NOTCNOTolan işlemi sağlar. Bu işlemi iki kubit üzerinde çalıştırmanın sonucu, ilk kubit ise ikinci kubiti çevirmektir One.

İşlemi, işlemden CNOT hemen sonra H programınıza ekleyin. Tam programınız şu şekilde görünmelidir:

import Microsoft.Quantum.Intrinsic.*;
import Microsoft.Quantum.Canon.*;

    operation SetQubitState(desired : Result, target : Qubit) : Unit {
        if desired != M(target) {
            X(target);
        }
    }

operation Main() : (Int, Int, Int, Int) {
    mutable numOnesQ1 = 0;
    mutable numOnesQ2 = 0;
    let count = 1000;
    let initial = Zero;

    // allocate the qubits
    use (q1, q2) = (Qubit(), Qubit());   
    for test in 1..count {
        SetQubitState(initial, q1);
        SetQubitState(Zero, q2);

        H(q1);            
        CNOT(q1, q2);      // Add the CNOT operation after the H operation

        // measure each qubit
        let resultQ1 = M(q1);            
        let resultQ2 = M(q2);           

        // Count the number of 'Ones' returned:
        if resultQ1 == One {
            numOnesQ1 += 1;
        }
        if resultQ2 == One {
            numOnesQ2 += 1;
        }
    }

    // reset the qubits
    SetQubitState(Zero, q1);             
    SetQubitState(Zero, q2);


    // Display the times that |0> is returned, and times that |1> is returned
    Message($"Q1 - Zeros: {count - numOnesQ1}");
    Message($"Q1 - Ones: {numOnesQ1}");
    Message($"Q2 - Zeros: {count - numOnesQ2}");
    Message($"Q2 - Ones: {numOnesQ2}");
    return (count - numOnesQ1, numOnesQ1, count - numOnesQ2, numOnesQ2 );

    }

Q1 - Zeros: 502           
Q1 - Ones: 498       // results will vary
Q2 - Zeros: 502
Q2 - Ones: 498
Result: "(502, 498, 502, 498)"

İlk kubitin istatistikleri değişmemiştir (ölçümden sonraki bir veya Zero 50/50 olasılıkOne) ancak ikinci kubitin ölçüm sonuçları her zaman ilk kubitin ölçümüyle aynıdır. İşlem CNOT iki kubiti dolanık yaptı, böylece bunlardan birine ne olursa olsun, diğerine de olur.

Sıklık histogramını çizme

Şimdi kuantum programını birden çok kez çalıştırarak elde edilen sonuçların dağılımını görselleştirelim. Sıklık histogramı bu sonuçların olasılık dağılımını görselleştirmeye yardımcı olur.

Görünüm -> Komut Paleti'ni seçin veya Ctrl+Shift+P tuşlarına basın ve "histogram" yazın. Bu, şu seçeneği göstermelidirQ#: Dosyayı çalıştır ve histogramı göster seçeneği. Yukarıdaki komut listesinden Histogram'ıMain. Histogram penceresini açmak Q# için bu seçeneği belirleyin.
Programı yürütmek için 100 çekim gibi bir dizi çekim girin ve Enter tuşuna basın. Histogram, histogram penceresinde görüntülenir Q# .
Histogramdaki her çubuk olası bir sonuca karşılık gelir ve yüksekliği sonucun kaç kez gözlemlendiğini gösterir. Bu durumda, 50 farklı benzersiz sonuç vardır. Her sonuç için birinci ve ikinci kubit için ölçüm sonuçlarının her zaman aynı olduğunu unutmayın.

İpucu

Fare kaydırma tekerleğini veya izleme yüzeyi hareketini kullanarak histogramı yakınlaştırabilirsiniz. Yakınlaştırıldığında, kaydırma sırasında Alt tuşuna basarak grafiği kaydırabilirsiniz.
Bu sonucun yüzdesini görüntülemek için bir çubuk seçin.
Seçenekleri görüntülemek için sol üst ayarlar simgesini seçin. İlk 10 sonucu, ilk 25 sonucu veya tüm sonuçları görüntüleyebilirsiniz. Ayrıca sonuçları yüksekten düşüeğe veya düşükten yükseğe sıralayabilirsiniz.

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

Grover arama algoritması, Grover arama algoritmasını kullanan bir Q# programın nasıl yazıldığını gösterir.
Quantum Fourier Transform , belirli kubitleri doğrudan ele alan bir Q# programın nasıl yazıldığını keşfeder.
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.

The future is yours

Aracılığıyla paylaş

Öğretici: Ile kuantum dolanıklığı keşfetme Q#

Önkoşullar

Bilinen bir duruma kubit başlatma

Bell durumunu test etmek için bir test işlemi yazma

Azure Quantum için Copilot'ta kodu çalıştırma

Kubiti süper konuma yerleştirme

İki kubiti dolanıklık

Önkoşullar

Yeni Q# dosya oluşturma

Bilinen bir duruma kubit başlatma

Bell durumunu test etmek için bir test işlemi yazma

Kodu çalıştırma

Kubiti süper konuma yerleştirme

İki kubiti dolanıklık

Sıklık histogramını çizme

Geri Bildirim

Ek kaynaklar

The future is yours

Aracılığıyla paylaş

Öğretici: Ile kuantum dolanıklığı keşfetme Q#

Önkoşullar

Bilinen bir duruma kubit başlatma

Bell durumunu test etmek için bir test işlemi yazma

Azure Quantum için Copilot'ta kodu çalıştırma

Kubiti süper konuma yerleştirme

İki kubiti dolanıklık

Önkoşullar

Yeni Q# dosya oluşturma

Bilinen bir duruma kubit başlatma

Bell durumunu test etmek için bir test işlemi yazma

Kodu çalıştırma

Kubiti süper konuma yerleştirme

İki kubiti dolanıklık

Sıklık histogramını çizme

İlgili içerik

Geri Bildirim

Ek kaynaklar