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

Makale
07/03/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, bilinen bir Q# duruma bir kubit başlatacak bir işlem tanımlamaktır. Bu, 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üğü One anlamına gelir. Kubitin ölçülmesi, yalnızca veya Onedeğerine Zero sahip olabilecek bir Q# türü Resultdöndürür.

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

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open 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 One) olmasını istediğiniz durumu temsil eden adlı desiredbir tür Resultve bir türüQubit.Zero
Kubitin (Zero veya One) durumunu ölçen ve sonucu içinde desiredbelirtilen değerle karşılaştıran bir ölçüm işlemi Mgerçekleştirir.
Ölçüm, karşılaştırılan değerle eşleşmiyorsa, kubitin durumunu döndüren Zero ve One ters çevrilen bir ölçümün olasılıklarını çeviren bir işlem çalıştırırX. 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ı TestBellStatebaş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 TestBellState() : (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 {
            set numOnesQ1 += 1;
        }
        if resultQ2 == One {
            set 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 One olarak 1000 ayarlanır. Bu, ilk kubiti One başlatır ve her kubiti 1000 kez ölçer.

İşlem TestBellState:

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 initial değeri ayarlamak için çağrılarSetQubitState.
2. İkinci kubiti bir Zero duruma ayarlamak için yeniden çağırırSetQubitState.
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 (Zero) sıfırlamak için yeniden çağırırSetQubitState. Bu, use deyimi için 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. Bu işlem, önce çalıştırmak istediğiniz işlemin hemen önüne eklenerek @EntryPoint() dosyada Q# gerçekleştirilir. Örneğin, bu durumda işlemdir TestBellState .

Not

@EntryPoint() yalnızca tek başına Q# programlar için gereklidir. Jupyter Notebooks'ta bir Q# program çalıştırırken veya Python konak dosyasından bir Q# program çağırırken gerekli değildir ve dahil edildiğinde hata oluşturur.

İşlemden hemen önce TestBellState öğesini @EntryPoint() ekleyin; programınız Q# bu noktaya kadar şu şekilde görünmelidir:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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 );

    }
}

Kod örneğinin tamamını kopyalayıp Azure Quantum için Copilot kod penceresine yapıştırın, çekim sayısı için slaydı "1" olarak ayarlayın ve Çalıştır'a tıklayın. 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

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 getirmeden önce ilk kubiti süper konum durumuna koyacaksınız. Burada kubitin ölçümü zamanın yaklaşık %50'sini ve One %50'sini döndürür Zero . Kavramsal olarak, kubitin veya Oneölçme Zero olasılığının eşit olduğu düşünülebilir.

Bir kubiti süper konuma yerleştirmek için , Q# veya Hadamard, işlemini sağlarH. 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 veya Oneeşit olasılıklara Zero sahip bir duruma çevirir. Ö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 One sıfırlayarak ve işlem için bir satır ekleyerek işlemdeki H kodu TestBellState 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

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-NOT ifadesinin kısaltması olan işlemi sağlarCNOT. 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:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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 One daha sonra ölçüm için yaklaşık 50/50 olasılık Zero 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 . VS Code'da QDK'yi yükleme.

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, bilinen bir Q# duruma bir kubit başlatacak bir işlem tanımlamaktır. Bu, kubiti klasik bir duruma ayarlamak için çağrılabilir; başka bir deyişle zamanın %100'ünün döndürüldüğü Zero veya %100'ünün döndürüldüğü One anlamına gelir. 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:

   namespace Bell {
       open Microsoft.Quantum.Intrinsic;
       open 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 One) olmasını istediğiniz durumu temsil eden adlı desiredbir tür Resultve bir türüQubit.Zero
Kubitin (Zero veya One) durumunu ölçen ve sonucu içinde desiredbelirtilen değerle karşılaştıran bir ölçüm işlemi Mgerçekleştirir.
Ölçüm, karşılaştırılan değerle eşleşmiyorsa, kubitin durumunu döndüren Zero ve One ters çevrilen bir ölçümün olasılıklarını çeviren bir işlem çalıştırırX. Bu şekilde hedef SetQubitState kubiti her zaman istenen duruma getirir.

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

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

operation TestBellState() : (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 {
            set numOnesQ1 += 1;
        }
        if resultQ2 == One {
            set 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 One olarak 1000 ayarlanır. Bu, ilk kubiti One başlatır ve her kubiti 1000 kez ölçer.

İşlem TestBellState:

İ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 initial değeri ayarlamak için çağrılarSetQubitState.
2. İkinci kubiti bir Zero duruma ayarlamak için yeniden çağırırSetQubitState.
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 (Zero) sıfırlamak için yeniden çağırırSetQubitState. Bu, use deyimi 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.

Bu işlem, çalıştırmak istediğiniz işlemin hemen önüne bir @EntryPoint() eklenerek dosyada Q# gerçekleştirilir. Örneğin, bu durumda işlemdir TestBellState .

Not

Dosyanız CreateBellStates.qs şu şekilde görünmelidir:

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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 profili Sınırsız olarak ayarlamanız gerekir. Görünüm - Komut Paleti'ni seçin, QIR'yi arayın, öğesini seçinQ#: Azure Quantum QIR hedef profilini 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, aşağıdaki @EntryPoint()komut listesinden Çalıştır'a tıklayın veya Ctrl+F5 tuşlarına basın.Q# Program, varsayılan simülatörde @EntryPoint() özniteliğiyle işaretlenmiş işlemi veya işlevi çalıştırır.
Çıktı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

Yeniden çalıştırmadan önce koda her değişiklik eklediğinizde dosyanızı kaydetmeyi unutmayın.

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 getirmeden önce ilk kubiti süper konum durumuna koyacaksınız. Burada kubitin ölçümü zamanın %50'sini ve One %50'sini döndürürZero. Kavramsal olarak, kubit ile Onearasında Zero bir yarı olarak düşünülebilir.

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

İşlemdeki TestBellState 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

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

namespace Bell {
    open Microsoft.Quantum.Intrinsic;
    open Microsoft.Quantum.Canon;

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

    @EntryPoint()
    operation TestBellState() : (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);

            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 {
                set numOnesQ1 += 1;
            }
            if resultQ2 == One {
                set 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

İlk kubitin istatistikleri değişmemiştir (ölçümden sonraki bir veya One 50/50 olasılıkZero) 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. Histogram'a aşağıdaki @EntryPoint()komut listesinden de tıklayabilirsiniz. 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ırdığınızda, kaydırma sırasında 'Alt' tuşuna basarak grafiği kaydırabilirsiniz.
Bu sonucun yüzdesini görüntülemek için bir çubuğu tıklatın.
Seçenekleri görüntülemek için sol üst ayarlar simgesine tıklayın. İ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.

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

Geri Bildirim

Ek kaynaklar

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

Geri Bildirim

Ek kaynaklar