แบบฝึกหัด - สร้างสถานะการซ้อนทับที่แตกต่างกันด้วย Q#

  • 12 นาที

ในหน่วยก่อนหน้า คุณได้เรียนรู้เกี่ยวกับการซ้อนทับและเครื่องหมาย Dirac นั่นเป็นทฤษฎีที่เพียงพอสําหรับตอนนี้! มาเขียนโค้ดเพื่อสํารวจการซ้อนทับใน Q# กันเถอะ

ในหน่วยนี้ คุณสร้างสถานะการซ้อนทับควอนตัมใน Q# และสํารวจบทบาทของความน่าจะเป็นในผลการวัด คุณยังใช้ฟังก์ชันใน DumpMachine Q# เพื่อตรวจสอบว่าสถานะของระบบเปลี่ยนแปลงอย่างไรในระหว่างการคํานวณควอนตัม

สร้างไฟล์ Q# ใหม่

  1. เปิด Visual Studio Code (VS Code)
  2. เปิดเมนู แฟ้ม แล้วเลือก แฟ้มข้อความใหม่ เพื่อสร้างแฟ้มใหม่
  3. บันทึกไฟล์เป็น Main.qs

เริ่มต้นใช้งานการซ้อนทับ

เริ่มต้นด้วยโปรแกรม Q# ง่ายๆ ที่ใช้คิวบิตในสถานะการซ้อนทับเพื่อสร้างค่าบิตแบบสุ่ม 0 หรือ 1 ในโค้ดของเรา เราใช้ฟังก์ชันเพื่อดู DumpMachine สถานะของคิวบิตที่จุดต่างๆ ในโปรแกรม

  1. คัดลอก และวางรหัสต่อไปนี้ลงในแฟ้ม Main.qs :

    import Std.Diagnostics.*;

operation Main() : Result {
    use q = Qubit();
    Message("Initialized qubit:");
    DumpMachine(); // First dump
    Message(" ");
    H(q);
    Message("Qubit after applying H:");
    DumpMachine(); // Second dump
    Message(" ");
    let randomBit = M(q);
    Message("Qubit after the measurement:");
    DumpMachine(); // Third dump
    Message(" ");
    Reset(q);
    Message("Qubit after resetting:");
    DumpMachine(); // Fourth dump
    Message(" ");
    return randomBit;
}

  2. หากต้องการเรียกใช้โปรแกรมของคุณบนเครื่องจําลองในตัว ให้เลือก เรียกใช้เลนส์โค้ด เหนือMainการทํางาน หรือกด Ctrl + F5 ผลลัพธ์ของคุณจะปรากฏในคอนโซลการแก้ไขข้อบกพร่อง

  3. ตรวจสอบคอนโซลดีบักเพื่อค้นหาผลลัพธ์ของการวัด Zero หรือOne

ฟังก์ชันนี้ DumpMachine สร้างตารางข้อมูลที่อธิบายสถานะของระบบควอนตัม ซึ่งในกรณีนี้คือคิวบิตเดียว ข้อมูลจาก DumpMachine รวมถึงแอมพลิจูดความน่าจะเป็น ความน่าจะเป็นในการวัด และเฟสเป็นเรเดียนสําหรับแต่ละสถานะพื้นฐาน

โค้ดของคุณเรียกใช้ฟังก์ชันสี่ DumpMachine ครั้ง:

  • หลังจากที่คุณจัดสรรคิวบิต
  • หลังจากที่คุณทําให้คิวบิตอยู่ในสถานะการซ้อนทับ
  • หลังจากที่คุณวัดสถานะของคิวบิต
  • หลังจากที่คุณรีเซ็ตคิวบิต

ลองตรวจสอบผลลัพธ์จากการเรียกแต่ละครั้งไปยัง DumpMachine:

  • คิวบิตที่เริ่มต้น: เมื่อคุณจัดสรรคิวบิตด้วย use คําสั่ง คิวบิตจะเริ่มต้นในสถานะ $|0\rangle$ เสมอ

    Initialized qubit:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

  • คิวบิตหลังจากใช้ H: หลังจากที่คุณใช้ H การดําเนินการ คิวบิตจะอยู่ในสถานะการซ้อนทับที่เท่ากัน $|\psi\rangle=\frac1{\sqrt2} |0\rangle + \frac1{\sqrt2} |1\rangle$

    Qubit after applying H:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
   |1⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • คิวบิตหลังการวัด: หลังจากที่คุณวัดคิวบิตแล้ว ผลลัพธ์จะเป็น หรือ อย่างOneใดอย่างZeroหนึ่ง และคิวบิตจะอยู่ในสถานะที่คุณวัดอย่างสมบูรณ์

    Qubit after the measurement:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |1⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

    โน้ต

    ผลลัพธ์ของคุณจาก DumpMachine การวัดหลังการวัดอาจแตกต่างจากเอาต์พุตตัวอย่าง เนื่องจากคุณมีโอกาส 50% ในการวัดแต่ละสถานะ ความน่าจะเป็นของผลลัพธ์เป็นแบบกําหนด แต่ผลลัพธ์ของการวัดแต่ละรายการไม่ใช่

  • คิวบิตหลังจากรีเซ็ต:Reset การดําเนินการจะรีเซ็ตคิวบิตเป็นสถานะ $|0\rangle$ เพื่อให้สามารถใช้อีกครั้งสําหรับการคํานวณในอนาคต

    Qubit after resetting:

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

สํารวจสถานะการซ้อนทับอื่นๆ

ตอนนี้คุณรู้วิธีตรวจสอบสถานะของระบบคิวบิตด้วย DumpMachineมาสํารวจการดําเนินการอื่นๆ ที่ทําให้ระบบเข้าสู่สถานะการซ้อนทับประเภทต่างๆ

ตัวสร้างบิตสุ่มปัจจุบันสร้างอย่างใดอย่างหนึ่ง Zero หรือ One มีความน่าจะเป็น 50% ในตัวอย่างถัดไป ความน่าจะเป็นไม่เท่ากัน

ตัวสร้างบิตแบบสุ่มเย็บ

สมมติว่าคุณต้องการสร้างตัวสร้างบิตแบบสุ่มที่เบ้ ซึ่งหมายความว่าความน่าจะเป็นที่จะได้รับZeroจะแตกต่างจากความน่าจะเป็นที่จะได้รับOne

ตัวอย่างเช่น คุณต้องการผลลัพธ์ Zero ด้วยความน่าจะเป็น $P$ และผลลัพธ์ One ที่มีความน่าจะเป็น $1 - P$ นี่คือสถานะ Qubit ที่ถูกต้องซึ่งสร้างตัวสร้างบิตแบบสุ่ม:

$$|\psi\rangle=\sqrt{P}|0\rangle+\sqrt{1 - P}|1\rangle$$

สําหรับสถานะนี้ $|\psi\rangle$, $\alpha=\sqrt{P}$ และ $\beta=\sqrt{1 - P}$ คือแอมพลิจูดความน่าจะเป็นของสถานะพื้นฐาน $|0\rangle$ และ $|1\rangle$ ตามลําดับ

ในการรับสถานะนี้ คุณสามารถใช้ตัวดําเนินการ $R_y(2\cos^{-1}\sqrt{P})$ ตามลําดับกับคิวบิตที่เริ่มต้นในสถานะ $|0\rangle$ เพื่อให้ได้ผลลัพธ์นี้ใน Q# ให้ใช้ไลบรารีจาก Ry มาตรฐาน

ปลาย

หากต้องการเรียนรู้เพิ่มเติมเกี่ยวกับการดําเนินการเชิงคณิตศาสตร์เบื้องหลังการปฏิบัติการแบบโควตาเดียว โปรดดูบทช่วยสอน Single-Qubit Gates ใน Quantum Katas

เมื่อต้องการสร้างสถานะการซ้อนทับแบบเบ้ใน Q# ให้ทําตามขั้นตอนเหล่านี้:

  1. แทนที่รหัสทั้งหมดใน Main.qs ด้วยตัวอย่างต่อไปนี้ แล้วบันทึกแฟ้ม ตัวอย่างนี้เลือก $\alpha$ ให้มีค่าประมาณ $\frac13$

    import Std.Diagnostics.*;
import Std.Math.*;

operation Main() : Result {
    use q = Qubit();
    let P = 0.333333; // P is 1/3
    Ry(2.0 * ArcCos(Sqrt(P)), q);
    Message("The qubit is in the desired state.");
    DumpMachine(); // Dump the state of the qubit 
    Message("Your skewed random bit is:");
    let skewedrandomBit = M(q);
    Reset(q);
    return skewedrandomBit;
}

  2. หากต้องการเรียกใช้โปรแกรมของคุณบนเครื่องจําลองในตัว ให้เลือก เรียกใช้เลนส์โค้ด เหนือMainการทํางาน หรือกด Ctrl + F5 ผลลัพธ์ของคุณจะปรากฏในคอนโซลการแก้ไขข้อบกพร่อง

  3. ตรวจสอบผลลัพธ์และ DumpMachine ผลการวัดของคุณ ตัวอย่างเช่น ผลลัพธ์จะคล้ายกับต่อไปนี้:

    The qubit is in the desired state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
   |0⟩ |  0.5773+0.0000𝑖 |    33.3333% |   0.0000
   |1⟩ |  0.8165+0.0000𝑖 |    66.6667% |   0.0000

Your skewed random bit is:

One

สังเกตว่าความน่าจะเป็นของ Zero ผลการวัดอยู่ที่ประมาณ 33.33% และความน่าจะเป็นของ One ผลลัพธ์อยู่ที่ประมาณ 66.67% ตัวสร้างบิตแบบสุ่มนี้เอียงไปทางOne

โน้ต

ผลลัพธ์การวัดของคุณอาจแตกต่างจากเอาต์พุตตัวอย่าง เนื่องจากตัวสร้างบิตแบบสุ่มมีความน่าจะเป็น ความน่าจะเป็นของผลลัพธ์เป็นแบบกําหนด แต่ผลลัพธ์ของการวัดแต่ละรายการไม่ใช่

การซ้อนทับแบบหลาย Qubit

จนถึงตอนนี้ เราได้พิจารณาเฉพาะระบบคิวบิตเดี่ยวเท่านั้น แต่คอมพิวเตอร์ควอนตัมที่ดีต้องการคิวบิตจํานวนมากเพื่อทําการคํานวณที่เป็นประโยชน์ สถานะควอนตัมและการซ้อนทับทํางานอย่างไรเมื่อระบบของเรามีคิวบิตมากกว่าหนึ่งคิวบิต

ตัวอย่างเช่น พิจารณาระบบสามคิวบิต แต่ละคิวบิตสามารถมีค่า 0 หรือ 1 เมื่อคุณวัด ดังนั้นจึงมีสถานะที่เป็นไปได้แปดสถานะที่คุณสามารถค้นหาระบบได้:

มุม\r$|000,|001 มุม\r,|010 มุม\r,|011 มุม\r,|100 มุม\r,|101 มุม\r, มุม |110\r,|111\rมุม $$

มีแปดสถานะที่เป็นไปได้สําหรับระบบนี้ เนื่องจากแต่ละคิวบิตสามารถเป็นสถานะ 0 หรือ 1 ได้อย่างอิสระเมื่อเราทําการวัด โดยทั่วไป จํานวนสถานะที่เป็นไปได้จะเท่ากับ $2^n$ โดยที่ $n$ คือจํานวนคิวบิต

เช่นเดียวกับคิวบิตเดียว สถานะการซ้อนทับโดยพลการสําหรับระบบ 3 คิวบิตจะแสดงเป็นผลรวมถ่วงน้ําหนักของแปดสถานะเหล่านี้ โดยที่น้ําหนักคือแอมพลิจูดความน่าจะเป็น:

$$|\psi\rangle=\alpha_0|000 มุม\r+\alpha_1|001 มุม\r+\alpha_2|010 มุม\r+\alpha_3|011 มุม\r+\alpha_4|100 มุม\r+\alpha_5|101 มุม\r+\alpha_6 |110 มุม\r+\alpha_7|111 มุม\r$$

แอมพลิจูด $\alpha_i$ เป็นจํานวนเชิงซ้อนที่ตรงตามเงื่อนไข $\sum\limits_{i=0}^{i=7}|\alpha_i|^2=1$

ตัวอย่างเช่น คุณสามารถวาง qubits ในการวางซ้อนทับแบบสม่ําเสมอโดยใช้ H กับแต่ละ qubit จากนั้นคุณสามารถใช้การซ้อนทับแบบสม่ําเสมอนี้เพื่อสร้างตัวสร้างตัวเลขสุ่มควอนตัมที่สร้างตัวเลขสามบิตแทนตัวเลขหนึ่งบิต:

สถานะพื้นฐาน เลข
$\ket{000}$ 0
$\ket{001}$ 4
$\ket{010}$ 2
$\ket{011}$ 6
$\ket{100}$ 1
$\ket{101}$ 5
$\ket{110}$ 3
$\ket{111}$ 7

โน้ต

วิธีมาตรฐานในการเขียนสตริงบิตคือการมีตัวเลขที่เล็กที่สุดทางด้านขวาและหลักที่ใหญ่ที่สุดทางด้านซ้าย เช่นเดียวกับตัวเลขทศนิยมปกติ ใน Q# (และภาษาโปรแกรมควอนตัมอื่น ๆ อีกมากมาย) ลําดับจะกลับด้านเพื่อให้ตัวเลขที่เล็กที่สุดอยู่ทางด้านซ้ายและตัวเลขที่ใหญ่ที่สุดอยู่ทางด้านขวา เนื่องจาก DumpMachine ฟังก์ชันแสดงสถานะควอนตัมในลําดับมาตรฐาน จํานวนเต็มทศนิยมที่สถานะสอดคล้องกันจึงไม่เรียงลําดับตามลําดับตั้งแต่ 0 ถึง $n-1$

ในการสร้างตัวสร้างตัวเลขสุ่มประเภทนี้ ให้ทําตามขั้นตอนเหล่านี้:

  1. แทนที่โค้ดของคุณใน Main.qs ด้วยตัวอย่างต่อไปนี้ แล้วบันทึกไฟล์:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register in a uniform superposition: ");
    DumpMachine();
    let result = MeasureEachZ(qubits);
    Message("Measuring the qubits collapses the superposition to a basis state.");
    DumpMachine();
    ResetAll(qubits);
    return ResultArrayAsInt(result);
}

  2. หากต้องการเรียกใช้โปรแกรมของคุณบนเครื่องจําลองในตัว ให้เลือก เรียกใช้เลนส์โค้ด เหนือMainการทํางาน หรือกด Ctrl + F5 ผลลัพธ์ของคุณจะปรากฏในคอนโซลการแก้ไขข้อบกพร่อง

  3. ตรวจสอบผลลัพธ์และ DumpMachine ผลการวัดของคุณ ตัวอย่างเช่น ผลลัพธ์จะคล้ายกับต่อไปนี้:

    The qubit register in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

Measuring the qubits collapses the superposition to a basis state.

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |011⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

6

    โน้ต

    ผลลัพธ์ของคุณอาจมีผลลัพธ์ที่แตกต่างจากเอาต์พุตตัวอย่าง เนื่องจากตัวสร้างตัวเลขสุ่มเป็นความน่าจะเป็น ความน่าจะเป็นของผลลัพธ์เป็นแบบกําหนด แต่ผลลัพธ์ของการวัดแต่ละรายการไม่ใช่

ในการทํางานกับหลายคิวบิต โค้ด Q# ของคุณจะมีการแก้ไขดังต่อไปนี้:

  • ตอนนี้ตัวแปร qubits แสดงอาร์เรย์ Qubit ที่มีความยาวสามรายการ
  • การดําเนินการ ApplyToEach และใช้ MeasureEachZ การดําเนินการควอนตัมกับคิวบิตหลายตัวด้วยโค้ดเพียงบรรทัดเดียว ไลบรารี Q# มีฟังก์ชันและการดําเนินการมากมายที่ทําให้การเขียนโปรแกรมควอนตัมง่ายขึ้นสําหรับคุณ
  • ฟังก์ชัน ResultArrayAsInt จาก Std.Convert ไลบรารีจะแปลงอาร์เรย์ไบนารี Result เป็นจํานวนเต็มทศนิยม

ผลลัพธ์จาก DumpMachine แสดงให้เห็นว่าการวัดจะยุบสถานะการซ้อนทับให้เป็นหนึ่งในแปดสถานะพื้นฐานที่เป็นไปได้ เช่นเดียวกับคิวบิตเดียว ตัวอย่างเช่น ถ้าคุณได้รับผลลัพธ์ 6แสดงว่าสถานะของระบบยุบลงเป็น $|011\rangle$

ตอนนี้เรามาดูกันว่าระบบเปลี่ยนแปลงไปอย่างไรเมื่อเราวัดแต่ละคิวบิต รหัสก่อนหน้านี้ใช้ MeasureEachZ การดําเนินการเพื่อวัดคิวบิตทั้งสามคิวบิตพร้อมกัน ลองใช้ for ลูปเพื่อวัดคิวบิตทีละคิวบิตแทน และใช้ DumpMachine เพื่อดูสถานะของระบบหลังการวัดแต่ละครั้ง

  1. แทนที่รหัสใน Main.qs ด้วยตัวอย่างต่อไปนี้ และจากนั้น บันทึกแฟ้ม:

    import Std.Diagnostics.*;
import Std.Convert.*;

operation Main() : Int {
    use qubits = Qubit[3];
    ApplyToEach(H, qubits);
    Message("The qubit register is in a uniform superposition: ");
    DumpMachine();
    mutable results = [];
    for q in qubits {
        Message(" ");
        results += [M(q)];
        DumpMachine();
    }
    ResetAll(qubits);
    Message("Your random number is: ");
    return ResultArrayAsInt(results);
}

  2. หากต้องการเรียกใช้โปรแกรมของคุณบนเครื่องจําลองในตัว ให้เลือก เรียกใช้เลนส์โค้ด เหนือMainการทํางาน หรือกด Ctrl + F5 ผลลัพธ์ของคุณจะปรากฏในคอนโซลการแก้ไขข้อบกพร่อง

  3. ตรวจสอบผลลัพธ์และ DumpMachine ผลการวัดของคุณ

ผลลัพธ์แสดงให้เห็นว่าการวัดต่อเนื่องแต่ละครั้งเปลี่ยนสถานะควอนตัมอย่างไร และด้วยเหตุนี้ความน่าจะเป็นที่จะได้รับผลลัพธ์แต่ละรายการ ตัวอย่างเช่น ลองตรวจสอบแต่ละส่วนของผลลัพธ์ในกรณีที่ผลลัพธ์ของคุณคือ 5:

  • การเตรียมสถานะ: ระบบอยู่ในสถานะการซ้อนทับที่เท่ากันหลังจากที่คุณใช้กับ H แต่ละคิวบิต

    The qubit register is in a uniform superposition: 

 Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |000⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |001⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |010⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |011⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |100⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |101⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |110⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000
 |111⟩ |  0.3536+0.0000𝑖 |    12.5000% |   0.0000

  • การวัดครั้งแรก: ผลลัพธ์คือ One การวัดครั้งแรก ดังนั้นตอนนี้สถานะที่เป็นไปได้เพียงอย่างเดียวที่ระบบสามารถจบลงได้คือสถานะที่บิตซ้ายสุดคือ 1 แอมพลิจูดของสถานะที่คิวบิตซ้ายสุดเป็น 0 หายไป และความน่าจะเป็นของสถานะที่เป็นไปได้ที่เหลือจะเพิ่มขึ้นจาก 12.5% เป็น 25.0% เพื่อให้ผลรวมของความน่าจะเป็นยังคงอยู่ที่ 100%

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |101⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |110⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000
 |111⟩ |  0.5000+0.0000𝑖 |    25.0000% |   0.0000

  • การวัดครั้งที่สอง: ผลลัพธ์คือ Zero การวัดครั้งที่สอง ดังนั้นตอนนี้สถานะที่เป็นไปได้เพียงอย่างเดียวที่ระบบสามารถจบลงได้คือสถานะที่บิตซ้ายสุดสองบิตคือ 10 ตอนนี้เราเหลือผลลัพธ์ที่เป็นไปได้เพียงสองประการเมื่อเราวัดคิวบิตที่สาม โดยมีความน่าจะเป็น 50% สําหรับแต่ละผลลัพธ์

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |100⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000
 |101⟩ |  0.7071+0.0000𝑖 |    50.0000% |   0.0000

  • การวัดครั้งที่สาม: ในการวัดครั้งที่สาม ผลลัพธ์คือOne ระบบได้รับการวัดอย่างสมบูรณ์ ดังนั้นจึงไม่อยู่ในสถานะการซ้อนทับตามที่คาดไว้อีกต่อไป

     Basis | Amplitude      | Probability | Phase
 -----------------------------------------------
 |101⟩ |  1.0000+0.0000𝑖 |   100.0000% |   0.0000

Your random number is: 

5

ด้วย Q# คุณสามารถสร้างระบบคิวบิต ทําให้คิวบิตอยู่ในสถานะการซ้อนทับ และตรวจสอบว่าระบบเปลี่ยนแปลงอย่างไรเมื่อคุณใช้การดําเนินการควอนตัมหรือทําการวัด