Kvantine Furje transformacija ir fazes ivertinimas

I Eksperimento tikslai

II Teorija

Diskrecioji Furje transformacija (DFT)

Klasikine DFT transformuoja N tasku seka x_0, ..., x_{N-1} i daznines komponentes. Kvantine Furje transformacija (QFT) atlieka ta pacia operacija, bet su kvantiniais busenu vektoriais eksponentiskai greiciau.

N = 2^n atveju, kur n -- kubitu skaicius, QFT isardo busena i tensorini fazoriniu busenu sandauga:

2-kubitu QFT grandine

2-kubitu sistemoje (N=4) QFT grandine susideda is:

Cia R2 yra valdomas S vartas (faze = pi/2 = 90 laipsniu), valdomas Q1 kubitu. Galutine SWAP operacija apvercia kubitu tvarka.

Kvantinis fazes ivertinimas (QPE)

QPE algoritmas nustato faze phi unitaraus operatoriaus U tikrinio vektoriaus |psi>: U|psi> = e^(2*pi*i*phi)|psi>. Algoritmas naudoja:

HHL algoritmas

HHL (Harrow-Hassidim-Lloyd) algoritmas sprencia tiesiniu lygciu sistema Ax = b kvantiskai. Jis naudoja QPE kaip surutina:

III QFT simuliatorius (2 kubitai)

Pasirinkite pradine 2-kubitu busena ir stebkite, kaip QFT transformuoja amplitudes ir fazes. Vizualizacija rodo amplitudes ir fazes kiekvienai isejimo busenai.

IV QFT zingsnis po zingsnio

Issamiai stebkite, kaip kiekvienas QFT grandines vartas keicia sistemos busena.

V Fazes ivertinimo (QPE) simuliatorius

Pasirinkite faze phi ir stebkite, kaip QPE algoritmas ja nustato. 2-kubitu registras gali tiksliai uzkoduoti fazes phi = k/4, kur k = 0, 1, 2, 3.

VI QPE tikslumo analize

Isnagrinekite, kaip registru skaicius n itakoja QPE tiksluma. Daugiau kubitu -- didesnis tikslumas, bet sudetingesne grandine.

VII HHL algoritmo vizualizacija

HHL algoritmas sprencia Ax = b. Stebkite, kaip QPE issklaido vektoriu b pagal tikrinius vektorius, o valdomas sukimas realizuoja A^(-1) operacija.

VIII SpinQ Gemini realizacija

SpinQ Gemini 2-kubitu sistemoje QFT realizuojama tiesiogiai, o QPE ir HHL -- supaprastintomis versijomis su 1 registriniu kubitu.

QFT grandines NMR atitikmenys

QPE 2-kubitu versija

Su vienu registriniu kubitu galima atskirti fazes phi = 0 ir phi = 1/2 (t.y. tikrines vertes +1 ir -1). Daugiau tikslumo reikalauja daugiau kubitu.

HHL 2-kubitu versija

SpinQ Gemini sistemoje HHL algoritmas realizuojamas supaprastintai: vienas kubitas -- registras (QPE), kitas -- duomenu kubitas (b vektorius). Tai leidzia spresti 2x2 diagonalines sistemas.

IX Eksperimento procedura

X Kontroliniai klausimai

XI Apibendrinimas

XII Programinis pavyzdys ir RQmod alternatyva

QFT, QPE ir HHL galima atkartoti tiek tiesiogine grandine Python kalboje (SpinQit / Qiskit / NumPy), tiek deklaratyviai aprasius .rqmod modelyje, kuri ResilQ Studio kompiliuoja i ResilQ IR ir QASM2 / SpinQit darba.

Pythonas: 2-kubitu QFT (SpinQit)

Pavyzdys realizuoja 2 kubitu kvantine Furje transformacija: H, valdomas R₂ (kontroliuojama S faze) ir SWAP, kad isvesties tvarka atitiktu kvantine konvencija.

# qft_2q.py — 2 kubitu kvantine Furje transformacija (SpinQit)
from spinqit import Circuit, BasicSimulator, get_compiler
from spinqit.model import H, S, CX, SWAP, MEASURE
import math

qc = Circuit(2)

# Pradine busena |10⟩ — testavimui
qc.append(H, [0])

# QFT: H, valdomas R₂ (S kontroliuojama), SWAP
qc.append(H, [0])
# Kontroliuojamas R_k = diag(1, exp(2πi/2^k)) realizuojamas per
# H, CX ir vieno kubito S vartus — supaprastinta seka:
qc.append(S,  [1])
qc.append(CX, [0, 1])
qc.append(S,  [1])
qc.append(CX, [0, 1])
qc.append(H, [1])
qc.append(SWAP, [0, 1])

qc.append(MEASURE, [0, 1])

backend = BasicSimulator()
exe     = get_compiler("native").compile(qc, 0)
print(backend.run(exe, 1024).counts)

Alternatyva: .rqmod modelis

Tas pats QFT/QPE eksperimentas iśreiškiamas auksciau abstrakcijos lygmeniu — modelyje paruosiama testavimo busena ir nurodoma QFT veiksmu seka. ResilQ Studio sugeneruoja QASM2 grandine ir CBOM iroduma.

// lab9-qft.rqmod
audit "lab9-qft-qpe" {
  targets = ["spinq-gemini-lab"]

  layers {
    use { runtime, openssl }
  }

  experiment qft_2q {
    qubits   = [q0, q1]
    prepare  { circuit { x(q0) } }       // |10⟩
    transform = qft
    measure  = z_basis
    shots    = 1024
  }

  experiment qpe_basic {
    qubits          = [q0, q1]
    unitary         = "diag(1, exp(2πi*0.25))"
    counting_qubits = [q0]
    eigenstate      = q1
    shots           = 1024
  }

  backend quantum {
    provider  = spinqit
    emit      = qasm2
    max_width = 2
  }

  output { formats = [json, cbom, qasm] }
}

resilq-q compile lab9-qft.rqmod --out build/lab9

Apie RQmod