วิธีการติดตามของสิ่งกีดขวางเมื่อเลียนแบบการคำนวณควอนตัม?

ฉันกำลังพยายามสร้างห้องสมุดคำนวณควอนตัมเป็นโครงการมหาวิทยาลัยของฉัน ฉันยังคงเรียนรู้ทุกแง่มุมของเขตข้อมูล Quantum Computing ฉันรู้ว่ามีห้องสมุดที่มีประสิทธิภาพสำหรับการจำลองควอนตัมอยู่แล้ว ฉันแค่ต้องการสร้างตัวเองซึ่งจะช่วยให้ฉันเข้าใจแนวคิดหลักของ Quantum Computing

ฉันรู้แล้ว $n$ qubits สามารถจัดเก็บด้วย $2^n$องค์ประกอบที่ซับซ้อนอาร์เรย์ นอกจากนี้$n$ ประตู qubit เป็น $2^n \times 2^n$อาร์เรย์ 2 มิติ ดังนั้นต่อไปนี้เป็นข้อสงสัยของฉัน (ส่วนใหญ่เกี่ยวข้องกับการพัวพัน):

1. ฉันต้องค้นหาผลิตภัณฑ์เทนเซอร์ของประตูเมื่อไหร่ (เช่น $I \otimes H \otimes I$, สำหรับ $3$ระบบ qubit)? จำเป็นหรือไม่ที่ต้องคำนวณผลิตภัณฑ์ของเมตริกซ์ตามลำดับ$2^n \times 2^n$แม้ว่า qubits จะไม่เข้าไปพัวพันกับ?

2. มีเพียง $2^n$อาร์เรย์องค์ประกอบ (ซึ่งฉันเก็บค่าสัมประสิทธิ์) จริง ๆ แล้วฉันสามารถคำนวณ qubits อันใดที่มีการพันกันหรือไม่ หรือฉันต้องสร้างโครงสร้างข้อมูลอื่นเพื่อจัดเก็บข้อมูลพัวพันของฉัน$n$ qubits (เกี่ยวกับ qubits ใดที่ทอดกัน)?

3. คำถามที่สองของฉันเกี่ยวข้องจริงหรือไม่ ฉันจำเป็นต้องติดตามข้อมูลพัวพันหรือไม่? ฉันหมายความว่าฉันไม่รู้ว่าการคูณประตูด้วยสัมประสิทธิ์นั้นเพียงพอหรือไม่ (แม้ว่าระบบจะพันกัน) อาจเกี่ยวข้องกับเวลาของการวัดเท่านั้น

มันเพียงพอที่จะคำนวณได้อย่างเต็มที่เสมอ $2^n\times 2^n$ รวมเมทริกซ์แล้วนำไปใช้กับ $2^n$- เวกเตอร์สถานะผู้ดี หากนั่นคือสิ่งที่คุณเลือกที่จะทำนั่นคือทั้งหมดที่คุณต้องทำเนื่องจากข้อมูลพัวพันทั้งหมดมีอยู่ในเวกเตอร์นั้น วิธีที่ง่ายและรวดเร็วในการตรวจสอบว่ามี qubit อันใดอันหนึ่งยุ่งเหยิงหรือไม่คือการติดตามบางส่วนของเวกเตอร์สถานะ (บริสุทธิ์) ของคุณเหนือ qubits อื่นทั้งหมด หากเมทริกซ์ที่ได้นั้นอยู่ในอันดับที่ 1 เควตนั้นจะอยู่ในสถานะที่แบ่งแยกได้ไม่งั้นก็จะยุ่งกัน

ฉันคิดว่าประเด็นคำถามของคุณคือ "สามารถหลีกเลี่ยงค่าใช้จ่ายในการคำนวณขนาดใหญ่นี้ได้อย่างไร" โดยทั่วไปไม่สามารถ - ถ้าคุณใช้ประโยชน์จากคอมพิวเตอร์ควอนตัมอย่างเต็มประสิทธิภาพคุณจะต้องมี$2^n$- เวกเตอร์สถานะผู้ดี อย่างไรก็ตามมีเทคนิคหลายอย่างที่ช่วยลดค่าใช้จ่ายในการคำนวณเช่นการชะลอความต้องการเวกเตอร์สถานะขนาดใหญ่ดังกล่าวโดยการติดตามการพัวพัน

การปรับปรุงประสิทธิภาพ

การประหยัดที่ใหญ่ที่สุดที่คุณสามารถทำได้เมื่อเปรียบเทียบกับการใช้งานแบบไร้เดียงสาข้างต้นคือการหลีกเลี่ยง $2^n\times 2^n$เมทริกซ์รวมกัน ตัวอย่างเช่นหากคุณใช้ประตู 1- หรือ 2-qubit เพียงแค่ใช้ sparsity ของเมทริกซ์หมายความว่าคุณต้องการเพียง$O(2^n)$ ที่เก็บข้อมูลแทน $O(2^{2n})$.

จากนั้นมีกลยุทธ์อื่น ๆ ที่คุณสามารถจ้างได้ ตัวอย่างเช่นลองจินตนาการว่าคุณต้องการใช้เกทสองอันรวมกัน$U$ บน qubits $i$ และ $j$. คุณสามารถใช้ชุด 4 องค์ประกอบจากเวกเตอร์สถานะของคุณ ($|x\rangle_{1,2,\ldots n\setminus i,j}|y\rangle_{i,j}$ สำหรับการแก้ไข $x\in\{0,1\}^{n-2}$ โดยการแตกต่างกันทั้งหมด $y\in\{0,1\}^2$) และเพียงแค่ใช้ $4\times 4$ รวมกัน $U$บนเวกเตอร์ 4 องค์ประกอบนั้น ทำซ้ำสิ่งนี้ทุกครั้ง$x$ จะกลับมา $U$ ตราสามดวงบนเวกเตอร์สถานะดั้งเดิม

ฉันคิดว่ามีกลยุทธ์อื่น ๆ ที่จะเกิดขึ้น สิ่งที่แนะนำตัวเองจากคำถามเดิมคือการติดตามสิ่งกีดขวาง สิ่งนี้ทำให้การปรับปรุงหน่วยความจำและความเร็วในการเริ่มต้นการคำนวณ แต่ท้ายที่สุดก็จะเทียบเท่าเพราะทุกอย่างในคอมพิวเตอร์ควอนตัมจะจบลงด้วยการพันกัน

การติดตามความพัวพัน

สมมติว่าการคำนวณของคุณประกอบด้วยเพียงวิวัฒนาการรวมและการวัดในชุดของ$n$ qubits คือไม่มี decoherence แผนที่ความน่าจะเป็น ฯลฯ ลองสมมติว่าคุณเริ่มจากสถานะที่แยกกันไม่ออกอย่างเต็มที่เช่น $|0\rangle^{\otimes n}$. ณ จุดนี้ทุก qubit จะแยกกันไม่ออกและมันก็เพียงพอที่จะเก็บ$n$รีจิสเตอร์ที่แตกต่างกันแต่ละสถานะของ qubit ที่แยกกันไม่ได้ หากประตูแรกของคุณเป็นเพียงการดำเนินการแบบบิตเดียว$U$ บน qubit $i$จากนั้นคุณเพียงแค่อัปเดตสถานะที่เก็บไว้ใน qubit $i$ เช่น $|\psi_i\rangle\mapsto U|\psi_i\rangle$และคุณไม่ต้องแตะต้องอะไรอีก

หากคุณต้องการทำเกตสองบิต $V$ ระหว่าง qubits $i$ และ $j$พูดแล้วคุณจะต้องรวมรัฐที่ทั้งสองเว็บไซต์ ดังนั้นคุณแทนที่การลงทะเบียนสองมิติแต่ละมิติด้วยการลงทะเบียนมิติ 4 หนึ่งครั้งที่มีสถานะ$V|\psi_i\rangle|\psi_j\rangle$. ปัญหาคือตอนนี้คุณไม่สามารถแยกสถานะนี้อีกครั้งได้ดังนั้นคุณต้องรักษาทั้งสอง qubits ไว้ในทะเบียนตลอดไป แน่นอนถ้าคุณมีเกต 1-qubit$U$ เพื่อใช้กับ qubit $i$ตอนนี้คุณจะต้องสมัคร $|\psi_{i,j}\rangle\mapsto U\otimes\mathbb{I}|\psi_{i,j}\rangle$. จากนั้นในครั้งต่อไปที่คุณต้องการเกต 2-qubit ระหว่างพูดว่า$j$ และ $k$คุณจะต้องรวมช่องว่างสำหรับ $(i,j)$ และ $k$. ช่องว่างเหล่านั้นจะเพิ่มขึ้นเรื่อย ๆ แต่ถ้ามีการแปลเป็นภาษาท้องถิ่นด้วยช่องว่างเพียงช่องเดียวคุณต้องใช้มันที่นั่น (ใช้$\mathbb{I}$ ตัวดำเนินการเพื่อวางลงบนส่วนที่เหลือของ qubits) และคุณไม่ต้องทำอะไรกับช่องว่างอื่น

หากคุณทำสิ่งนี้คุณจะไม่มี (อย่างน้อยสำหรับสองสามขั้นตอนแรกของอัลกอริทึม) $2^n$การลงทะเบียนองค์ประกอบ คุณจะต้องมีการลงทะเบียนที่แตกต่างกันจำนวนมากและติดตามว่า qubits ใดที่อธิบายโดยการลงทะเบียนในอาเรย์อื่น ทุกครั้งที่คุณรวมช่องว่างของ qubits คุณจะอัปเดตอาร์เรย์พิเศษนั้น

นี่คือรหัสเทียมที่หยั่งรู้บางอย่างที่อาจช่วยสื่อความหมายของฉัน:

#initialise variables
entangled_blocks={{1},{2},{3},...,{n}}
quantum_states={{1,0},{1,0},...,{1,0}}

#apply action of each gate
for each gate
   for each gate_target
       target_block=entangled_blocks entry containing gate_target
   next gate_target
   if all target_blocks equal then
      apply gate on target_block (pad with identity on other qubits)
   else
      new_entangled_block=union(target_blocks)
      new_state_vec=tensor_product(quantum_states for each target block)
      apply gate on new_state_vec (pad with identity on other qubits)
      replace all target_blocks in entangled_blocks with new_entangled_block
      replace all quantum_states(all target blocks) with new_state_vec
   end if
next gate

ตัวเลือกอื่น

(โดยไม่หมดจด)

คุณอาจสนใจอ่านเกี่ยวกับ Matrix Product States ซึ่งเป็นวิธีที่ดีในการห่อหุ้มข้อมูลเกี่ยวกับสถานะที่ไม่พันกันยุ่งเกินไปและอาจเป็นเส้นทางอื่นสำหรับคุณขึ้นอยู่กับว่าคุณพยายามทำอะไร