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

2025-03-27

Bu öğreticide, kubitleri işleyen ve ölçen, süperpozisyon ve dolanıklığın etkilerini gösteren bir Q# programı yazacaksınız. Belirli bir kuantum durumunda iki kubit hazırlarsınız, Q# ile kubitler üzerinde çalışarak durumlarını nasıl değiştireceğinizi öğrenir ve süperpozisyon 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 değeri 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üperpozisyona 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 Azure Quantum'u keşfetme bölümüne bakın.

Kübiti bilinen bir duruma başlatın.

İlk adım, bir kubiti bilinen bir Q# duruma başlatan bir işlem tanımlamaktır. Bu işlem, bir kubiti klasik duruma ayarlamak için çağrılabilir. Yani, ölçüldüğünde ya Zero olarak %100 döner ya da One olarak %100 döner. Kübitin ölçülmesi, yalnızca Zero veya One değerine sahip olabilecek bir Q# türü Result dö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'ı seçmeyin; kodu dersin 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, bir kubitin durumunu dönüştüren M ve X olmak üzere iki standart işlemi tanıtır.

İşlem SetQubitState :

İki parametre alır: bir Result türü, desired adlı, kubitin (Zero veya One) olmasını istediğiniz durumu temsil eden ve bir Qubit türü.
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, bir ölçümün Zero ve One değerlerini tersine çevirecek şekilde değiştiren bir X işlemi çalıştırır. 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.

Aşağıdaki kodu SetQubitState işleminin altına, kod düzenleyicisi penceresine 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, count ve initial değişkenleri sırasıyla 1000 ve One olarak 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.
İki kubiti başlatmak için use ifadesini çağırır.
Yinelemeler için count döngüler. Her bir döngü için
1. Belirtilen initial değerini ilk kübitte ayarlamak için SetQubitState çağrılır.
2. İkinci kubiti bir Zero duruma ayarlamak için SetQubitState yeniden çağırır.
3. Her bir kubiti ölçmek için M işlemini kullanır.
4. Her bir kubit için One geri döndüren ölçüm sayısını depolar.
Döngü tamamlandıktan sonra, kubitleri bilinen bir duruma (Zero) sıfırlamak ve diğer kullanıcıların kubitleri bilinen bir durumda ayırmasına izin vermek için SetQubitState'i yeniden çağırır. use ifadesi, sıfırlama gerektirir.
Son olarak, Message işlevini kullanarak sonuçları döndürmeden önce Copilot çıkış pencerelerine yazdırır.

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

Süperpozisyon ve dolanıklık yordamlarına geçmeden önce, bu noktaya kadar kubitlerin başlatılmasını ve ölçülmesini görmek için kodu 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 initial'dan Zero'e değiştirir ve programı yeniden çalıştırırsanız, ilk kubitin de her seferinde Zero döndüğünü gözlemleyebilirsiniz.

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

İpucu

Ctrl-Z tuşlarına basın veya Düzenle Geri Al seçeneğini seçin ve yeniden çalıştırmadan önce koda bir test değişikliği eklediğinizde dosyanızı kaydedin.

Kübiti süperpozisyona yerleştirmek

Ş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 bir süperpozisyon durumuna koyarsınız; burada kubitin ölçümü, Zero durumunu ve One durumunu yaklaşık %50 olasılıkla döndürür. Kavramsal olarak, kübitin Zero veya One ölçülme olasılıklarının eşit olduğu düşünülebilir.

Bir kubiti süperpozisyona yerleştirmek için, Q#H veya Hadamard işlemini sağlar. X Daha önce geçen ve bir kubiti 0'dan 1'e (veya tam tersi) çeviren bilinen bir duruma kubit başlatma yordamındaki işlemi hatırlayın; H işlemi, kubiti yarı yolda, eşit olasılıkla Zero veya One durumuna getirir. Ölçüldüyse, süper pozisyondaki bir kubit yaklaşık olarak eşit sayıda Zero ve One sonuç döndürmelidir.

Yazılımda başlangıç değerini One olarak ayarlayarak Main işleminde değişiklik yapın ve H işlemi için bir satır ekleyin.

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% One ve 50% Zero'a yakın olurken, ikinci kubitin sonuçları her zaman Zero kalır.

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

İlk kubitin Zero ile başlatılması benzer sonuçlar verir.

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ığa sokun

Daha önce belirtildiği gibi dolanık kubitler birbirinden bağımsız olarak tanımlanamayacak şekilde bağlanır. Yani, bir kübite ne işlem yapılırsa yapılsın, dolanık kübit için de aynı işlem gerçekleşir. Bu, bir kubitin sonucunu ölçmeden, sadece diğer kubitin durumunu ölçerek bilmenizi sağlar. (Bu örnekte iki kubit kullanılır; ancak üç veya daha fazla kubiti dolanık hale getirmek de mümkündür).

Dolanıklığı etkinleştirmek için, Q#CNOT işlemini sağlar, bu işlem Kontrol Edilmiş DEĞİL anlamına gelir. İki kubit üzerinde bu işlemi çalıştırmanın sonucu, ilk kubit One ise ikinci kubitin çevrilmesidir.

CNOT işlemini, H işleminden hemen sonra 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. CNOT işlemi iki kubiti dolanık hale getirdi, böylece bunlardan birine ne olursa olsun diğerine de aynısı 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 Web'de VS Code'u açın.
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# .

Kubiti bilinen bir duruma başlat

İlk adım, bir kubiti bilinen bir Q# duruma başlatan bir işlem tanımlamaktır. Bu işlem, bir kubiti klasik bir duruma ayarlamak için çağrılabilir; bu, ya %100 zaman Zero döner ya da %100 zaman One döner 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:

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

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

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

SetQubitState işlemi:

İki parametre alır: İlki, kubitin bulunmasını istediğiniz durumu temsil eden bir tip Result, adlandırılan desired, (Zero veya One), diğeri ise bir tip 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, X işlemi çalıştırılır ve bu işlem, kubitin durumunu öyle bir hale çevirir ki, bir ölçümün Zero ve One döndüren olasılıkları tersine döner. Bu şekilde hedef SetQubitState kubiti her zaman istenen duruma getirir.

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

SetQubitState işleminden sonra, CreateBellStates.qs dosyanıza 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 count ve initial değişkenleri, sırasıyla 1000 ve One olarak 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.
İki kubiti başlatmak için use ifadesini çağırır.
Yinelemeler için count döngüler. Her döngü için
1. Belirtilen initial değerini ilk kubitte ayarlamak için SetQubitState çağrılır.
2. İkinci kubiti bir Zero durumuna ayarlamak için SetQubitState yeniden çağırır.
3. M işlemini her kubiti ölçmek için kullanır.
4. Her kubitin One döndürdüğü ölçüm sayısını depolar.
Döngü tamamlandıktan sonra, kubitleri bilinen bir duruma sıfırlamak için SetQubitState'yı yeniden çağırır ve bu da diğer kullanıcıların kubitleri bilinen bir durumda ayırmasına olanak tanır Zero. use deyimi tarafından kubitin sıfırlanması 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üperpozisyon ve dolanıklık işlemlerine geçmeden önce, kubitlerin başlatılması ve ölçülmesini görmek 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 açın, QIR için arama yapın ve ardından Azure Quantum QIR hedef profilini ayarlayın: sınırsız seçeneğini seçin.

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şlemin öncesindeki Main komutlar listesinden Çalıştır'ı seçin veya Ctrl+F5 tuşlarına basın. 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ştirirseniz ve programı yeniden çalıştırırsanız, ilk kubitin de her seferinde Zero döndüğünü 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.

Bir kubiti süperpozisyona yerleştirmek

Ş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 bir süperpozisyon durumuna koyarsınız; burada kubitin ölçümü %50 olasılıkla Zero ve %50 olasılıkla One döner. Kavramsal olarak, kubit Zero ile One arasında bir yarı yolda olarak düşünülebilir.

Bir kübiti süperpozisyona yerleştirmek için Q#, Hadamard operasyonunu sağlar. Daha önce, bir qubiti Zero durumundan One durumuna (veya tam tersi) çevirdiğimiz Bir kubiti bilinen bir duruma başlatma yordamındaki X işlemini hatırlayın; H işlemi ise qubiti, Zero veya One olma olasılıklarının eşit olduğu bir duruma kadar yarı yarıya çevirir. Ölçüldüyse, süper pozisyondaki bir kubit yaklaşık olarak eşit sayıda Zero ve One sonuç döndürmelidir.

Main işlemindeki kodu, H işlemini içerecek şekilde 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 One %50 ve Zero %50'ye yakın olurken, ikinci kubitin sonuçları her zaman Zero olarak kalır.
```
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ık hale getir

Daha önce belirtildiği gibi dolanık kubitler birbirinden bağımsız olarak tanımlanamayacak şekilde bağlanır. Başka bir ifadeyle, bir kubit ile gerçekleştirilen herhangi bir operasyon, dolanık kubite de aynı şekilde uygulanır. Bu, bir kubitin sonuç durumunu ölçmeden, yalnızca diğer kubitin durumunu ölçerek 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ığı etkinleştirmek için Q#, Controlled-NOT olarak adlandırılan CNOT işlemini sağlar. İki kubit üzerinde bu işlemi çalıştırmanın sonucu, eğer ilk kubit One ise ikinci kubiti çevirmektir.

H işleminden hemen sonra CNOT işlemini 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 qubitin istatistikleri değişmemiştir (ölçümden sonra Zero veya One olasılığı 50/50), ancak ikinci qubitin ölçüm sonuçları her zaman ilk qubitin ölçümüyle aynıdır. İşlem iki kubiti dolanık hale getirdi, böylece bunlardan birine ne olursa 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. Ayrıca, komutlar listesinden Main önceki Histogram'ı seçebilirsiniz. Histogram penceresini açmak Q# için bu seçeneği belirleyin.
Programı yürütmek için, örneğin 100 çekim gibi bir sayı girin ve Enter tuşuna basın. Histogram, Q# histogram penceresinde görüntülenir.
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ınıza uygun öğreticiler ve programlama egzersizleridir.

Aracılığıyla paylaş

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

Önkoşullar

Kübiti bilinen bir duruma başlatın.

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

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

Kübiti süperpozisyona yerleştirmek

İki kubiti dolanıklığa sokun

Önkoşullar

Yeni Q# dosya oluşturma

Kubiti bilinen bir duruma başlat

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

Kodu çalıştırma

Bir kubiti süperpozisyona yerleştirmek

İki kubiti dolanık hale getir

Sıklık histogramını çizme

İlgili içerik

Geri Bildirim

Ek kaynaklar