การแปลงฟูเรียเชิงควอนตัม

โมดูล Qiskit in Classrooms นี้ต้องการให้นักเรียนมี Python environment ที่ใช้งานได้พร้อมติดตั้งแพ็กเกจต่อไปนี้:

• qiskit v2.1.0 หรือใหม่กว่า
• qiskit-ibm-runtime v0.40.1 หรือใหม่กว่า
• qiskit-aer v0.17.0 หรือใหม่กว่า
• qiskit.visualization
• numpy
• pylatexenc

สำหรับการตั้งค่าและติดตั้งแพ็กเกจข้างต้น ดู คู่มือติดตั้ง Qiskit เพื่อรันงานบนคอมพิวเตอร์ควอนตัมจริง นักเรียนต้องสร้างบัญชี IBM Quantum® โดยทำตามขั้นตอนในคู่มือ ตั้งค่าบัญชี IBM Cloud

โมดูลนี้ผ่านการทดสอบและใช้เวลา QPU ไป 13 วินาที ตัวเลขนี้เป็นค่าประมาณ ปริมาณการใช้งานจริงของคุณอาจแตกต่างกัน

# Added by doQumentation — required packages for this notebook
!pip install -q numpy qiskit qiskit-aer qiskit-ibm-runtime

# Uncomment and modify this line as needed to install dependencies
#!pip install 'qiskit>=2.1.0' 'qiskit-ibm-runtime>=0.40.1' 'qiskit-aer>=0.17.0' 'numpy' 'pylatexenc'

บทนำ

การแปลงฟูเรีย (Fourier transform) เป็นเครื่องมือที่ใช้กันทั่วไปมากในคณิตศาสตร์ ฟิสิกส์ การประมวลผลสัญญาณ การบีบอัดข้อมูล และสาขาอื่นๆ อีกมากมาย การแปลงฟูเรียเชิงควอนตัม ที่ตั้งชื่อได้ตรงไปตรงมา เป็นพื้นฐานของอัลกอริทึมควอนตัมที่สำคัญที่สุดบางตัว

วันนี้ หลังจากทบทวนการแปลงฟูเรียแบบคลาสสิก เราจะพูดถึงวิธีที่เรานำการแปลงฟูเรียเชิงควอนตัมไปใช้บนคอมพิวเตอร์ควอนตัม จากนั้นเราจะหารืออยู่กับหนึ่งในการประยุกต์ใช้การแปลงฟูเรียเชิงควอนตัมกับอัลกอริทึมที่เรียกว่า phase estimation algorithm การประมาณเฟสเชิงควอนตัมเป็นซับรูทีนในอัลกอริทึมการแยกตัวประกอบที่มีชื่อเสียงของ Shor ซึ่งบางครั้งเรียกว่า "มงกุฎแก้วของการประมวลผลเชิงควอนตัม" โมดูลนี้ก้าวไปสู่โมดูลอีกตัวเกี่ยวกับอัลกอริทึมของ Shor แต่ยังออกแบบให้ยืนหยัดได้ด้วยตัวเอง การแปลงฟูเรียเชิงควอนตัมเป็นอัลกอริทึมที่น่าสนใจและมีประโยชน์ในตัวมันเอง!

การแปลงฟูเรียแบบคลาสสิก

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

มาดูตัวอย่างว่าการแปลงฟูเรียอาจช่วยให้เราหาว่าเครื่องดนตรีกำลังเล่นโน้ตใดโดยพิจารณาจาก waveform เสียง โดยทั่วไป เราเห็น waveform ที่แสดงในฐานเวลา นั่นคือ แอมพลิจูดของคลื่นแสดงเป็นฟังก์ชันของเวลา

เราสามารถแปลงฟูเรีย waveform นี้เพื่อไปจากฐานเวลาสู่ฐานความถี่:

ในฐานความถี่ เราสามารถเห็นยอดแหลมชัดเจนที่ประมาณ 260 Hz นั่นคือโน้ต C กลาง!

ตอนนี้ คุณอาจจะสามารถระบุได้ว่ากำลังเล่น C กลางโดยไม่ต้องใช้การแปลงฟูเรีย แต่ถ้าเล่นหลายโน้ตพร้อมกันล่ะ? waveform จะซับซ้อนขึ้นเมื่อเราพล็อตในฐานเวลา:

แต่สเปกตรัมความถี่ระบุยอดแหลมสามยอดอย่างชัดเจน:

นี่เป็นคอร์ด C major กำลังเล่นโน้ต C, E และ G

การวิเคราะห์ฟูเรียประเภทนี้สามารถช่วยให้เราดึงองค์ประกอบความถี่ของสัญญาณที่ซับซ้อนประเภทใดก็ได้

การแปลงฟูเรียแบบไม่ต่อเนื่อง

การแปลงฟูเรียมีประโยชน์สำหรับการประยุกต์ใช้การประมวลผลสัญญาณมากมาย แต่ในการประยุกต์ใช้งานจริงส่วนใหญ่ (รวมถึงตัวอย่างเพลงที่เราใช้ด้านบน) เราต้องการแปลงชุดข้อมูล $N$ จุดแบบไม่ต่อเนื่อง ไม่ใช่ฟังก์ชันต่อเนื่อง ในกรณีนี้ เราใช้ การแปลงฟูเรียแบบไม่ต่อเนื่อง (DFT) DFT กระทำบน vector $(x_0, ..., x_{N-1})$ และแมปไปยัง vector $(y_0, ..., y_{N-1})$ ตามสูตร:

$y_k = \frac{1}{\sqrt{N}}\sum_{j=0}^{N-1}x_j\omega_N^{jk}$

โดยที่เรานิยาม $\omega_N^{jk} = e^{2\pi i \frac{jk}{N}}$ (สังเกตว่ามี convention อื่นที่มีเครื่องหมายลบในเลขชี้กำลัง ดังนั้นควรระวังเมื่อเห็น DFT ในที่อื่น) จำว่า $e^{2\pi i \frac{jk}{N}}$ เป็นฟังก์ชันคาบ ด้วยคาบ $\frac{N}{k}$ ดังนั้น โดยการคูณด้วยฟังก์ชันนี้ การแปลงฟูเรียจึงเป็นวิธีแยก (แบบไม่ต่อเนื่อง) ฟังก์ชัน $\{x_{j}\}$ ออกเป็นการรวมเชิงเส้นของฟังก์ชันคาบที่ประกอบขึ้น โดยแต่ละตัวมีคาบ $\frac{N}{k}$

การแปลงฟูเรียเชิงควอนตัม

ตอนนี้ เราเห็นแล้วว่าการแปลงฟูเรียถูกใช้เพื่อแสดงฟังก์ชันเป็นการรวมเชิงเส้นของชุด "ฟังก์ชันฐาน" ใหม่ การแปลงฐานถูกทำกับสถานะ Qubit เป็นประจำเช่นกัน ตัวอย่างเช่น สถานะของ Qubit เดี่ยว $|\psi\rangle$ สามารถแสดงในฐาน computational $|\psi\rangle = c_0 |0\rangle + c_1 |1\rangle$ พร้อมสถานะฐาน $|0\rangle$ และ $|1\rangle$ หรือในฐาน $X$ $|\psi\rangle = c_+ |+\rangle + c_- |-\rangle$ พร้อมสถานะฐาน $|+\rangle = \frac{1}{\sqrt{2}} (|0\rangle + |1\rangle)$ และ $|-\rangle = \frac{1}{\sqrt{2}} (|0\rangle - |1\rangle)$ ทั้งสองถูกต้องเท่าเทียมกัน แต่อย่างใดอย่างหนึ่งอาจเป็นธรรมชาติกว่าขึ้นอยู่กับประเภทของปัญหาที่พยายามแก้

สถานะ Qubit ยังสามารถแสดงในฐานฟูเรียที่สถานะแสดงในรูปของการรวมเชิงเส้นของสถานะฐานฟูเรีย $|\phi_y\rangle$ แทนสถานะฐาน computational ปกติ $|x\rangle$ ในการทำเช่นนี้ คุณต้องนำการแปลงฟูเรียเชิงควอนตัม (QFT) ไปใช้:

$| \phi_y \rangle = \frac{1}{\sqrt{N}}\sum_{x=0}^{N-1}\omega_N^{y x} \vert x \rangle$

โดยที่ $\omega_N^{yx} = e^{\frac{2\pi i y x}{N}}$ ดังที่กล่าวข้างต้น และ $N$ คือจำนวนสถานะฐานในระบบควอนตัมของคุณ สังเกตว่าเนื่องจากตอนนี้เราทำงานกับ Qubit $m$ Qubit ให้ $2^m$ สถานะฐาน ดังนั้น $N=2^m$ ที่นี่ สถานะฐานเขียนเป็นตัวเลขเดี่ยว $|x\rangle$ โดยที่ $x$ มีค่าตั้งแต่ $0$ ถึง $N-1$ แต่โดยทั่วไปคุณอาจเห็นสถานะฐานแสดงเป็น $|00...00\rangle$, $|00...01\rangle$, $|00...11\rangle$, ..., $|11...11\rangle$ โดยแต่ละหลักไบนารีแสดงสถานะของ Qubit 0 ถึง $m-1$ จากขวาไปซ้าย มีวิธีง่ายๆ ในการแปลงสถานะไบนารีเหล่านี้เป็นตัวเลขเดี่ยว: แค่ถือว่ามันเป็นเลขฐานสอง! ดังนั้น $|00...00\rangle = |0\rangle$, $|00...01\rangle = |1\rangle$, $|00...10\rangle = |2\rangle$, $|00...11\rangle = |3\rangle$ และต่อเนื่องไปจนถึง $|11...11\rangle = |2^m -1\rangle = |N-1\rangle$

สร้างสัญชาตญาณสำหรับสถานะฐานฟูเรีย

ดังนั้น เพิ่งอธิบายไปแล้วว่าสถานะฐาน computational คืออะไรและเรียงลำดับอย่างไร: พวกมันคือชุดของสถานะที่แต่ละ Qubit อยู่ใน 0 หรือ 1 และเราเรียงลำดับจากสถานะที่ Qubit ทั้งหมดเป็น 0 $|00...00\rangle$ ถึงสถานะที่ทั้งหมดเป็น 1 $|11...11\rangle$

แต่เราจะเข้าใจสถานะฐาน ฟูเรีย ได้อย่างไร? สถานะฐานฟูเรียทั้งหมดเป็นซูเปอร์โพสิชันที่เท่ากันของสถานะฐาน computational ทั้งหมด แต่แต่ละสถานะต่างกันจากอื่นในความเป็นคาบของ เฟส ของส่วนประกอบ เพื่อทำความเข้าใจสิ่งนี้มากขึ้น มาดูสถานะฐานฟูเรียสี่ตัวของระบบสอง Qubit กัน สถานะฟูเรียต่ำสุดคือสถานะที่เฟสไม่เปลี่ยนแปลงเลย:

$|\phi_0\rangle = \frac{1}{2} (|00\rangle + |01\rangle + |10\rangle + |11\rangle)$

เราสามารถแสดงสถานะนี้โดยการพล็อตแอมพลิจูดเชิงซ้อนของแต่ละเทอม เส้นสีแดงช่วยให้เห็นว่าเฟสของแอมพลิจูดนี้วนรอบระนาบเชิงซ้อนอย่างไรในฐานะฟังก์ชันของสถานะฐาน computational สำหรับ $|\phi_0\rangle$ เฟสคงที่:

สถานะฐานฟูเรียถัดไปคือสถานะที่เฟสของส่วนประกอบวนรอบจาก $0$ ถึง $2\pi$ เพียงครั้งเดียว:

$|\phi_1\rangle = \frac{1}{2} (|00\rangle + e^{i\pi/2}|01\rangle + e^{i\pi}|10\rangle + e^{3i\pi/2}|11\rangle) = \frac{1}{2}(|00\rangle + i|01\rangle - |10\rangle - i|11\rangle)$

และเราสามารถเห็นการวนนี้ในกราฟแอมพลิจูดเชิงซ้อนเทียบสถานะฐาน computational:

ดังนั้น แต่ละสถานะมีเฟสที่สูงกว่าสถานะก่อนหน้า $2\pi/4$ เรเดียน เมื่อเรียงลำดับตามปกติ เนื่องจากในตัวอย่างนี้เรามีสี่สถานะฐาน ($N=4$) สถานะฐานถัดไปวนรอบจาก 0 ถึง $2\pi$ สองครั้ง:

$|\phi_2\rangle = \frac{1}{2} (|00\rangle + e^{i\pi}|01\rangle + e^{2i\pi}|10\rangle + e^{3i\pi}|11\rangle) = \frac{1}{2} (|00\rangle - |01\rangle + |10\rangle - |11\rangle)$

สุดท้าย องค์ประกอบฟูเรียสูงสุดคือสถานะที่มีเฟสแปรผันเร็วที่สุด สำหรับตัวอย่างสอง Qubit ของเรา มันคือสถานะที่เฟสวนรอบจาก 0 ถึง $2\pi$ สามครั้ง:

$|\phi_3\rangle = \frac{1}{2} (|00\rangle + e^{3i\pi/2}|01\rangle + e^{6i\pi/2}|10\rangle + e^{9i\pi/2}|11\rangle) = \frac{1}{2} (|00\rangle - i|01\rangle - |10\rangle + i|11\rangle)$

โดยทั่วไป สำหรับสถานะ $m$-Qubit จะมีสถานะฐานฟูเรีย $2^m$ ตัว ซึ่งความถี่ในการแปรผันของเฟสมีช่วงตั้งแต่คงที่สำหรับ $|\phi_0\rangle$ ถึงแปรผันรวดเร็วสำหรับ $|\phi_{2^m-1}\rangle$ โดยวนครบ $2^m-1$ รอบรอบ $2\pi$ ตลอดซูเปอร์โพสิชันของสถานะ ดังนั้น เมื่อเรา QFT สถานะควอนตัม เราก็กำลังทำการวิเคราะห์พื้นฐานเดียวกับที่เราทำสำหรับ waveform เพลงในบทนำ เราระบุองค์ประกอบความถี่ฟูเรียที่มีส่วนในการสร้างสถานะควอนตัมที่สนใจ

ลอง QFT ตัวอย่าง

มาลองสร้างสัญชาตญาณสำหรับการแปลงฟูเรียเชิงควอนตัมต่อไปโดยสร้างสถานะในฐาน computational แล้วดูว่าเกิดอะไรขึ้นเมื่อเรานำ QFT ไปใช้กับมัน สำหรับตอนนี้ เราจะถือว่า QFT เป็นกล่องดำที่เรานำมาใช้โดยใช้ QFTGate จาก ไลบรารี Circuit ของ Qiskit ในภายหลัง เราจะดูภายในเพื่อดูวิธีที่มันถูกใช้งาน

เราเริ่มต้นด้วยการโหลดแพ็กเกจที่จำเป็นและเลือกอุปกรณ์สำหรับรัน Circuit:

import numpy as np
from qiskit import QuantumCircuit
from qiskit.visualization import plot_histogram
from qiskit.circuit.library import QFTGate

# Load the Qiskit Runtime service
from qiskit_ibm_runtime import QiskitRuntimeService

# Load the Runtime primitive and session
from qiskit_ibm_runtime import SamplerV2 as Sampler

service = QiskitRuntimeService()

# Use the least busy backend
# backend = service.least_busy(operational=True, simulator=False, min_num_qubits = 127)
backend = service.backend("ibm_pinguino2")

print(backend.name)

ibm_pinguino2

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

# Load the backend sampler
from qiskit.primitives import BackendSamplerV2

# Load the Aer simulator and generate a noise model based on the currently-selected backend.
from qiskit_aer import AerSimulator
from qiskit_aer.noise import NoiseModel

noise_model = NoiseModel.from_backend(backend)

# Define a simulator using Aer, and use it in Sampler.
backend_sim = AerSimulator(noise_model=noise_model)
sampler_sim = BackendSamplerV2(backend=backend_sim)

# Alternatively, load a fake backend with generic properties and define a simulator.
from qiskit.providers.fake_provider import GenericBackendV2

backend_gen = GenericBackendV2(num_qubits=18)
sampler_gen = BackendSamplerV2(backend=backend_gen)

สถานะฐาน computational เดี่ยว

ก่อนอื่น มาลองแปลงสถานะฐาน computational เดี่ยว เราจะเริ่มด้วยการสร้างสถานะ computational แบบสุ่ม:

# Step 1: Map

qubits = 4
N = 2**qubits

qc = QuantumCircuit(qubits)

# flip state of random qubits to put in a random single computational basis state
for i in range(1, qubits):
    if np.random.randint(0, 2):
        qc.x(i)

# make a copy of the above circuit. (to be used when we apply the QFT in next part)
qc_qft = qc.copy()

qc.measure_all()
qc.draw("mpl")

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qc)

# Step 3: Run the job on a real quantum computer OR try fake backend

sampler = Sampler(mode=backend)
pubs = [qc_isa]

# Run the job on real quantum device

job = sampler.run(pubs, shots=1000)
res = job.result()
counts = res[0].data.meas.get_counts()

# OR Run the job on the Aer simulator with noise model from real backend

# job = sampler_sim.run([qc_isa])
# res = job.result()
# counts = res[0].data.meas.get_counts()

# Step 4: Post-Process
plot_histogram(counts)

ตอนนี้ มา Fourier transform สถานะนี้ด้วย QFTGate:

# Step 1: Map

qc_qft.compose(QFTGate(qubits), inplace=True)
qc_qft.measure_all()
qc_qft.draw("mpl")

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qc_qft)

# Step 3: Run the job on a real quantum computer - try fake backend

sampler = Sampler(mode=backend)
pubs = [qc_isa]

# Run the job on real quantum device

job = sampler.run(pubs, shots=1000)
res = job.result()
counts = res[0].data.meas.get_counts()

# OR Run the job on the Aer simulator with noise model from real backend

# job = sampler_sim.run([qc_isa])
# res = job.result()
# counts = res[0].data.meas.get_counts()

# Step 4: Post-Process
plot_histogram(counts)

จะเห็นว่าเราวัดจำนวนประชากรของแต่ละสถานะให้มากหรือน้อยเท่ากัน โดยคำนึงถึง noise ในการทดลองและสถิติ ดังนั้น หากคุณนำ QFT ไปใช้กับสถานะฐาน computational เดี่ยว ผลลัพธ์คือซูเปอร์โพสิชันที่เท่ากันของสถานะทั้งหมด หากคุณคุ้นเคยกับการแปลงฟูเรีย สิ่งนี้น่าจะไม่น่าแปลกใจ หลักการพื้นฐานอย่างหนึ่งที่ช่วยให้เราสร้างการเชื่อมต่อเชิงสัญชาตญาณระหว่างฟังก์ชันและการแปลงฟูเรียคือความกว้างของฟังก์ชันแปรผกผันกับความกว้างของการแปลงฟูเรีย ดังนั้น สิ่งที่แปลมากในเวลา เช่น pulse สั้นมาก จะต้องใช้ช่วงความถี่กว้างในการสร้าง pulse นั้น สัญญาณนั้นจะกว้างมากใน Fourier space

ข้อเท็จจริงนี้จริงๆ แล้วเกี่ยวข้องกับความไม่แน่นอนเชิงควอนตัม! หลักความไม่แน่นอนของ Heisenberg มักระบุเป็น $\Delta x \Delta p \ge \hbar / 2$ ดังนั้นหากความไม่แน่นอนใน $x$ ($\Delta x$) มีขนาดเล็ก ความไม่แน่นอนในโมเมนตัม ($\Delta p$) ต้องมีขนาดใหญ่ และในทางกลับกัน ปรากฏว่าการแปลงจากฐานตำแหน่ง $x$ ไปยังฐานโมเมนตัม $p$ ทำโดยการแปลงฟูเรีย

หมายเหตุ: โปรดจำไว้ว่าเรากำลังวัดประชากรในแต่ละสถานะฐาน ดังนั้นเราสูญเสียข้อมูลเกี่ยวกับเฟสสัมพัทธ์ระหว่างส่วนต่างๆ ของซูเปอร์โพสิชัน ดังนั้น ขณะที่ QFT ของสถานะฐาน computational เดี่ยวจะให้การกระจายประชากรสม่ำเสมอกว่าสถานะฐานทั้งหมดเช่นกัน เฟส จะไม่จำเป็นต้องเหมือนกัน

สถานะฐาน computational สอง

ตอนนี้ มาดูกันว่าเกิดอะไรขึ้นเมื่อเราเตรียมซูเปอร์โพสิชันของสถานะฐาน computational คุณคิดว่าการแปลงฟูเรียจะมีลักษณะอย่างไรในกรณีนี้?

มาเลือกซูเปอร์โพสิชัน:

$|\psi\rangle = \frac{1}{\sqrt{2}} (|0\rangle + |N/2\rangle) = \frac{1}{\sqrt{2}} (|000...0\rangle + |100...0\rangle)$

# Step 1: Map
qubits = 4
N = 2**qubits

qc = QuantumCircuit(qubits)

# To make this state, we just need to apply a Hadamard to the last qubit

qc.h(qubits - 1)

qc_qft = qc.copy()

qc.measure_all()

qc.draw("mpl")

# First, let's go through steps 2-4 for the first circuit, qc

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qc)

# Step 3: Run the job on a real quantum computer - try fake backend

sampler = Sampler(mode=backend)
pubs = [qc_isa]

# Run the job on real quantum device

job = sampler.run(pubs, shots=1000)
res = job.result()
counts = res[0].data.meas.get_counts()

# OR run the job on the Aer simulator with noise model from real backend

# job = sampler_sim.run([qc_isa])
# res = job.result()
# counts = res[0].data.meas.get_counts()

# Step 4: Post-process
plot_histogram(counts)

ตอนนี้ มา Fourier transform สถานะนี้ด้วย QFTGate:

# Step 1: Map

qc_qft.compose(QFTGate(qubits), inplace=True)
qc_qft.measure_all()
qc_qft.draw("mpl")

# Step 2: Transpile
from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

target = backend.target
pm = generate_preset_pass_manager(target=target, optimization_level=3)

qc_isa = pm.run(qc_qft)

# Step 3: Run the job on a real quantum computer OR try fake backend

sampler = Sampler(mode=backend)
pubs = [qc_isa]

# Run the job on real quantum device

job = sampler.run(pubs, shots=1000)
res = job.result()
counts = res[0].data.meas.get_counts()

# OR run the job on the Aer simulator with noise model from real backend

# job = sampler_sim.run([qc_isa])
# res = job.result()
# counts = res[0].data.meas.get_counts()

# Step 4: Post-process
plot_histogram(counts)

สิ่งนี้อาจน่าแปลกใจเล็กน้อย ดูเหมือนว่า QFT ของสถานะ $|\psi\rangle = \frac{1}{\sqrt{2}} (|0\rangle + |N/2\rangle)$ เป็นซูเปอร์โพสิชันของสถานะฐานที่เป็นจำนวนคู่ทั้งหมด แต่ถ้าเราคิดถึงการแสดงภาพสถานะฐานแต่ละตัว $|\phi_y\rangle$ และวิธีที่เฟสของแต่ละส่วนประกอบวนรอบ $2\pi$ $y$ ครั้ง เหตุผลที่เราได้ผลลัพธ์นี้อาจชัดเจนขึ้น

ทดสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดหาคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

ใช้คำใบ้ด้านบน อธิบายว่าทำไมผลลัพธ์ที่ได้สำหรับ QFT ของ $|\psi\rangle = \frac{1}{\sqrt{2}} (|0\rangle + |N/2\rangle)$ จึงเป็นที่คาดหวัง

คำตอบ:

สถานะเดิมมีเฟสสัมพัทธ์ 0 (หรือจำนวนเต็มคูณของ $2\pi$) ระหว่างสองส่วนของซูเปอร์โพสิชัน ดังนั้น เราทราบว่าสถานะนี้มีองค์ประกอบฟูเรียที่เฟสก็ตรงกันในแบบนั้นด้วย: สถานะที่มีเฟส shift 0 ระหว่างเทอม |0000> และเทอม |1000> สถานะฐานฟูเรียแต่ละตัว $|\phi_y\rangle$ ประกอบด้วยเทอมที่เฟสสะสมในอัตรา $2\pi y/N$ หมายความว่า เมื่อเรียงลำดับตามปกติ แต่ละเทอมในซูเปอร์โพสิชันมีเฟสสูงกว่าเทอมก่อนหน้า $2\pi y/N$ ดังนั้น ที่จุดกึ่งกลาง $N/2$ เราต้องการให้เฟส $2\pi y/N * N/2$ เป็นจำนวนเต็มคูณของ $2\pi$ ซึ่งเกิดขึ้นเมื่อ $y$ เป็นจำนวนคู่

ซูเปอร์โพสิชันของสถานะ computational ใดที่จะตรงกับ QFT ที่มียอดแหลมบนทุกจำนวนไบนารีคี่?

คำตอบ:

ถ้าคุณนำ QFT ไปใช้กับสถานะ $\psi = |0\rangle - |N/2\rangle$ คุณจะเห็นยอดแหลมบนสถานะที่มีหมายเลขไบนารีคี่ทุกตัว

แยกแยะอัลกอริทึม QFT

ตอนนี้ที่เราได้สร้างสัญชาตญาณเพิ่มเติมเกี่ยวกับความสัมพันธ์ระหว่างสถานะ Qubit ในฐาน computational และฐานฟูเรียแล้ว มาเจาะลึกลงไปในอัลกอริทึม QFT กัน กล่าวคือ เราใช้ Gate ใดจริงๆ บนคอมพิวเตอร์ควอนตัมเพื่อให้ได้การแปลงนี้?

มาเริ่มต้นจากขนาดเล็ก ด้วย Qubit เดี่ยว ดังนั้นหมายความว่าเรามีสองสถานะฐาน QFT$_2$ แปลงสถานะฐาน computational $|0\rangle$ และ $|1\rangle$ ไปยังสถานะฐานฟูเรีย $\phi_0$ และ $\phi_1$:

$|\phi_0\rangle = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$

$|\phi_1\rangle = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle)$

ทดสอบความเข้าใจ

อ่านคำถามด้านล่าง คิดหาคำตอบ แล้วคลิกสามเหลี่ยมเพื่อดูเฉลย

ใช้สมการสำหรับ QFT ในส่วนก่อนหน้า ยืนยันสถานะฐานฟูเรียสองตัวด้านบน

คำตอบ:

สูตร QFT ทั่วไปคือ:

$| \phi_y \rangle = \frac{1}{\sqrt{N}}\sum_{x=0}^{N-1}\omega_N^{y x} \vert x \rangle$

สำหรับ Qubit เดี่ยว ($n=1$), $N=2^n=2$, และ $\omega_N^{xy} = e^{2\pi i \frac {y x}{2}}$ ดังนั้นเรามี

$| \phi_0 \rangle = \frac{1}{\sqrt{2}}(e^{2\pi i \frac {0 \times 0}{2}}|0\rangle + e^{2\pi i \frac {0 \times 1}{2}}|1\rangle) = \frac{1}{\sqrt{2}}(|0\rangle + |1\rangle)$

$| \phi_1 \rangle = \frac{1}{\sqrt{2}}(e^{2\pi i \frac {1 \times 0}{2}}|0\rangle + e^{2\pi i \frac {1 \times 1}{2}}|1\rangle) = \frac{1}{\sqrt{2}}(|0\rangle - |1\rangle)$

ลองดูสองสมการนั้น คุณอาจทราบแล้วถึง Gate ควอนตัมที่สามารถใช้ในการนำการแปลงนี้ไปใช้ นั่นคือ มี Gate ที่แปลงสถานะฐาน computational $|0\rangle$ และ $|1\rangle$ ไปยังสถานะฐานฟูเรียที่เกี่ยวข้อง $|\phi_0\rangle$ และ $|\phi_1\rangle$ มันคือ Hadamard Gate! สิ่งนี้ยิ่งชัดเจนขึ้นหากเราแนะนำการแสดงเมทริกซ์ของการดำเนินการ QFT$_N$:

$\text{QFT}_N = \frac{1}{\sqrt{N}} \sum_{x=0}^{N-1} \sum_{y=0}^{N-1} \omega_N^{xy} \vert x \rangle \langle y \vert$

หากคุณไม่คุ้นเคยกับสัญลักษณ์นี้สำหรับการแสดงตัวดำเนินการควอนตัม ไม่เป็นไร! มันเป็นวิธีแสดงเมทริกซ์ $N \times N$ โดยที่ $x$ และ $y$ ระบุดัชนีคอลัมน์และแถวของเมทริกซ์ตั้งแต่ $0$ ถึง $N-1$ และ $\omega_N^{xy}$ คือค่าของรายการนั้น ดังนั้น รายการในคอลัมน์ที่ 0 และแถวที่ 2 ตัวอย่างเช่น จะเป็น $\omega_N^{0,2} = e^{2 \pi i \frac{0 \times 2}{N}} = 1$

ในการแสดงนี้ แต่ละสถานะฐาน computational เกี่ยวข้องกับ basis vector อย่างใดอย่างหนึ่ง:

$$\begin{pmatrix} 1 \\ 0 \\ \vdots \\ 0 \end{pmatrix}, |1\rangle = \begin{pmatrix} 0 \\ 1 \\ \vdots \\ 0 \end{pmatrix}, |N-1\rangle = \begin{pmatrix} 0 \\ 0 \\ \vdots \\ 1 \end{pmatrix}.$$

หากคุณต้องการเรียนรู้เกี่ยวกับการแสดงนี้อย่างลึกซึ้งกว่า ดูบทเรียนของ John Watrous เกี่ยวกับ multiple systems ในหลักสูตร พื้นฐานของข้อมูลควอนตัม

มาลองสร้างเมทริกซ์สำหรับ QFT$_4$ กัน ใช้สูตรด้านบน เราพบว่า

\text\{QFT\}_4 = \frac\{1\}\{2\} \begin\{pmatrix\} 1 & 1 & 1 & 1 \\ 1 & i & -1 & -i \\ 1 & -1 & 1 & -1 \\ 1 & -i & -1 & i \\ \end\{pmatrix\}

เพื่อนำเมทริกซ์นี้ไปใช้บนคอมพิวเตอร์ควอนตัม เราต้องหาว่าการรวมกันของ Gate ที่นำไปใช้กับ Qubit ใดจะให้การแปลงแบบ unitary ที่ตรงกับเมทริกซ์ด้านบน เราทราบแล้วว่าหนึ่งใน Gate ที่จะต้องใช้คือ Hadamard Gate อีก Gate ที่เราจะต้องใช้คือ controlled-phase gate ซึ่งนำเฟสสัมพัทธ์ $\alpha$ ไปใช้กับสถานะของ target qubit ตราบใดที่ control qubit อยู่ในสถานะ $|1\rangle$ ในรูปแบบเมทริกซ์ดูเหมือน:

\text\{CP\}_\alpha = \begin\{pmatrix\} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & e^\{i\alpha\} \\ \end\{pmatrix\}

เนื่องจากมีเพียงสถานะ $|11\rangle$ เท่านั้นที่ถูกเปลี่ยน จริงๆ แล้วไม่สำคัญว่า Qubit ตัวใดถือว่าเป็น "control" และตัวใดเป็น "target" ผลลัพธ์จะเหมือนกันไม่ว่าทางใด

สุดท้าย เราต้องการ SWAP Gate ด้วย SWAP Gate สลับสถานะของ Qubit สอง Qubit มีลักษณะดังนี้:

\text\{SWAP\}_\alpha = \begin\{pmatrix\} 1 & 0 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 0 & 1 \\ \end\{pmatrix\}

ขั้นตอนในการสร้าง Circuit QFT$_{2^m}$ บน $m$ Qubit เป็นแบบวนซ้ำ — คุณนำ QFT$_{2^{m-1}}$ ไปใช้กับ Qubit $1$ ถึง $m-1$ ก่อน จากนั้นเพิ่ม Gate บางตัวระหว่าง Qubit $0$ กับอีก $m-1$ Qubit ที่เหลือ แต่เพื่อนำ QFT$_{2^{m-1}}$ ไปใช้ คุณต้องนำ QFT$_{2^{m-2}}$ ไปใช้กับ Qubit 2 ถึง $m-1$ ก่อน จากนั้นเพิ่ม Gate บางตัวระหว่าง Qubit 1 กับ Qubit ที่เหลือ $2$ ถึง $m-1$ มันเหมือนตุ๊กตาแมทรีออชก้ารัสเซีย: ตุ๊กตาแต่ละตัวเพิ่ม QFT ขึ้นสองเท่าในขนาด โดยมีตุ๊กตาตัวเล็กที่สุดอยู่ตรงกลาง ซึ่งคือ QFT$_2$ หรือ Hadamard Gate

เพื่อใส่ตุ๊กตาเข้าในตุ๊กตาขนาดใหญ่ถัดไป ดังนั้นเพิ่มขนาดของ QFT เป็นสองเท่า คุณมักทำตามขั้นตอนเดิมเสมอ:

1. ก่อนอื่น นำ QFT$_{2^{m-1}}$ ไปใช้กับ $m-1$ Qubit ล่างสุด นี่คือ "ตุ๊กตาเล็กกว่า" ของชุดตุ๊กตาแมทรีออชก้ารัสเซียที่คุณจะใส่ไว้ในตุ๊กตาใหญ่ถัดไป
2. ใช้ Qubit ถัดขึ้นไปเป็น control และนำ controlled phase gate ไปใช้กับ Qubit ล่าง $m-1$ ตัว ด้วยเฟสต่อสถานะมาตรฐานของ Qubit ที่เหลือ $m-1$ ตัวแต่ละตัว
3. ทำ Hadamard บน Qubit บนสุดตัวเดียวกันที่ใช้เป็น control ในเฟส Gate
4. ใช้ SWAP Gate เพื่อจัดเรียงลำดับ Qubit ใหม่ เพื่อให้บิตที่มีนัยสำคัญน้อยที่สุด (บน) กลายเป็นบิตที่มีนัยสำคัญมากที่สุด (ล่าง) และทั้งหมดอื่นๆ เลื่อนขึ้นหนึ่งตำแหน่ง

เราใช้ฟังก์ชัน QFTGate จากไลบรารี Circuit ของ Qiskit มาตลอด แต่ตอนนี้ มาดูภายใน QFT Gate บางตัวเพื่อยืนยันขั้นตอนด้านบน เราทำได้ด้วย decompose()

qc = QuantumCircuit(1)
qc.compose(QFTGate(1), inplace=True)
qc.decompose().draw("mpl")

qc = QuantumCircuit(2)
qc.compose(QFTGate(2), inplace=True)
qc.decompose().draw("mpl")

qc = QuantumCircuit(3)
qc.compose(QFTGate(3), inplace=True)
qc.decompose().draw("mpl")

qc = QuantumCircuit(4)
qc.compose(QFTGate(4), inplace=True)
qc.decompose().draw("mpl")

ดังนั้น หวังว่าจาก QFT สี่ตัวแรก คุณจะเริ่มเห็นว่าแต่ละตัวซ้อนอยู่ภายในตัวที่ใหญ่กว่า คุณอาจสังเกตเห็นว่า phase Gate บางตัวไม่ตรงตามที่ระบุในขั้นตอนที่เราอธิบายด้านบน และ SWAP ไม่ปรากฏหลังซับรูทีนแต่ละตัว แต่ปรากฏเฉพาะในตอนท้ายของ QFT เต็มรูปแบบ สิ่งนี้ช่วยประหยัด Gate ที่ไม่จำเป็น ซึ่งจะทำให้ Circuit ใช้เวลานานขึ้นและเกิดข้อผิดพลาดมากขึ้น แทนที่จะนำ SWAP ไปใช้หลังตุ๊กตาที่ซ้อนกันแต่ละตัว Circuit จะติดตามว่าแต่ละสถานะ Qubit ควร อยู่ที่ใดและปรับ Qubit ที่นำ phase Gate ไปใช้ตามนั้น จากนั้น SWAP ชุดสุดท้ายในตอนท้ายจะวางทุกอย่างในตำแหน่งที่เหมาะสม

นำ QFT ไปใช้: การประมาณเฟส

มาดูกันว่า QFT สามารถใช้แก้ปัญหาที่มีประโยชน์ในการประมวลผลเชิงควอนตัมได้อย่างไร การคำนวณ inverse quantum Fourier transform เป็นขั้นตอนที่จำเป็นในอัลกอริทึมที่เรียกว่า Quantum Phase Estimation (QPE) ซึ่งตัวมันเองเป็นซับรูทีนในอัลกอริทึมหลายตัว รวมถึง "มงกุฎแก้ว" ของอัลกอริทึมควอนตัม อัลกอริทึมการแยกตัวประกอบของ Shor

เป้าหมายของ QPE คือการประมาณค่า eigenvalue ของตัวดำเนินการ unitary Unitary operators พบได้ทั่วไปในการประมวลผลเชิงควอนตัม และบ่อยครั้ง การหาค่า eigenvalue ของ eigenvector ที่เกี่ยวข้องเป็นขั้นตอนที่จำเป็นในอัลกอริทึมที่ใหญ่กว่า ขึ้นอยู่กับปัญหา ค่า eigenvalue อาจแสดงพลังงานของ Hamiltonian ในปัญหาการจำลอง สามารถช่วยหาตัวประกอบเฉพาะของจำนวนในอัลกอริทึมของ Shor หรือมีข้อมูลสำคัญอื่นๆ QPE เป็นหนึ่งในซับรูทีนที่สำคัญและใช้กันอย่างแพร่หลายที่สุดในการประมวลผลเชิงควอนตัม

แล้วสิ่งนี้เกี่ยวข้องกับการแปลงฟูเรียเชิงควอนตัมอย่างไร? ดังที่คุณอาจจำได้ ค่า eigenvalue $\lambda$ ใดๆ ของตัวดำเนินการ unitary มีขนาด $|\lambda| = 1$ ดังนั้นเราสามารถเขียนค่า eigenvalue แต่ละตัวเป็นจำนวนเชิงซ้อนที่มีขนาดหนึ่ง:

$\lambda = e^{2\pi i \theta}$

โดยที่ $\theta$ เป็นจำนวนจริงระหว่าง 0 ถึง 1 หากคุณต้องการข้อมูลเพิ่มเติมเกี่ยวกับเมทริกซ์ unitary ดูบทเรียนของ John Watrous ในหัวข้อนี้ ในพื้นฐานของข้อมูลควอนตัม

สังเกตว่า $\lambda$ มีความเป็น คาบ ใน $\theta$ สิ่งนี้อาจทำให้คุณนึกถึง QFT แล้ว เนื่องจากเราเห็นว่า QFT มีประโยชน์มากแค่ไหนในการวิเคราะห์ฟังก์ชันคาบ ด้านล่าง เราจะดูอัลกอริทึมและเห็นว่า QFT เข้ามามีส่วนร่วมอย่างไรอย่างแม่นยำ

QPE ทำงานอย่างไร

ก่อนอื่น เราจะเริ่มด้วยอัลกอริทึม QPE ที่ง่ายที่สุด ซึ่งประมาณเฟสได้ถึงหลักเลขฐานสองหนึ่งหลักของความแม่นยำ กล่าวคืออัลกอริทึมนี้สามารถแยกแยะระหว่าง $\theta = 0$ และ $\theta = 1/2$ ได้ แต่ไม่สามารถทำได้ดีกว่านั้น ต่อไปนี้คือแผนภาพ Circuit:

Qubit ถูกเตรียมในสถานะ $|\pi_0\rangle = |\psi\rangle|0\rangle$ โดยที่ Qubit $0$ อยู่ในสถานะ $|0\rangle$ และ Qubit ที่เหลืออยู่ในสถานะ $|\psi\rangle$ ซึ่งเป็น eigenstate ของ $U$ หลังจาก Hadamard ตัวแรก สถานะ Qubit กลายเป็น:

$|\pi_1\rangle = \frac{1}{\sqrt{2}}|\psi\rangle (|0\rangle + |1\rangle)$

Gate ถัดไปคือ "controlled-$U$" gate สิ่งนี้นำการดำเนินการ unitary $U$ ไปใช้กับ Qubit ล่างที่อยู่ในสถานะ $|\psi\rangle$ หาก Qubit 0 อยู่ในสถานะ $|1\rangle$ แต่ไม่ทำอะไรกับ $|\psi\rangle$ หาก Qubit 0 อยู่ในสถานะ $|0\rangle$ สิ่งนี้แปลง Qubit ไปยังสถานะ:

$|\pi_2\rangle = \frac{1}{\sqrt{2}}( |\psi\rangle|0\rangle + e^{2\pi i \theta}|\psi\rangle|1\rangle)$ $= \frac{1}{\sqrt{2}}|\psi\rangle (|0\rangle + e^{2\pi i \theta}|1\rangle)$

เกิดสิ่งแปลกประหลาดขึ้น: controlled-$U$ gate ใช้เพียง Qubit $0$ เป็น control qubit ดังนั้นอาจคิดว่า Gate นี้จะไม่เปลี่ยนสถานะของ Qubit 0 เลย แต่ไม่ว่าจะอย่างไร มันก็เปลี่ยน! แม้ว่าการดำเนินการถูกนำไปใช้กับ Qubit ล่าง ผลโดยรวมของ Gate คือการเปลี่ยนเฟสของ Qubit $0$ สิ่งนี้เรียกว่า "phase kickback mechanism" และถูกใช้ในอัลกอริทึมควอนตัมหลายตัว รวมถึง Deutsch-Josza และอัลกอริทึมของ Grover หากคุณต้องการเรียนรู้เพิ่มเติมเกี่ยวกับ phase-kickback mechanism ดูบทเรียนของ John Watrous เกี่ยวกับ Quantum query algorithms ใน Fundamentals of quantum algorithms

หลังจาก phase-kickback เรานำ Hadamard อีกครั้งไปใช้กับ Qubit $0$ ซึ่งส่งผลให้ได้สถานะ:

$|\pi_3\rangle = |\psi\rangle ( \frac{1+e^{2\pi i \theta}}{2} |0\rangle + \frac{1 - e^{2\pi i \theta}}{2}|1\rangle) = |\psi\rangle ( \cos(\pi\theta) |0\rangle - i \sin(\pi\theta)|1\rangle)$

ดังนั้น เมื่อเราวัด Qubit $0$ ในตอนท้าย เราจะวัด $|0\rangle$ ด้วยความน่าจะเป็น 100% หาก $\theta = 0$ และเราจะวัด $|1\rangle$ ด้วยความน่าจะเป็น 100% หาก $\theta = \frac{1}{2}$ (และหากคอมพิวเตอร์ควอนตัมของเราสมบูรณ์แบบ ไม่มี noise) หาก $\theta$ เป็นค่าอื่นนอกจากนี้ การวัดสุดท้ายจะมีความน่าจะเป็นเท่านั้นและบอกเราได้เพียงไม่มากนัก

QPE ที่มีความแม่นยำมากขึ้น: Qubit มากขึ้น

เราสามารถขยายแนวคิดง่ายๆ นี้ไปยังอัลกอริทึมที่ซับซ้อนกว่าด้วยความแม่นยำตามต้องการ หากแทนที่จะใช้เพียง Qubit $0$ เพื่อวัดเฟส เราใช้ $m$ Qubit $0$ ถึง $m-1$ เราจะสามารถประมาณเฟสด้วยความแม่นยำ $m$ บิต มาดูวิธีที่สิ่งนี้ทำงาน:

Circuit QPE ที่มีความแม่นยำมากขึ้นนี้เริ่มต้นเหมือนกับเวอร์ชันบิตเดียว: Hadamard ถูกนำไปใช้กับ $m$ Qubit แรก และ Qubit ที่เหลือถูกเตรียมในสถานะ $|\psi\rangle$ สร้างสถานะ:

$|\pi_1\rangle = \frac{1}{2^{m/2}}|\psi\rangle(|0\rangle+|1\rangle)(|0\rangle+|1\rangle)...(|0\rangle+|1\rangle)$

ตอนนี้ controlled-unitaries ถูกนำไปใช้ Qubit $0$ เป็น control สำหรับ unitary $U$ เดิมเช่นเดิม แต่ตอนนี้ Qubit $1$ เป็น control สำหรับ unitary $U^2$ ซึ่งก็คือ $U$ ที่นำไปใช้สองครั้ง ดังนั้น ค่า eigenvalue ของ $U^2$ คือ $e^{2*2\pi i \theta}$ โดยทั่วไป Qubit $k$ แต่ละตัวตั้งแต่ 0 ถึง $m-1$ จะเป็น control สำหรับ unitary $U^{2^k}$ ซึ่งหมายความว่า Qubit แต่ละตัวเหล่านั้นจะประสบ phase kickback ของ $e^{2^k*2\pi i \theta}$ ซึ่งส่งผลให้ได้สถานะ:

$|\pi_2\rangle = |\psi\rangle \otimes \frac{1}{2^{m/2}} (|0\rangle+e^{2^{m-1}2\pi i \theta}|1\rangle)(|0\rangle+e^{2^{m-2}2\pi i \theta}|1\rangle)...(|0\rangle+e^{2\pi i \theta}|1\rangle)$

สิ่งนี้สามารถเขียนใหม่เป็นผลรวมบนสถานะฐาน computational:

$|\pi_2\rangle = |\psi\rangle \otimes \frac{1}{2^{m/2}} \sum_{k=0}^{2^{m}-1} e^{2\pi i k \theta} |k\rangle$

ผลรวมดูคุ้นเคยไหม? มันคือ QFT! จำสมการสำหรับ quantum Fourier transform:

$\text{QFT}_{2^m}| y \rangle = \frac{1}{\sqrt{2^m}}\sum_{x=0}^{2^m-1}\omega_{2^m}^{y x} \vert x \rangle$

ดังนั้น หากเฟส $\theta = y/2^m$ สำหรับจำนวนเต็ม $y$ บางตัวระหว่าง $0$ และ $2^m-1$ การนำ inverse QFT ไปใช้กับสถานะนี้จะส่งผลให้ได้สถานะ:

$|\pi_3\rangle = |\psi\rangle \otimes |y\rangle$

และจาก $|y\rangle$ เราสามารถอนุมาน $\theta$ ได้

หาก $\theta/2^m$ ไม่ใช่ จำนวนเต็มคูณ อย่างไรก็ตาม การนำ inverse QFT ไปใช้จะ ประมาณ $\theta$ เท่านั้น ความแม่นยำในการประมาณ $\theta$ จะมีความน่าจะเป็น หมายความว่าเราจะไม่ได้การประมาณที่ดีที่สุดเสมอไป แต่จะค่อนข้างใกล้เคียง และยิ่งคุณใช้ Qubit $m$ มากเท่าไหร่ การประมาณที่ดีกว่าที่คุณจะได้ก็ยิ่งมากขึ้น หากต้องการเรียนรู้เกี่ยวกับวิธีการระบุปริมาณการประมาณ $\theta$ นี้ ดูบทเรียนของ John Watrous เกี่ยวกับ Phase estimation and factoring ใน Fundamentals of quantum algorithms

บทสรุป

โมดูลนี้ให้ภาพรวมว่า QFT คืออะไร มันถูกนำไปใช้บนคอมพิวเตอร์ควอนตัมอย่างไร และมีประโยชน์อย่างไร เราให้คุณลิ้มรสประโยชน์ของมันเมื่อเราเห็นว่ามันสามารถใช้ใน quantum phase estimation เพื่อเรียนรู้เกี่ยวกับค่า eigenvalue ของเมทริกซ์ unitary ได้

แนวคิดสำคัญ

• Quantum Fourier Transform เป็นอนาล็อกเชิงควอนตัมของ Discrete Fourier Transform
• QFT เป็นตัวอย่างของการแปลงฐาน
• กระบวนการ Quantum Phase Estimation อาศัย phase-kickback mechanism จาก controlled-unitary operations และ inverse QFT
• QFT และ QPE เป็นซับรูทีนที่ใช้กันอย่างแพร่หลายในอัลกอริทึมควอนตัมหลายตัว

คำถาม

จริง/เท็จ

1. จ/ท Quantum Fourier Transform เป็นอนาล็อกเชิงควอนตัมของ classical discrete Fourier transform (DFT)
2. จ/ท QFT สามารถนำไปใช้โดยใช้เพียง Hadamard และ CNOT Gate
3. จ/ท QFT เป็นส่วนประกอบสำคัญของอัลกอริทึมของ Shor
4. จ/ท output ของ Quantum Phase Estimation คือสถานะควอนตัมที่แสดง eigenvector ของตัวดำเนินการ
5. จ/ท QPE ต้องการการใช้งาน inverse Quantum Fourier Transform (QFT$^\dag$)
6. จ/ท ใน QPE หากเฟส $\phi$ แสดงได้อย่างแม่นยำด้วย $n$ บิต อัลกอริทึมให้ผลลัพธ์ที่ถูกต้องด้วยความน่าจะเป็น 1

คำตอบสั้น

1. ต้องการ Qubit กี่ตัวในการทำ QFT บนระบบที่มี $2^n$ จุดข้อมูล?
2. QFT สามารถใช้กับสถานะที่ไม่ใช่สถานะฐาน computational ได้หรือไม่? ถ้าได้เกิดอะไรขึ้น?
3. จำนวน control qubit ที่ใช้ใน QPE ส่งผลต่อความละเอียดของค่าประมาณเฟสที่ได้อย่างไร?

โจทย์

1. ใช้การคูณเมทริกซ์เพื่อยืนยันว่าขั้นตอนในอัลกอริทึม QFT ให้ผลลัพธ์เป็นเมทริกซ์ $\text{QFT}_4$ จริง:

$$\text{QFT}_4 = \frac{1}{2} \begin{pmatrix} 1 & 1 & 1 & 1 \\ 1 & i & -1 & -i \\ 1 & -1 & 1 & -1 \\ 1 & -i & -1 & i \\ \end{pmatrix}$$

(ไม่จำเป็นต้องทำด้วยมือ!)

โจทย์ท้าทาย

1. สร้างสถานะสี่ Qubit ที่เป็นซูเปอร์โพสิชันที่เท่ากันของฐาน computational คี่ทั้งหมด: $|\psi\rangle = |0001\rangle + |0011\rangle + |0101\rangle + |0111\rangle +|1001\rangle +|1011\rangle +|1101\rangle +|1111\rangle$ จากนั้นทำ QFT กับสถานะ ผลลัพธ์คือสถานะอะไร? อธิบายว่าทำไมผลลัพธ์ของคุณจึงสมเหตุสมผล โดยใช้ความรู้เรื่องการแปลงฟูเรีย