教學課程：使用探索量子糾纏 Q#

發行項
10/29/2024

在本教學課程中，您會撰寫一個 Q# 程式來操作和測量量子位，並示範迭加和糾纏的效果。您會在特定量子狀態準備兩個量子位，瞭解如何使用來操作量子位 Q# 來變更其狀態，並示範迭加和糾纏的效果。您可以逐一建置程式 Q# ，以介紹量子位狀態、作業和度量。

以下是開始之前要瞭解的一些重要概念：

其中傳統位會保存單一二進位值，例如 0 或 1，量子位的狀態可以是兩個量子狀態的迭加，0 和 1。每個可能的量子狀態都有相關聯的機率幅度。
測量量子位的動作會產生具有特定機率的二進制結果，並將量子位的狀態變更為迭加。
多個量子位可以糾纏，因此無法彼此獨立描述。也就是說，糾纏配對中的一個量子位也會發生在另一個量子位上。

在本教學課程中，您將了解如何：

建立 Q# 作業，將量子位初始化為所需的狀態。
將量子位置於迭加中。
糾纏一對量子位。
測量量子位並觀察結果。

提示

如果您想要加速量子運算旅程，請參閱使用 Azure Quantum 撰寫程式代碼，這是 Azure Quantum 網站的獨特功能。在這裡，您可以執行內Q#建範例或您自己的Q#程式、從提示產生新Q#程序代碼、在 VS Code for the Web 中開啟並執行程式碼，按兩下滑鼠，並詢問 Copilot 關於量子運算的任何問題。

必要條件

若要在適用於 Azure Quantum 的 Copilot 中執行程式代碼範例，您需要：

Microsoft （MSA）電子郵件帳戶。

如需 Copilot 的詳細資訊，請參閱探索 Azure Quantum。

將量子位初始化為已知狀態

第一個步驟是定義 Q# 將量子位初始化為已知狀態的作業。您可以呼叫此作業，將量子位設定為傳統狀態，這表示測量時，它會傳回 Zero 100% 的時間或傳 One 回 100% 的時間。測量量子位會Q#傳回型Result別，其只能有或One的值Zero。

開啟適用於 Azure Quantum 的 Copilot，並將下列程式代碼複製到程式代碼編輯器視窗中。請勿按兩下 [執行 ];您稍後會在教學課程中執行程序代碼。

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

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

程式碼範例引進兩個標準作業，M 以及 X，其會轉換量子位元的狀態。

SetQubitState 作業：

接受兩個參數：名為的型Result別，表示量子位在中所需的狀態，OneZero以及類型 Qubit。desired
執行測量作業 M，其會測量量子位元 (Zero 或 One) 的狀態，並將結果與 desired 中指定的值進行比較。
如果度量不符合比較值，則會執行 X 作業，將量子位元的狀態翻轉為傳回 Zero 且反轉 One 的測量機率。如此一來，SetQubitState 一律會將目標量子位元置於所需的狀態。

撰寫測試作業以測試 Bell 狀態

接下來，為了示範 SetQubitState 作業的效果，請建立另一個名為 Main 的作業。此作業會配置兩個量子位，呼叫 SetQubitState 以將第一個量子位設定為已知狀態，然後測量量子位以查看結果。

將下列程式代碼複製到作業下方 SetQubitState 的程式代碼編輯器視窗中。

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 {
            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 );
}

在程式代碼中， count 和 initial 變數會分別設定為 1000 和 One 。這會將第一個量子位元初始化為 One，並測量每個量子位元 1000 次。

Main 作業：

設定計數器和初始量子位狀態的變數。
呼叫 use 陳述式來初始化兩個量子位元。
count 個反覆項目的迴圈。針對每個迴圈，將會
1. 呼叫 SetQubitState 以在第一個量子位元上設定指定的 initial 值。
2. 再次呼叫 SetQubitState，將第二個量子位元設定為 Zero 狀態。
3. 使用 M 作業來測量每個量子位元。
4. 儲存傳回 One 的每個量子位元的度量數目。
迴圈完成之後，會再次呼叫 SetQubitState，將量子位元重設為已知狀態 (Zero)，以允許其他人以已知狀態配置量子位元。語句需要 use 重設。
最後，它會使用函 Message 式將結果列印至 Copilot 輸出視窗，再傳回結果。

在適用於 Azure Quantum 的 Copilot 中執行程式代碼

在繼續進行迭加和糾纏的程式之前，您可以測試程式代碼到這個點，以查看量子位的初始化和測量。

若要以獨立程式執行程序代碼， Q# Copilot 中的編譯程式必須知道 程式要從何處 啟動程式。因為未指定命名空間，編譯程式會將預設進入點辨識為 Main 作業。如需詳細資訊，請參閱專案和隱含命名空間。

您的 Q# 程式現在看起來應該像這樣：

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 {
            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 );

}

將完整的程式代碼範例複製並貼到適用於 Azure Quantum 程式代碼的 Copilot 視窗中，將投影片的拍攝次數設定為 “1”，然後按兩下 [ 執行]。結果會顯示在直方圖和 [結果] 欄位中。

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

因為量子位元尚未操作，所以已保留其初始值：第一個量子位元每次都會傳回 One，而第二個量子位元會傳回 Zero。

如果您將的值 initial 變更為 Zero ，然後再次執行程式，您應該觀察第一個量子位每次也會傳 Zero 回。

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

提示

選取 Ctrl-Z 或 [編輯 > 復原] ，並在您引入測試變更程式碼之前儲存盤案，然後再再次執行。

將量子位置於迭加

目前，程式中的量子位元全都處於傳統狀態，也就是 1 或 0。您知道這一點，因為程式會將量子位元初始化為已知狀態，而且您尚未新增任何程式來進行操作。糾纏量子位之前，您會將第一個 量子位放入迭加狀態，其中量子位的測量會 Zero 傳回大約 50% 的時間和 One 大約 50% 的時間。就概念上講，量子位可以視為測量或One的機率Zero相等。

若要將量子位置於迭加中， Q# 請提供 H、或 Hadamard，作業。 X請記得稍早將量子位初始化為已知狀態程式的作業，其會將量子位從 0 翻轉為 1（反之亦然）：H作業會將量子位翻轉為或 One的等機率Zero狀態。測量時，疊加中的量子位元應該傳回大約相等數目 Zero 和 One 個結果。

將初始值One重設為，並插入H作業行，以修改作業中的Main程式碼：

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); 
        ...

現在當您執行程式時，您可以看到迭加中第一個量子位的結果。

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

每次執行程式時，第一個量子位的結果會稍有不同，但會接近 50% One 和 50%， Zero而第二個量子位的結果一直維持 Zero 不變。

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

初始化第一個量子位元為 Zero 以傳回類似的結果。

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

注意

藉由移動適用於 Azure Quantum 的 Copilot 滑桿並增加拍攝次數，您可以看到迭加結果在拍攝分佈上稍有不同。

糾纏兩個量子位

如先前所述，糾纏量子位會連線，因此無法彼此獨立描述。也就是說，無論一個量子位發生何種作業，也會發生在糾纏的量子位上。這可讓您知道一個量子位的結果狀態，而不需要測量它，只要測量另一個量子位的狀態。（此範例使用兩個量子位;不過，也可以糾纏三個或多個量子位。

若要啟用糾纏， Q# 請提供 CNOT 代表 Controlled-NOT 的作業。對兩個量子位元執行這項作業的結果是：如果第一個量子位元是 One，就會翻轉第二個量子位元。

在作業之後H立即將CNOT作業新增至您的程式。您的完整程式看起來應該像這樣：

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 {
            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           // results will vary
Q1 - Ones: 498
Q2 - Zeros: 502
Q2 - Ones: 498

請注意，第一個量子位的統計數據尚未變更（測量后仍有 ~50/50 的機率ZeroOne），但第二個量子位的度量結果一律與第一個量子位的測量相同，無論您執行程式多少次。 CNOT 作業讓這兩個量子位元相互糾纏，因此其中一個量子位元發生的情況，也會出現在另一個量子位元上。

必要條件

若要在您的本機開發環境中開發和執行程式碼範例：

最新版的 Visual Studio Code 或開啟 Web上的 VS Code。
最新版的 Azure Quantum 開發套件延伸模組。如需安裝詳細數據，請參閱在 VS Code 上安裝 QDK。

建立新 Q# 檔案

開啟 Visual Studio Code，然後選取 [檔案 > 新增文字檔] 以建立新的檔案。
將檔案儲存為 CreateBellStates.qs。此檔案將包含 Q# 程式的程序代碼。

將量子位初始化為已知狀態

第一個步驟是定義 Q# 將量子位初始化為已知狀態的作業。您可以呼叫此作業，將量子位設定為傳統狀態，這表示它會傳回 Zero 100% 的時間或傳 One 回 100% 的時間。 Zero 和 One 是 Q# 值，僅代表量子位測量的兩個可能結果。

開啟 CreateBellStates.qs 並複製下列程式代碼：

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

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

程式碼範例引進兩個標準作業，M 以及 X，其會轉換量子位元的狀態。

SetQubitState 作業：

接受兩個參數：名為的型Result別，表示量子位在中所需的狀態，OneZero以及類型 Qubit。desired
執行測量作業 M，其會測量量子位元 (Zero 或 One) 的狀態，並將結果與 desired 中指定的值進行比較。
如果度量不符合比較值，則會執行 X 作業，將量子位元的狀態翻轉為傳回 Zero 且反轉 One 的測量機率。如此一來，SetQubitState 一律會將目標量子位元置於所需的狀態。

撰寫測試作業以測試 Bell 狀態

在作業之後SetQubitState，將下列作業新增至您的CreateBellStates.qs檔案：

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 {
            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 );
}

在程式代碼中， count 和 initial 變數會分別設定為 1000 和 One 。此步驟會將第一個量子位初始化為， One 並測量每個量子位 1000 次。

Main 作業：

採用兩個參數：count、執行度量的次數，以及 initial 初始化量子位元所需的狀態。
呼叫 use 陳述式來初始化兩個量子位元。
count 個反覆項目的迴圈。針對每個迴圈，將會
1. 呼叫 SetQubitState 以在第一個量子位元上設定指定的 initial 值。
2. 再次呼叫 SetQubitState，將第二個量子位元設定為 Zero 狀態。
3. 使用 M 作業來測量每個量子位元。
4. 儲存傳回 One 的每個量子位元的度量數目。
迴圈完成之後，會再次呼叫 SetQubitState，將量子位元重設為已知狀態 (Zero)，以允許其他人以已知狀態配置量子位元。語句需要 use 重設量子位。
最後，它會使用函 Message 式將訊息列印至主控台，再傳回結果。

執行程式碼

在移至疊加和糾纏的程序之前，請先測試這段時間點的程式碼，以查看量子位元的初始化和測量。

若要以獨立程式執行程式代碼，編譯 Q# 程式必須知道 程式在何處 啟動程式。因為未指定命名空間，編譯程式會將預設進入點辨識為 Main 作業。如需詳細資訊，請參閱專案和隱含命名空間。

到目前為止，您的 CreateBellStates.qs 檔案現在看起來應該像這樣：

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 {
            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 );
}

執行程式之前，請確定目標配置檔設定為 [不受限制]。選取 [檢視 -> 命令選擇區]，搜尋 QIR，選取 Q#：設定 Azure Quantum QIR 目標設定檔，然後選取 Q#：不受限制。

注意

如果目標設定檔未設定為 [不受限制]，當您執行程式時會收到錯誤。
若要執行程式，請從右上方的播放圖示下拉式清單中選取 [執行Q#檔案]、從作業之前的Main命令清單中選取 [執行]，或按 Ctrl+F5。程式會在預設模擬器上執行 Main 作業。
您的輸出會出現在偵錯控制台中。
```
Q1 - Zeros: 0
Q1 - Ones: 1000
Q2 - Zeros: 1000
Q2 - Ones: 0
```
因為量子位元尚未操作，所以已保留其初始值：第一個量子位元每次都會傳回 One，而第二個量子位元會傳回 Zero。
如果您將的值 initial 變更為 Zero ，然後再次執行程式，您應該觀察第一個量子位每次也會傳 Zero 回。
```
Q1 - Zeros: 1000
Q1 - Ones: 0
Q2 - Zeros: 1000
Q2 - Ones: 0
```

提示

選取 Ctrl-Z 或 [編輯 > 復原] ，並在您引入測試變更程式碼之前儲存盤案，然後再再次執行。

將量子位置於迭加

目前，程式中的量子位元全都處於傳統狀態，也就是 1 或 0。您知道這一點，因為程式會將量子位元初始化為已知狀態，而且您尚未新增任何程式來進行操作。糾纏量子位之前，您會將第一個 量子位放入迭加狀態，其中量子位的測量會 Zero 傳回 50% 的時間和 One 50% 的時間。就概念上講，量子位可以視為和 One之間的Zero一半。

若要將量子位置於迭加中， Q# 請提供 H、或 Hadamard，作業。 X請記得稍早將量子位初始化為已知狀態程式的作業，此程式會將量子位從 Zero 翻轉為 One （反之亦然H）：作業會將量子位翻轉成等於或 One的機率Zero狀態。測量時，疊加中的量子位元應該傳回大約相等數目 Zero 和 One 個結果。

修改工作中的 Main 程式碼以包含 H 工作：

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); 
        ...

現在當您執行程式時，您可以看到迭加中第一個量子位的結果：

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

每次執行程式時，第一個量子位的結果會稍有不同，但會接近 50% One 和 50%， Zero而第二個量子位的結果一直維持 Zero 不變。
```
Q1 - Zeros: 510           
Q1 - Ones: 490
Q2 - Zeros: 1000
Q2 - Ones: 0
```

初始化第一個量子位元為 Zero 以傳回類似的結果。

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

糾纏兩個量子位

在作業之後H立即將CNOT作業新增至您的程式。您的完整程式看起來應該像這樣：

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 {
            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
Result: "(502, 498, 502, 498)"

第一個量子位的統計數據尚未變更（測量后的 50/50 機率ZeroOne），但第二個量子位的度量結果一律與第一個量子位的測量結果相同。作業 CNOT 糾纏著兩個量子位，因此無論其中一個量子位發生什麼情況，都發生在另一個量子位上。

繪製頻率直方圖

讓我們以可視化方式呈現從執行量子程式多次取得的結果分佈。頻率直方圖有助於可視化這些結果的機率分佈。

選取 [檢視 -> 命令選擇區]，或按 Ctrl+Shift+P，然後輸入「直方圖」，其中應該會顯示 Q#：執行檔案並顯示直方圖 選項。您也可以從前面的Main命令清單中選取直方圖。選取此選項以開啟 Q# 直方圖視窗。
輸入數 次執行 程式，例如 100 次拍攝，然後按 Enter 鍵。直方圖會顯示在 Q# 直方圖視窗中。
直方圖中的每個直方圖都會對應至可能的結果，其高度代表觀察到結果的次數。在此情況下，有50個不同的唯一結果。請注意，針對每個結果，第一個和第二個量子位的測量結果一律相同。

提示

您可以使用滑鼠滾動滾輪或軌跡板手勢來縮放直方圖。放大時，您可以在捲動時按 Alt 來平移圖表。
選取長條以顯示 該結果的百分比 。
選取左 上方的設定圖示 以顯示選項。您可以顯示前 10 個結果、前 25 個結果或所有結果。您也可以將結果從高到低或低到高排序。

探索其他 Q# 教學課程：

Grover 的搜尋演算法示範如何撰寫 Q# 使用 Grover 搜尋演算法的程式。
Quantum Fourier Transform 會探索如何撰寫 Q# 直接尋址特定量子位的程式。
Quantum Katas 是自我節奏的教學課程和程序設計練習，旨在同時教學量子運算和Q#程序設計元素。

共用方式為

教學課程：使用探索量子糾纏 Q#

必要條件

將量子位初始化為已知狀態

撰寫測試作業以測試 Bell 狀態

在適用於 Azure Quantum 的 Copilot 中執行程式代碼

將量子位置於迭加

糾纏兩個量子位

必要條件

建立新 Q# 檔案

將量子位初始化為已知狀態

撰寫測試作業以測試 Bell 狀態

執行程式碼

將量子位置於迭加

糾纏兩個量子位

繪製頻率直方圖

意見反應

其他資源

共用方式為

教學課程：使用 探索量子糾纏 Q#

必要條件

將量子位初始化為已知狀態

撰寫測試作業以測試 Bell 狀態

在適用於 Azure Quantum 的 Copilot 中執行程式代碼

將量子位置於迭加

糾纏兩個量子位

必要條件

建立新 Q# 檔案

將量子位初始化為已知狀態

撰寫測試作業以測試 Bell 狀態

執行程式碼

將量子位置於迭加

糾纏兩個量子位

繪製頻率直方圖

相關內容

意見反應

其他資源

教學課程：使用探索量子糾纏 Q#