Ang variational quantum eigensolver (VQE)

Ipapakilala ng araling ito ang variational quantum eigensolver, ipapaliwanag ang kahalagahan nito bilang isang pundasyon na algorithm sa quantum computing, at tatalakayin din ang mga kalakasan at kahinaan nito. Ang VQE sa sarili nito, nang walang mga karagdagang pamamaraan, ay malamang na hindi sapat para sa modernong utility-scale na quantum computations. Mahalaga pa rin ito bilang isang arketipong classical-quantum hybrid na pamamaraan, at ito ay isang mahalagang pundasyon kung saan maraming mas advanced na mga algorithm ang itinayo.

Ang video na ito ay nagbibigay ng pangkalahatang-ideya ng VQE at ng mga salik na nakakaapekto sa kahusayan nito. Ang teksto sa ibaba ay nagdaragdag ng mas maraming detalye at nagpapatupad ng VQE gamit ang Qiskit.

1. Ano ang VQE?

Ang variational quantum eigensolver ay isang algorithm na gumagamit ng classical at quantum computing nang magkasama upang makamit ang isang gawain. May 4 na pangunahing bahagi ang isang VQE na kalkulasyon:

Isang operator: Kadalasan ay isang Hamiltonian, na tatawagin nating $H$ , na naglalarawan ng isang katangian ng iyong sistema na nais mong i-optimize. Isa pang paraan ng pagsasabi nito ay naghahanap ka ng eigenvector ng operator na ito na tumutugma sa pinakamababang eigenvalue. Madalas nating tinatawag ang eigenvector na iyon na "ground state".
Isang "ansatz" (isang salitang Aleman na nangangahulugang "pamamaraan"): ito ay isang quantum circuit na naghahanda ng isang quantum state na nagtatantya sa eigenvector na hinahanap mo. Talaga, ang ansatz ay isang pamilya ng mga quantum circuit, dahil ang ilan sa mga Gate sa ansatz ay may mga parameter, ibig sabihin, binibigyan sila ng isang parameter na maaari nating baguhin. Ang pamilyang ito ng mga quantum circuit ay maaaring maghanda ng isang pamilya ng mga quantum state na nagtatantya sa ground state.
Isang estimator: isang paraan ng pagtatantya ng expectation value ng operator na $H$ sa kasalukuyang variational quantum state. Minsan ang talagang pinahahalagahan natin ay ang expectation value na ito lamang, na tinatawag nating isang cost function. Minsan, pinapahalagahan natin ang isang mas kumplikadong function na maaari pa ring isulat mula sa isa o higit pang mga expectation value.
Isang classical optimizer: isang algorithm na nagbabago ng mga parameter upang subukang i-minimize ang cost function.

Tingnan natin ang bawat isa sa mga bahaging ito nang mas malalim.

1.1 Ang operator (Hamiltonian)

Sa kaibuturan ng isang VQE na problema ay isang operator na naglalarawan ng isang sistema ng interes. Ipagpalagay natin dito na ang pinakamababang eigenvalue at ang kaukulang eigenvector ng operator na ito ay kapaki-pakinabang para sa ilang siyentipiko o pang-negosyong layunin. Ang mga halimbawa ay maaaring kabilang ang isang chemical Hamiltonian na naglalarawan ng isang molekula, tulad na ang pinakamababang eigenvalue ng operator ay tumutugma sa ground state energy ng molekula, at ang kaukulang eigenstate ay naglalarawan ng geometry o electron configuration ng molekula. O ang operator ay maaaring naglalarawan ng gastos ng isang tiyak na proseso na ia-optimize, at ang mga eigenstate ay maaaring tumutugma sa mga ruta o gawi. Sa ilang larangan, tulad ng pisika, ang "Hamiltonian" ay halos palaging tumutukoy sa isang operator na naglalarawan ng enerhiya ng isang pisikal na sistema. Ngunit sa quantum computing, karaniwan na makita ang mga quantum operator na naglalarawan ng isang negosyo o logistikal na problema na tinutukoy din bilang "Hamiltonian". Gagamitin natin ang kombensyong iyon dito.

Isang larawan ng mga atomic orbital at isang larawan ng isang network na may maraming node at koneksyon sa pagitan ng mga ito.

Ang pag-map ng isang pisikal o optimization na problema sa mga Qubit ay karaniwang hindi trivial na gawain, ngunit ang mga detalyeng iyon ay hindi ang pokus ng kursong ito. Ang isang pangkalahatang talakayan ng pag-map ng isang problema sa isang quantum operator ay makikita sa Quantum computing in practice. Ang isang mas detalyadong pagtingin sa pag-map ng mga problema sa chemistry sa mga quantum operator ay makikita sa Quantum Chemistry with VQE.

Para sa layunin ng kursong ito, ipagpalagay natin na kilala ang anyo ng Hamiltonian. Halimbawa, ang isang Hamiltonian para sa isang simpleng hydrogen na molekula (sa ilalim ng ilang active space na pagpapalagay, at gamit ang Jordan-Wigner mapper) ay:

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

from qiskit.quantum_info import SparsePauliOp

hamiltonian = SparsePauliOp(
    [
        "IIII",
        "IIIZ",
        "IZII",
        "IIZI",
        "ZIII",
        "IZIZ",
        "IIZZ",
        "ZIIZ",
        "IZZI",
        "ZZII",
        "ZIZI",
        "YYYY",
        "XXYY",
        "YYXX",
        "XXXX",
    ],
    coeffs=[
        -0.09820182 + 0.0j,
        -0.1740751 + 0.0j,
        -0.1740751 + 0.0j,
        0.2242933 + 0.0j,
        0.2242933 + 0.0j,
        0.16891402 + 0.0j,
        0.1210099 + 0.0j,
        0.16631441 + 0.0j,
        0.16631441 + 0.0j,
        0.1210099 + 0.0j,
        0.17504456 + 0.0j,
        0.04530451 + 0.0j,
        0.04530451 + 0.0j,
        0.04530451 + 0.0j,
        0.04530451 + 0.0j,
    ],
)

Pansinin na sa Hamiltonian sa itaas, may mga termino tulad ng ZZII at YYYY na hindi nagko-commute sa isa't isa. Ibig sabihin, upang masuri ang ZZII, kailangan nating sukatin ang Pauli Z operator sa Qubit 3 (bukod sa iba pang mga pagsukat). Ngunit upang masuri ang YYYY, kailangan nating sukatin ang Pauli Y operator sa parehong Qubit, Qubit 3. May uncertainty relation sa pagitan ng Y at Z na mga operator sa parehong Qubit; hindi natin maaaring sukatin ang parehong mga operator nang sabay-sabay. Babalik tayo sa puntong ito sa ibaba, at sa katunayan sa buong kurso.

Ang Hamiltonian sa itaas ay isang $16\times 16$ na matrix operator. Ang pag-diagonalize ng operator upang mahanap ang pinakamababang energy eigenvalue nito ay hindi mahirap.

import numpy as np

A = np.array(hamiltonian)
eigenvalues, eigenvectors = np.linalg.eigh(A)
print("The ground state energy is ", min(eigenvalues), "hartrees")

The ground state energy is  -1.1459778447627311 hartrees

Ang mga brute-force classical eigensolver ay hindi maaaring mag-scale upang ilarawan ang mga enerhiya o geometry ng napakalaking mga sistema ng mga atom, tulad ng mga gamot o protina. Ang VQE ay isa sa mga maagang pagtatangkang gamitin ang quantum computing sa problemang ito.

Makakatagpo tayo ng mga Hamiltonian sa araling ito na mas malaki kaysa sa nasa itaas. Ngunit magiging pag-aaksaya ang pagtutulak ng mga limitasyon ng magagawa ng VQE, bago pa man ipakilala natin ang ilan sa mga mas advanced na tool na maaaring dagdagan o palitan ang VQE, sa susunod na bahagi ng kursong ito.

1.2 Ansatz

Ang salitang "ansatz" ay Aleman para sa "pamamaraan". Ang tamang plural sa Aleman ay "ansätze", bagaman madalas nakikita ang "ansatzes" o "ansatze". Sa konteksto ng VQE, ang ansatz ay ang quantum circuit na ginagamit mo upang lumikha ng isang multi-qubit na wave function na pinakamalapit na nagtatantya sa ground state ng sistemang pinag-aaralan mo, at na nagbubunga ng pinakamababang expectation value ng iyong operator. Ang quantum circuit na ito ay maglalaman ng mga variational parameter (kadalasan ay pinagsama-sama sa vector ng mga variable na $\vec{\theta}$ ).

Isang larawan ng isang quantum circuit na may mga variational parameter na may label na "theta".

Isang paunang hanay ng mga halaga na $\vec{\theta_0}$ ng mga variational parameter ang pinipili. Tatawagin natin ang unitary na operasyon ng ansatz sa Circuit na $U_{\text{var}}(\vec{\theta_0})$ . Bilang default, lahat ng Qubit sa mga quantum computer ng IBM® ay ini-initialize sa $|0\rangle$ na estado. Kapag pinatakbo ang Circuit, ang estado ng mga Qubit ay magiging

|\psi(\vec{\theta_0})\rangle=U_{\text{var}}(\vec{\theta_0})|0\rangle^{\otimes N}

Kung kailangan natin lamang ang pinakamababang enerhiya (gamit ang wika ng mga pisikal na sistema), maaari nating tantiyahin ito sa pamamagitan ng simpleng pagsukat ng enerhiya nang maraming beses at pagkuha ng pinakamababa. Ngunit kadalasan gusto rin natin ang configuration na nagbubunga ng pinakamababang enerhiya o eigenvalue na iyon. Kaya ang susunod na hakbang ay ang pagtatantya ng expectation value ng Hamiltonian, na natatamo sa pamamagitan ng mga quantum na pagsukat. Maraming bagay ang pumapasok doon. Ngunit maaari nating maunawaan ang prosesong ito nang qualitative sa pamamagitan ng pagpuna na ang probabilidad na $P_j$ ng pagsukat ng isang enerhiyang $E_j$ (muli gamit ang wika ng mga pisikal na sistema) ay may kaugnayan sa expectation value sa pamamagitan ng:

\langle \psi(\vec{\theta_0}) |H|\psi (\vec{\theta_0}) \rangle

Ang probabilidad na $P_j$ ay may kaugnayan din sa overlap sa pagitan ng eigenstate na $|\phi_j\rangle$ at ng kasalukuyang estado ng sistema na $|\psi(\vec{\theta_0})\rangle$ :

P_j=|\langle \phi_j|\psi(\vec{\theta_0})\rangle|^2 = |\langle \phi_j|U_{\text{var}}(\vec{\theta_0})|0\rangle^{\otimes N}|^2

Kaya sa pamamagitan ng paggawa ng maraming pagsukat ng mga Pauli operator na bumubuo ng ating Hamiltonian, maaari nating tantiyahin ang expectation value ng Hamiltonian sa kasalukuyang estado ng sistema na $|\psi(\vec{\theta_0})\rangle$ . Ang susunod na hakbang ay ang pagbabago ng mga parameter na $\vec{\theta}$ at pagsubok na mas malapit na lumapit sa pinakamababang-enerhiya (ground) na estado ng sistema. Dahil sa mga variational parameter sa ansatz, minsan naririnig itong tinutukoy bilang variational form.

Bago tayo lumipat sa variational na proseso, pansinin na kadalasang kapaki-pakinabang na simulan ang iyong estado mula sa isang "mabuting hula" na estado. Maaaring alam mo ang sapat tungkol sa iyong sistema upang makagawa ng mas mabuting paunang hula kaysa sa $|0\rangle^{\otimes N}$ . Halimbawa, karaniwan na ini-initialize ang mga Qubit sa Hartree-Fock na estado sa mga chemical na aplikasyon. Ang paunang hulang ito na hindi naglalaman ng anumang variational parameter ay tinatawag na reference state. Tatawagin natin ang quantum circuit na ginagamit upang lumikha ng reference state na $U_{ref}$ . Tuwing nagiging mahalaga ang pagtukoy sa reference state mula sa natitirang bahagi ng ansatz, gamitin ang: $U_{\text{ansatz}}(\vec{\theta}) =U_{\text{var}}(\vec{\theta})U_{\text{ref}}.$ Katumbas nito

\begin{aligned} |\psi_{\text{ref}}\rangle&=U_{\text{ref}}|0\rangle^{\otimes N}\\ |\psi_{\text{ansatz}}(\vec{\theta})\rangle&=U_{var}(\vec{\theta})|\psi_{\text{ref}}\rangle = U_{\text{var}}(\vec{\theta})U_{\text{ref}}|0\rangle^{\otimes N}. \end{aligned}

1.3 Estimator

Kailangan natin ng paraan upang matantya ang expectation value ng ating Hamiltonian sa isang partikular na variational state na $|\psi(\vec{\theta})\rangle$ . Kung maaari tayong direktang sukatin ang buong operator na $H$ , ito ay magiging kasing simple ng paggawa ng maraming (sabihing $N$ ) na pagsukat at pag-average ng mga nasukat na halaga:

\langle \psi(\vec{\theta})|H|\psi(\vec{\theta})\rangle _N \approx \frac{1}{N}\sum_{j=1}^N {E_j}

Dito, ang simbolong $\approx$ ay nagpapaalala sa atin na ang expectation value na ito ay tumpak lamang sa limitasyon habang $N\rightarrow \infty$ . Ngunit sa libu-libong pagsukat na ginagawa sa isang Circuit, ang sampling error ng expectation value ay medyo mababa. May iba pang mga konsiderasyon tulad ng ingay na nagiging isyu para sa mga napaka-tumpak na kalkulasyon.

Gayunpaman, sa pangkalahatan ay hindi posible na sukatin ang $H$ nang sabay-sabay. Ang $H$ ay maaaring maglaman ng maraming non-commuting na Pauli X, Y, at Z operator. Kaya ang Hamiltonian ay dapat hatiin sa mga grupo ng mga operator na maaaring sabay na sukatin, at ang bawat ganitong grupo ay dapat tantiyahin nang hiwalay, at ang mga resulta ay pinagsama upang makakuha ng isang expectation value. Babalik tayo rito nang mas detalyado sa susunod na aralin, kapag tinatalakay natin ang scaling ng mga classical at quantum na pamamaraan. Ang kumplikasyon sa pagsukat na ito ay isa sa mga dahilan kaya kailangan natin ng napaka-episyenteng code para sa pagsasagawa ng ganitong pagtatantya. Sa araling ito at higit pa, gagamitin natin ang Qiskit Runtime primitive Estimator para sa layuning ito.

1.4 Mga classical optimizer

Ang isang classical optimizer ay anumang classical algorithm na idinisenyo upang mahanap ang mga extrema ng isang target na function (karaniwang isang minimum). Naghahanap sila sa espasyo ng mga posibleng parameter upang mahanap ang isang hanay na nagmi-minimize ng ilang function ng interes. Maaari silang malawak na ikategorya sa mga gradient-based na pamamaraan, na gumagamit ng impormasyon ng gradient, at mga gradient-free na pamamaraan, na gumagana bilang mga black-box optimizer. Ang pagpili ng classical optimizer ay maaaring malaki ang epekto sa pagganap ng isang algorithm, lalo na sa presensya ng ingay sa quantum hardware. Ang mga sikat na optimizer sa larangang ito ay kinabibilangan ng Adam, AMSGrad, at SPSA, na nagpakita ng magagandang resulta sa mga maingay na kapaligiran. Ang mga mas tradisyonal na optimizer ay kinabibilangan ng COBYLA at SLSQP.

Isang karaniwang workflow (ipinakita sa Seksyon 3.3) ay ang paggamit ng isa sa mga algorithm na ito bilang paraan sa loob ng isang minimizer tulad ng minimize function ng scipy. Ito ay tumatanggap ng mga sumusunod na argumento:

Ilang function na ie-minimize. Ito ay kadalasang ang energy expectation value. Ngunit ang mga ito ay karaniwang tinutukoy bilang "cost functions".
Isang hanay ng mga parameter kung saan sisimulan ang paghahanap. Kadalasan ay tinatawag na $x_0$ o $\theta_0$ .
Mga argumento, kasama ang mga argumento ng cost function. Sa quantum computing gamit ang Qiskit, ang mga argumentong ito ay magsasama ng ansatz, ang Hamiltonian, at ang estimator, na tinatalakay nang higit pa sa susunod na subseksyon.
Isang 'method' ng minimization. Tumutukoy ito sa partikular na algorithm na ginagamit upang hanapin ang espasyo ng parameter. Dito natin tutukuyin, halimbawa, ang COBYLA o SLSQP.
Mga opsyon. Ang mga opsyong available ay maaaring magkaiba ayon sa paraan. Ngunit isang halimbawa na halos lahat ng pamamaraan ay maglalaman ay ang maximum na bilang ng mga iteration ng optimizer bago tapusin ang paghahanap: 'maxiter'.

Isang larawan na nagpapakita ng isang kurba na linya na kumakatawan sa enerhiya na may ilang mga punto kung saan tinutukoy ang halaga upang mahanap ang minimum.

Sa bawat iterative na hakbang, ang expectation value ng Hamiltonian ay tinantya sa pamamagitan ng paggawa ng maraming pagsukat. Ang tinantiyang enerhiyang ito ay ibinalik ng cost function, at ina-update ng minimizer ang impormasyon nito tungkol sa landscape ng enerhiya. Kung ano mismo ang ginagawa ng optimizer upang pumili ng susunod na hakbang ay nag-iiba mula sa pamamaraan patungo sa pamamaraan. Ang ilan ay gumagamit ng mga gradient at pinipili ang direksyon ng pinaka-matarik na pagbaba. Ang iba ay maaaring isaalang-alang ang ingay at maaaring kailanganin na bumaba nang malaki ang gastos bago tanggapin na talagang bumababa ang tunay na enerhiya sa direksyong iyon.

# Example syntax for minimization
# from scipy.optimize import minimize
# res = minimize(cost_func, x0, args=(ansatz, hamiltonian, estimator), method="cobyla", options={'maxiter': 200})

1.5 Ang variational principle

Sa kontekstong ito ang variational principle ay napakahalaga; isinasaad nito na walang variational wave function ang maaaring magbigay ng isang energy (o cost) expectation value na mas mababa kaysa sa ibinibigay ng ground state wave function. Mathematically,

E_\text{var}=\langle \psi_\text{var}|H|\psi_\text{var}\rangle \geq E_\text{min}=\langle \psi_\text{0}|H|\psi_\text{0}\rangle

Ito ay madaling i-verify kung mapapansin natin na ang hanay ng lahat ng eigenstate na $\{|\psi_0\rangle, |\psi_1\rangle, |\psi_2\rangle, ...|\psi_n \rangle\}$ ng $H$ ay bumubuo ng isang kumpletong basis para sa Hilbert space. Sa madaling salita, anumang estado at partikular ang $|\psi_\text{var}\rangle$ ay maaaring isulat bilang isang weighted (normalized) na kabuuan ng mga eigenstates ng $H$ :

|\psi_\text{var}\rangle=\sum_{i=0}^n c_i |\psi_i\rangle

kung saan ang $c_i$ ay mga constant na tutukuyin, at $\sum_{i=0} |c_i|^2 = 1$ . Iniiwan natin ito bilang isang ehersisyo para sa mambabasa. Ngunit pansinin ang implikasyon: ang variational state na nagbubunga ng pinakamababang-enerhiya na expectation value ay ang pinakamahusay na tantya ng tunay na ground state.

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, isipin ang iyong sagot, pagkatapos ay i-click ang tatsulok upang ipakita ang solusyon.

I-verify sa mathematical na $E_\text{var}\geq E_0$ para sa anumang variational state na $|\psi_\text{var}\rangle$ .

Sagot:

Gamit ang ibinigay na expansion ng variational state sa mga tuntunin ng mga energy eigenstate,

|\psi_\text{var}\rangle=\sum_{i=0}^n c_i |\psi_i\rangle,

maaari nating isulat ang variational energy expectation value bilang

\begin{aligned} E_\text{var}&=\langle \psi_\text{var}|H|\psi_\text{var}\rangle =\left(\sum_{i=0}^n c^*_i \langle \psi_i|\right)H\left(\sum_{j=0}^n c_j |\psi_j\rangle\right)\\ &=\left(\sum_{i=0}^n c^*_i \langle \psi_i|\right)\left(\sum_{j=0}^n c_j E_j|\psi_j\rangle\right)\\ &=\sum_{i,j=0}^n c^*_i c_j E_j \langle \psi_i|\psi_j\rangle\\ &=\sum_{i,j=0}^n c^*_i c_j E_j \delta_{i,j}\\ &=\sum_{i=0}^n |c_i|^2 E_i. \end{aligned}

Para sa lahat ng coefficient na $0\leq|c_i|^2\leq 1$ . Kaya maaari tayong sumulat

\begin{aligned} E_\text{var}&=\sum_{i=0}^n |c_i|^2 E_i\geq \sum_{i=0}^n |c_i|^2 E_0 = E_0 \sum_{i=0}^n |c_i|^2 = E_0(1) \\ E_\text{var}&\geq E_0 \end{aligned}

2. Paghahambing sa classical workflow

Sabihin nating interesado tayo sa isang matrix na may N na hanay at N na kolum. Ipagpalagay na ang iyong matrix ay napakalaki na ang eksaktong diagonalization ay hindi isang pagpipilian. Ipagpalagay pa na alam mo ang sapat tungkol sa iyong problema upang makagawa ng ilang hula tungkol sa pangkalahatang istruktura ng target na eigenstate, at gusto mong suriin ang mga estado na katulad ng iyong paunang hula upang makita kung ang iyong cost/energy ay maaaring bawasan pa. Ito ay isang variational na pamamaraan, at ito ay isa sa mga pamamaraang ginagamit kapag ang eksaktong diagonalization ay hindi isang pagpipilian.

2.1 Classical workflow

Gamit ang isang classical computer, ito ay gagana tulad ng sumusunod:

Gumawa ng isang guess state, na may ilang mga parameter na $\vec{\theta}_i$ na babaguhin mo: $|\psi(\vec{\theta}_i)\rangle$ . Bagaman ang paunang hulang ito ay maaaring random, hindi ito advisable. Gusto nating gamitin ang kaalaman ng problema sa kamay upang iakma ang ating hula nang hangga't maaari.
Kalkulahin ang expectation value ng operator kasama ang sistema sa estadong iyon: $\langle\psi(\vec{\theta}_i)|H|\psi(\vec{\theta}_i)\rangle$
Baguhin ang mga variational parameter at ulitin: $\vec{\theta}_i\rightarrow \vec{\theta}_{i+1}$ .
Gamitin ang naipong impormasyon tungkol sa landscape ng mga posibleng estado sa iyong variational subspace upang gumawa ng mas magagandang hula at lumapit sa target na estado. Ginagarantiyahan ng variational principle na ang ating variational state ay hindi maaaring magbigay ng eigenvalue na mas mababa kaysa sa target na ground state. Kaya mas mababa ang expectation value mas mabuti ang ating pagtatantya ng ground state:

\min_{\vec{\theta}} \{ E_{\text{var},i} = \langle\psi(\vec{\theta_i})|H|\psi(\vec{\theta_i})\rangle \} \geq E_0

Suriin natin ang kahirapan ng bawat hakbang sa pamamaraang ito. Ang pag-set o pag-update ng mga parameter ay madaling gawain sa computational; ang kahirapan doon ay sa pagpili ng mga kapaki-pakinabang, pisikal na motivated na paunang mga parameter. Ang paggamit ng naipong impormasyon mula sa mga nakaraang iteration upang i-update ang mga parameter sa paraang lumalayo ka sa ground state ay non-trivial. Ngunit ang mga classical optimization algorithm ay umiiral na gumagawa nito nang napaka-episyente. Ang classical optimization na ito ay mahal lamang dahil maaari itong mangailangan ng maraming iteration; sa pinakamasamang kaso, ang bilang ng mga iteration ay maaaring mag-scale nang exponentially kasama ang N. Ang pinaka-computationally expensive na solong hakbang ay halos tiyak na ang pagkalkula ng expectation value ng iyong matrix gamit ang isang ibinigay na estado na $|\psi(\vec{\theta_i})\rangle$ : $\langle\psi(\vec{\theta_i})|H|\psi(\vec{\theta_i})\rangle.$

Ang $N\times N$ na matrix ay kailangang kumilos sa $N$ -element na vector, na tumutugma sa: $O(N^2)$ na mga operasyon ng multiplikasyon sa pinakamasamang kaso. Ito ay dapat gawin sa bawat iteration ng mga parameter. Para sa napakalaking mga matrix, ito ay may mataas na computational cost.

2.2 Quantum workflow at commuting Pauli groups

Ngayon isipin ang paglipat ng bahaging ito ng kalkulasyon sa isang quantum computer. Sa halip na kalkulahin ang expectation value na ito, tinantya mo ito sa pamamagitan ng paghahanda ng estado na $|\psi(\vec{\theta_i})\rangle$ sa quantum computer gamit ang iyong variational ansatz, at pagkatapos ay paggawa ng mga pagsukat.

Maaaring mukhang mas madali ito kaysa sa totoong nangyayari. Ang $H$ ay sa pangkalahatan ay hindi madaling sukatin. Halimbawa, maaari itong binubuo ng maraming non-commuting na Pauli X, Y, at Z operator. Ngunit ang $H$ ay maaaring isulat bilang isang linear na kombinasyon ng mga termino, $h_\alpha$ , na bawat isa ay madaling masusukat (halimbawa, mga Pauli operator o mga grupo ng qubit-wise commuting na Pauli operator). Ang expectation value ng $H$ sa ilang estado na $|\Psi\rangle$ ay ang weighted na kabuuan ng mga expectation value ng mga bumubuo na termino na $h_\alpha$ . Ang ekspresyong ito ay naaangkop para sa anumang estado na $|\Psi⟩$ , ngunit gagamitin nating ito nang partikular kasama ang ating mga variational state na $|\psi(\theta_i)\rangle$ .

H = \sum_{\alpha = 1}^T{c_\alpha h_\alpha}

kung saan ang $h_\alpha$ ay isang Pauli string tulad ng IZZX…XIYX, o ilang mga ganitong string na nagko-commute sa isa't isa. Kaya ang isang paglalarawan ng expectation value na mas malapit na tumutugma sa mga katotohanan ng pagsukat sa mga quantum computer ay

\langle \Psi |H|\Psi \rangle =\sum_{\alpha} c_\alpha \langle \Psi | h_\alpha|\Psi \rangle.

At sa konteksto ng ating variational wave function:

\langle \psi(\vec{\theta}_i) |H|\psi(\vec{\theta}_i) \rangle =\sum_{\alpha} c_\alpha \langle \psi(\vec{\theta}_i) | h_\alpha|\psi(\vec{\theta}_i) \rangle

Ang bawat isa sa mga termino na $h_\alpha$ ay maaaring sukatin nang $M$ na beses na nagbubunga ng mga sample ng pagsukat na $s_{\alpha j}$ na may $j=1…M$ at nagbabalik ng isang expectation value na $\mu_\alpha$ at isang standard deviation na $\sigma_\alpha$ . Maaari nating kabuuanin ang mga terminong ito at ipagpatuloy ang mga error sa kabuuan upang makakuha ng pangkalahatang expectation value na $\mu$ at standard deviation na $\sigma$ .

\begin{aligned} \langle \psi(\vec{\theta}_i) |h_\alpha|\psi(\vec{\theta}_i) \rangle &\simeq \mu _\alpha \pm \frac{\sigma_\alpha}{\sqrt{M}} &\qquad \mu_\alpha &=\frac{1}{M}\sum_j s_{\alpha,j} &\qquad \sigma^2_\alpha &=\frac{1}{M-1}\sum_j (s_{\alpha,j}-\mu_\alpha)^2\\ \langle \psi(\vec{\theta}_i) |H|\psi(\vec{\theta}_i) \rangle &\simeq \mu \pm \sigma &\qquad \mu &= \sum_\alpha c_\alpha \mu_\alpha &\qquad \sigma^2&=\sum_\alpha c^2_\alpha \frac{\sigma^2_\alpha }{M} \end{aligned}

Hindi ito nangangailangan ng malakihang multiplikasyon, ni anumang proseso na kinakailangan ay nag-scale tulad ng $N^2$ . Sa halip, nangangailangan ito ng maraming pagsukat sa quantum computer. Kung hindi ka nangangailangan ng napakarami sa mga iyon, ang pamamaraang ito ay maaaring maging episyente. At iyon ang quantum na bahagi ng VQE.

Ngunit pag-usapan natin ang mga dahilan kung bakit maaaring hindi ito maging episyente. Isang dahilan para sa maraming pagsukat ay upang mabawasan ang statistical uncertainty sa iyong mga tantya, para sa mga napaka-tumpak na kalkulasyon. Isa pang dahilan ay ang bilang ng mga Pauli string na kinakailangan upang masaklaw ang iyong buong matrix. Dahil ang mga Pauli matrix (kasama ang identity: X, Y, Z, at I) ay sumasaklaw sa espasyo ng lahat ng operator ng isang ibinigay na dimensyon, ginagarantiyahan na maaari nating isulat ang ating matrix ng interes bilang isang weighted na kabuuan ng mga Pauli operator, tulad ng ginawa natin kanina.

H = \sum_{\alpha = 1}^T{c_\alpha h_\alpha}

kung saan ang $h_\alpha$ ay isang Pauli string na kumikilos sa lahat ng Qubit na naglalarawan ng iyong sistema tulad ng IZZX…XIYX, o ilang mga ganitong string na nagko-commute sa isa't isa. Alalahanin na ang Qiskit ay gumagamit ng little endian na notation, kung saan ang $n^\text{th}$ na Pauli operator mula sa kanan ay kumikilos sa $n^\text{th}$ na Qubit. Kaya maaari nating sukatin ang ating operator sa pamamagitan ng pagsukat ng isang serye ng mga Pauli operator.

Ngunit hindi natin maaaring sukatin ang lahat ng mga Pauli operator nang sabay-sabay. Ang mga Pauli operator (hindi kasama ang I) ay hindi nagko-commute sa isa't isa kung sila ay nauugnay sa parehong Qubit. Halimbawa, maaari nating sukatin ang IZIZ at ZZXZ nang sabay-sabay, dahil maaari nating sukatin ang I at Z nang sabay-sabay para sa ika-3 na Qubit, at maaari nating malaman ang I at X nang sabay-sabay para sa ika-1 na Qubit. Ngunit hindi natin maaaring sukatin ang ZZZZ at ZZZX nang sabay-sabay, dahil ang Z at X ay hindi nagko-commute, at ang pareho ay kumikilos sa ika-0 na Qubit.

Isang talahanayan ng iba't ibang Pauli string, ang ilan sa kanila ay nagko-commute at ang iba ay hindi.

Kaya nag-decompose tayo ng ating matrix na $H$ sa isang kabuuan ng mga Pauli na kumikilos sa iba't ibang Qubit. Ang ilang mga elemento ng kabuuang iyon ay maaaring sukatin nang sabay-sabay; tinatawag natin itong grupo ng mga commuting Pauli. Depende sa dami ng mga non-commuting na termino, maaaring kailangan natin ng maraming ganitong grupo. Tawagan ang bilang ng ganitong mga grupo ng commuting Pauli string na $N_\text{GCP}$ . Kung maliit ang $N_\text{GCP}$ , ito ay maaaring gumana nang maayos. Kung ang $H$ ay may milyun-milyong grupo, hindi ito magiging kapaki-pakinabang.

Ang mga prosesong kinakailangan para sa pagtatantya ng expectation value ay pinagsama-sama sa Qiskit Runtime primitive na tinatawag na Estimator. Upang matuto nang higit pa tungkol sa Estimator, tingnan ang API reference sa IBM Quantum® Documentation. Maaari itong gamitin nang direkta ang Estimator, ngunit ang Estimator ay nagbabalik ng higit pa kaysa sa pinakamababang energy eigenvalue lamang. Halimbawa, nagbabalik din ito ng impormasyon sa ensemble standard error. Kaya, sa konteksto ng mga problema sa minimization, madalas na makikita ang Estimator sa loob ng isang cost function. Upang matuto nang higit pa tungkol sa mga input at output ng Estimator tingnan ang gabay na ito sa IBM Quantum Documentation.

Itinatala mo ang expectation value (o ang cost function) para sa hanay ng mga parameter na $\vec{\theta_i}$ na ginamit sa iyong estado, at pagkatapos ay ina-update mo ang mga parameter. Sa paglipas ng panahon, maaari mong gamitin ang mga expectation value o cost-function value na iyong tinantya upang tantiyahin ang isang gradient ng iyong cost function sa subspace ng mga estado na samplingin ng iyong ansatz. Parehong gradient-based at gradient-free na classical optimizer ay umiiral. Parehong nagdurusa mula sa mga potensyal na isyu sa trainability, tulad ng maraming local minima, at malalaking rehiyon ng espasyo ng parameter na may malapit-sa-zero na gradient, na tinatawag na barren plateaus.

Dalawang larawan ng isang kurba na linya na may pinakamababang halaga. Sa isa, ang mga punto ay random na sinusuri sa paghahanap ng minimum, sa isa pa ang isang gradient ay tinantya sa pamamagitan ng paglalagay ng linya sa pagitan ng dalawang magkadikit na punto.

2.3 Mga salik na nagtatakda ng computational cost

Hindi lulutasin ng VQE ang lahat ng iyong pinakamahirap na mga problema sa quantum chemistry. Hindi. Ngunit ang maging mas mahusay sa lahat ng kalkulasyon ay hindi ang punto. Inilipat natin kung ano ang nagtatakda ng computational cost.

Isang talahanayan na naghahambing ng classical at quantum variational na mga pamamaraan. Parehong nangangailangan ng magagandang paunang hula. Sa classical, ang gastos ay nag-scale tulad ng dimensyon ng iyong matrix na squared, at sa quantum na pamamaraan ito ay depende sa kung ilang grupo ng commuting Pauli operator ang mayroon ka.

Lumipat tayo mula sa isang proseso na ang kumplikasyon ay nakasalalay lamang sa dimensyon ng matrix patungo sa isa na nakasalalay sa kinakailangang katumpakan at sa bilang ng mga non-commuting na Pauli operator na bumubuo ng matrix. Ang huling bahagi ay walang katulad sa classical computing.

Batay sa mga dependency na ito, para sa mga sparse na matrix, o mga matrix na nagsasangkot ng kaunting non-commuting na Pauli string, ang prosesong ito ay maaaring maging kapaki-pakinabang. Ito ang kaso para sa mga sistema ng mga nakikipag-ugnayan na spin, halimbawa. Para sa mga dense na matrix, maaaring ito ay hindi gaanong kapaki-pakinabang. Alam natin halimbawa na ang mga chemical na sistema ay kadalasang may mga Hamiltonian na nagsasangkot ng daan-daan, libo-libo, kahit milyun-milyong Pauli string. May kawili-wiling gawain na nagawa upang mabawasan ang bilang ng mga terminong ito. Ngunit ang mga chemical na sistema ay maaaring mas angkop sa ilan sa mga iba pang algorithm na tatalakayin natin sa kursong ito.

Suriin ang iyong pag-unawa

Basahin ang mga tanong sa ibaba, isipin ang iyong mga sagot, pagkatapos ay i-click ang mga tatsulok upang ipakita ang mga solusyon.

Isaalang-alang ang isang Hamiltonian sa apat na Qubit na naglalaman ng mga termino:

IIXX, IIXZ, IIZZ, IZXZ, IXXZ, ZZXZ, XZXZ, ZIXZ, ZZZZ, XXXX

Gusto mong pagbukurin ang mga terminong ito sa mga grupo upang ang lahat ng termino sa isang grupo ay maaaring sukatin nang sabay-sabay. Ano ang pinakamaliit na bilang ng ganitong mga grupo na maaari mong gawin upang masama ang lahat ng termino?

Sagot:

Maaaring gawin sa 5 grupo. Pansinin na ang mga ganitong solusyon ay karaniwang hindi natatangi.

IIXX, XXXX

IIXZ, IZXZ, ZZXZ

IIZZ, ZZZZ

IXXZ, ZIXZ

XZXZ

Alin ang inaasahan mong karaniwang nagpapahirap sa quantum chemistry gamit ang VQE: ang bilang ng mga termino sa Hamiltonian, o ang paghanap ng isang mabuting ansatz?

Sagot:

Lumalabas na may mga ansätze na lubos na na-optimize para sa mga chemical na konteksto. Ang bilang ng mga termino sa Hamiltonian, at kaya ang bilang ng mga pagsukat na kinakailangan ay karaniwang nagdudulot ng mas maraming problema.

3. Halimbawang Hamiltonian

Subukan nating gamitin ang algorithm na ito gamit ang isang maliit na Hamiltonian matrix para makita kung ano ang nangyayari sa bawat hakbang. Gagamitin natin ang Qiskit patterns framework:

-Hakbang 1: I-map ang problema sa mga quantum circuit at operator -Hakbang 2: I-optimize para sa target na hardware -Hakbang 3: Isagawa sa target na hardware -Hakbang 4: I-post-process ang mga resulta

3.1 Hakbang 1: I-map ang problema sa mga quantum circuit at operator

Gagamitin natin ang Hamiltonian na tinukoy natin kanina mula sa konteksto ng chemistry. Magsisimula tayo sa ilang pangkalahatang imports.

# General imports
import numpy as np

# SciPy minimizer routine
from scipy.optimize import minimize

# Plotting functions
import matplotlib.pyplot as plt

Muli, inaasahan nating alam na ang Hamiltonian na gusto natin. Gagamit tayo ng napakaliit na Hamiltonian dito, dahil ang ibang mga pamamaraan na tatalakayin sa kursong ito ay mas mahusay sa paglutas ng mas malalaking problema.

from qiskit.quantum_info import SparsePauliOp
import numpy as np

hamiltonian = SparsePauliOp.from_list(
    [("YZ", 0.3980), ("ZI", -0.3980), ("ZZ", -0.0113), ("XX", 0.1810)]
)

A = np.array(hamiltonian)
eigenvalues, eigenvectors = np.linalg.eigh(A)
print("The ground state energy is ", min(eigenvalues))

The ground state energy is  -0.702930394459531

Maraming handa nang ansatz na pagpipilian sa Qiskit. Gagamit tayo ng efficient_su2.

# Pre-defined ansatz circuit and operator class for Hamiltonian
from qiskit.circuit.library import efficient_su2

# Note that it is more common to place initial 'h' gates outside the ansatz. Here we specifically wanted this layer structure.
ansatz = efficient_su2(
    hamiltonian.num_qubits, su2_gates=["h", "rz", "y"], entanglement="circular", reps=1
)

num_params = ansatz.num_parameters
print("This circuit has ", num_params, "parameters")

ansatz.decompose().draw("mpl", style="iqp")

This circuit has  4 parameters

Output of the previous code cell

Ang iba't ibang ansätze ay may iba't ibang istruktura ng entanglement at iba't ibang rotation Gate. Ang ipinapakita rito ay gumagamit ng mga CNOT Gate para sa entanglement, at parehong mga Y Gate at mga parameterized na RZ Gate para sa mga rotasyon. Pansinin ang laki ng parameter space na ito; ibig sabihin nito ay kailangan nating i-minimize ang cost function sa 4 na variable (ang mga parameter para sa mga RZ Gate). Maaari itong palakihin, ngunit hindi walang hangganan. Ang pagpapatakbo ng katulad na problema sa 4 na Qubit, gamit ang default na 3 reps para sa efficient_su2, ay nagbibigay ng 16 na variational parameter.

3.2 Hakbang 2: I-optimize para sa target na hardware

Ang ansatz ay isinulat gamit ang mga pamilyar na Gate, ngunit ang ating Circuit ay kailangang i-transpile para magamit ang mga basis Gate na maipapatupad sa bawat quantum computer. Pipiliin natin ang Backend na may pinakamaliit na bilang ng trabaho.

# runtime imports
from qiskit_ibm_runtime import QiskitRuntimeService, Session
from qiskit_ibm_runtime import EstimatorV2 as Estimator

# To run on hardware, select the backend with the fewest number of jobs in the queue
service = QiskitRuntimeService()
backend = service.least_busy(operational=True, simulator=False)

print(backend)

<IBMBackend('ibm_torino')>

Maaari na nating i-transpile ang ating Circuit para sa hardware na ito at i-visualize ang ating na-transpile na ansatz.

from qiskit.transpiler.preset_passmanagers import generate_preset_pass_manager

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

ansatz_isa = pm.run(ansatz)

ansatz_isa.draw(output="mpl", idle_wires=False, style="iqp")

Output of the previous code cell

Pansinin na nagbago ang mga Gate na ginamit, at ang mga Qubit sa ating abstract na Circuit ay na-map na sa iba't ibang numeradong Qubit sa quantum computer. Kailangan nating i-map ang ating Hamiltonian nang pareho upang ang ating mga resulta ay may kahulugan.

hamiltonian_isa = hamiltonian.apply_layout(layout=ansatz_isa.layout)

3.3 Hakbang 3: Isagawa sa target na hardware

3.3.1 Pag-ulat ng mga halaga

Nagtatakda tayo ng cost function dito na tumatanggap bilang mga argumento ang mga istrukturang itinayo natin sa mga nakaraang hakbang: ang mga parameter, ang ansatz, at ang Hamiltonian. Gumagamit din ito ng estimator na hindi pa natin tinukoy. Nagsasama tayo ng code para subaybayan ang kasaysayan ng ating cost function, para masuri natin ang gawi ng convergence.

def cost_func(params, ansatz, hamiltonian, estimator):
    """Return estimate of energy from estimator

    Parameters:
        params (ndarray): Array of ansatz parameters
        ansatz (QuantumCircuit): Parameterized ansatz circuit
        hamiltonian (SparsePauliOp): Operator representation of Hamiltonian
        estimator (EstimatorV2): Estimator primitive instance
        cost_history_dict: Dictionary for storing intermediate results

    Returns:
        float: Energy estimate
    """
    pub = (ansatz, [hamiltonian], [params])
    result = estimator.run(pubs=[pub]).result()
    energy = result[0].data.evs[0]

    cost_history_dict["iters"] += 1
    cost_history_dict["prev_vector"] = params
    cost_history_dict["cost_history"].append(energy)
    print(f"Iters. done: {cost_history_dict['iters']} [Current cost: {energy}]")

    return energy

cost_history_dict = {
    "prev_vector": None,
    "iters": 0,
    "cost_history": [],
}

Napaka-kapaki-pakinabang kung maaari kang pumili ng mga paunang halaga ng parameter batay sa kaalaman ng problema at mga katangian ng target na estado. Hindi tayo gagawa ng anumang pagpapalagay tungkol sa ganitong kaalaman at gagamit tayo ng mga random na paunang halaga.

x0 = 2 * np.pi * np.random.random(num_params)

# This required 13 min, 20 s QPU time on an Eagle processor, 28 min total time.
with Session(backend=backend) as session:
    estimator = Estimator(mode=session)
    estimator.options.default_shots = 10000

    res = minimize(
        cost_func,
        x0,
        args=(ansatz_isa, hamiltonian_isa, estimator),
        method="cobyla",
        options={"maxiter": 50},
    )

Iters. done: 1 [Current cost: 0.010575798722044727]
Iters. done: 2 [Current cost: 0.004040015974440895]
Iters. done: 3 [Current cost: 0.0020213258785942503]
Iters. done: 4 [Current cost: 0.18723082446726014]
Iters. done: 5 [Current cost: -0.2746792152068885]
Iters. done: 6 [Current cost: -0.3094547651648519]
Iters. done: 7 [Current cost: -0.05281985428356641]
Iters. done: 8 [Current cost: 0.00808560303514377]
Iters. done: 9 [Current cost: -0.0014821685303514388]
Iters. done: 10 [Current cost: -0.004759824281150161]
Iters. done: 11 [Current cost: 0.09942328705995292]
Iters. done: 12 [Current cost: 0.01092366214057508]
Iters. done: 13 [Current cost: 0.05017497496069776]
Iters. done: 14 [Current cost: 0.13028868414310696]
Iters. done: 15 [Current cost: 0.013747803514376994]
Iters. done: 16 [Current cost: 0.2583072432944498]
Iters. done: 17 [Current cost: -0.14422125655131562]
Iters. done: 18 [Current cost: -0.0004950150347678081]
Iters. done: 19 [Current cost: 0.00681082268370607]
Iters. done: 20 [Current cost: -0.0023377795527156544]
Iters. done: 21 [Current cost: 0.6027665591169237]
Iters. done: 22 [Current cost: 0.00596641373801917]
Iters. done: 23 [Current cost: -0.008318769968051117]
Iters. done: 24 [Current cost: -0.00026683306709265246]
Iters. done: 25 [Current cost: -0.007648222843450479]
Iters. done: 26 [Current cost: 0.004121086261980831]
Iters. done: 27 [Current cost: -0.004075019968051117]
Iters. done: 28 [Current cost: -0.004419369009584665]
Iters. done: 29 [Current cost: 0.213185460054037]
Iters. done: 30 [Current cost: -0.06505919572162797]
Iters. done: 31 [Current cost: -0.5334241316590271]
Iters. done: 32 [Current cost: 0.00218370607028754]
Iters. done: 33 [Current cost: 0.09579352143666908]
Iters. done: 34 [Current cost: -0.009274800319488819]
Iters. done: 35 [Current cost: -0.44395141360688106]
Iters. done: 36 [Current cost: 0.011747104632587858]
Iters. done: 37 [Current cost: -0.003344149361022364]
Iters. done: 38 [Current cost: 0.19138183916486304]
Iters. done: 39 [Current cost: 0.013513931813145209]

Maaari nating tingnan ang mga hilaw na output.

res

message: Return from COBYLA because the trust region radius reaches its lower bound.
 success: True
  status: 0
     fun: -0.5334241316590271
       x: [ 1.024e+00  6.459e+00  3.625e+00  4.007e+00]
    nfev: 39
   maxcv: 0.0

3.4 Hakbang 4: I-post-process ang mga resulta

Kung maayos na natatapos ang proseso, dapat ay katumbas ang mga halaga sa ating dictionary ng solution vector at kabuuang bilang ng function evaluations, ayon sa pagkakasunod. Madaling i-verify ito:

cost_history_dict

{'prev_vector': array([1.02397956, 6.45886604, 3.62479262, 4.00744128]),
 'iters': 39,
 'cost_history': [np.float64(0.010575798722044727),
  np.float64(0.004040015974440895),
  np.float64(0.0020213258785942503),
  np.float64(0.18723082446726014),
  np.float64(-0.2746792152068885),
  np.float64(-0.3094547651648519),
  np.float64(-0.05281985428356641),
  np.float64(0.00808560303514377),
  np.float64(-0.0014821685303514388),
  np.float64(-0.004759824281150161),
  np.float64(0.09942328705995292),
  np.float64(0.01092366214057508),
  np.float64(0.05017497496069776),
  np.float64(0.13028868414310696),
  np.float64(0.013747803514376994),
  np.float64(0.2583072432944498),
  np.float64(-0.14422125655131562),
  np.float64(-0.0004950150347678081),
  np.float64(0.00681082268370607),
  np.float64(-0.0023377795527156544),
  np.float64(0.6027665591169237),
  np.float64(0.00596641373801917),
  np.float64(-0.008318769968051117),
  np.float64(-0.00026683306709265246),
  np.float64(-0.007648222843450479),
  np.float64(0.004121086261980831),
  np.float64(-0.004075019968051117),
  np.float64(-0.004419369009584665),
  np.float64(0.213185460054037),
  np.float64(-0.06505919572162797),
  np.float64(-0.5334241316590271),
  np.float64(0.00218370607028754),
  np.float64(0.09579352143666908),
  np.float64(-0.009274800319488819),
  np.float64(-0.44395141360688106),
  np.float64(0.011747104632587858),
  np.float64(-0.003344149361022364),
  np.float64(0.19138183916486304),
  np.float64(0.013513931813145209)]}

fig, ax = plt.subplots()
x = np.linspace(0, 10, 50)

# Define the constant function
constant = -0.7029
y_constant = np.full_like(x, constant)
ax.plot(
    range(cost_history_dict["iters"]), cost_history_dict["cost_history"], label="VQE"
)
ax.set_xlabel("Iterations")
ax.set_ylabel("Cost")
ax.plot(y_constant, label="Target")
plt.legend()
plt.draw()

Output of the previous code cell

Ang IBM Quantum ay may iba pang mga materyales para sa pagpapaunlad ng kasanayan na may kaugnayan sa VQE. Kung handa ka nang ilagay sa praktis ang VQE, tingnan ang aming tutorial: Ground-state energy estimation of the Heisenberg chain with VQE. Kung gusto mo ng karagdagang impormasyon sa paglikha ng mga molecular Hamiltonian, tingnan ang araling ito sa aming kurso sa Quantum chemistry with VQE. Kung interesado ka sa mas malalim na pag-unawa sa kung paano gumagana ang mga variational algorithm tulad ng VQE, inirerekomenda namin ang kursong Variational Algorithm Design.

Suriin ang iyong pag-unawa

Basahin ang tanong sa ibaba, isipin ang iyong sagot, pagkatapos ay i-click ang tatsulok para makita ang solusyon.

Sa seksyong ito, kinalkula natin ang ground state energy mula sa isang Hamiltonian. Kung gusto nating ilapat ito sa, halimbawa, pagtukoy sa geometry ng isang molekula, paano natin ito paaalawakin?

Sagot:

Kakailanganin nating magpakilala ng mga variable para sa inter-atomic spacing, at ang mga anggulo sa pagitan ng mga bond. Kakailanganin nating baguhin ang mga ito. Para sa bawat pagbabago ng mga ito, gagawa tayo ng bagong Hamiltonian (dahil ang mga operator na naglalarawan ng enerhiya ay tiyak na nakasalalay sa geometry). Para sa bawat Hamiltonian na ginawa at na-map sa mga Qubit, kakailanganin nating isagawa ang optimization tulad ng ginawa sa itaas. Sa lahat ng maraming na-converge na mga optimization problem na iyon, ang geometry na nagbigay ng pinakamababang enerhiya ang siyang magiging natural na estado. Medyo mas kumplikado ito kaysa sa ipinakita sa itaas. Isinasagawa ang ganitong kalkulasyon para sa pinakasimpleng molekula, ang $\text{H}_2$ , dito.

4. Relasyon ng VQE sa iba pang mga pamamaraan

Sa seksyong ito, susuriin natin ang mga kalamangan at kahinaan ng orihinal na VQE approach at ituturo ang mga relasyon nito sa iba, mas bagong mga algorithm.

4.1 Ang mga kalakasan at kahinaan ng VQE

Ilang kalakasan ang nabanggit na. Kabilang dito ang:

Angkop sa modernong hardware: Ang ilang quantum algorithm ay nangangailangan ng mas mababang error rate, papalapit sa malakihang fault tolerance. Hindi kailangan ng VQE; maaari itong ipatupad sa kasalukuyang mga quantum computer.
Mababaw na mga Circuit: Kadalasang gumagamit ang VQE ng medyo mababaw na mga quantum Circuit. Ginagawa nitong hindi gaanong madaling maapektuhan ang VQE ng naipon na mga error sa Gate at angkop ito para sa maraming teknik ng error mitigation. Siyempre, hindi palaging mababaw ang mga Circuit; nakasalalay ito sa ansatz na ginamit.
Versatility: Maaaring ilapat ang VQE (sa prinsipyo) sa anumang problema na maaaring ipahayag bilang isang problema ng eigenvalue/eigenvector. Maraming caveat na ginagawang hindi praktikal o hindi kapaki-pakinabang ang VQE para sa ilang mga problema. Ang ilan sa mga ito ay binanggit sa ibaba.

Ilang kahinaan ng VQE at mga problema kung saan ito ay hindi praktikal ay naipakita na rin sa itaas. Kabilang dito ang:

Heuristic na kalikasan: Hindi ginagarantiyahan ng VQE ang convergence sa tamang ground state energy, dahil ang pagganap nito ay nakasalalay sa pagpili ng ansatz at mga paraan ng optimization[1-2]. Kung ang isang mahinang ansatz ang pinili na kulang ang kinakailangang entanglement para sa nais na ground state, walang classical optimizer ang makaabot sa ground state na iyon.
Posibleng napakaraming parameter: Ang isang napaka-expressive na ansatz ay maaaring may napakaraming parameter kaya ang mga iterasyon ng minimization ay napaka-nakakaubos ng oras.
Mataas na overhead sa pagsukat: Sa VQE, ginagamit ang isang estimator para tantiyahin ang expectation value ng bawat termino sa Hamiltonian. Karamihan sa mga Hamiltonian na may interes ay magkakaroon ng mga termino na hindi maaaring sabay na tantiyahin. Maaari itong gawing resource-intensive ang VQE para sa malalaking sistema na may kumplikadong mga Hamiltonian[1].
Mga epekto ng ingay: Kapag ang classical optimizer ay naghahanap ng minimum, ang mga maingay na kalkulasyon ay maaaring malito ito at ipalayo ito sa tunay na minimum o mapabagal ang convergence nito. Isang posibleng solusyon para dito ay ang paggamit ng mga pinakabagong teknik ng error mitigation at error suppression[2-3] mula sa IBM.
Mga barren plateau: Ang mga rehiyong ito ng nawawalang mga gradient[2-3] ay umiiral kahit walang ingay, ngunit ginagawa ng ingay na mas mapanganib ang mga ito dahil ang pagbabago sa mga expectation value dahil sa ingay ay maaaring mas malaki kaysa sa pagbabago mula sa pag-update ng mga parameter sa mga barren na rehiyong ito.

4.2 Relasyon sa iba pang mga approach

Adapt-VQE

Ang ADAPT-VQE (Adaptive Derivative-Assembled Pseudo-Trotter Variational Quantum Eigensolver) algorithm ay isang pagpapabuti ng orihinal na VQE algorithm, dinisenyo para mapabuti ang kahusayan, katumpakan, at scalability para sa mga quantum simulation, lalo na sa quantum chemistry.

Ang orihinal na VQE algorithm na inilarawan sa buong araling ito ay gumagamit ng isang paunang itinakda, naayos na ansatz para tantiyahin ang ground state ng sistema. Sa aming kaso, ginamit namin ang efficient_su2, na may isang ulit, gamit ang mga Y at RZ rotation Gate. Kahit nagbago ang mga parameter sa mga RZ Gate, ang istruktura ng ansatz na ito at ang mga Gate na ginamit ay hindi nagbago.

Tinutugunan ng ADAPT-VQE ang mga limitasyon ng VQE sa pamamagitan ng adaptive ansatz construction. Sa halip na magsimula sa isang naayos na ansatz, ang ADAPT-VQE ay dinamikong nagtatayo ng ansatz nang paunti-unti. Sa bawat hakbang, pinipili nito ang operator mula sa isang paunang itinakdang pool (tulad ng mga fermionic excitation operator) na may pinakamalaking gradient kaugnay ng enerhiya. Tinitiyak nito na ang mga pinaka-mahalaga lamang na operator ang idadagdag, na humahantong sa isang compact at mahusay na ansatz[4-6]. Ang approach na ito ay maaaring magkaroon ng ilang kapaki-pakinabang na epekto:

Nabawasang Lalim ng Circuit: Sa pamamagitan ng paglaki ng ansatz nang paunti-unti at pagtuon lamang sa mga kinakailangang operator, binibigyang-daan ng ADAPT-VQE na mabawasan ang mga Gate operation kumpara sa mga tradisyonal na VQE approach[5,7].
Pinahusay na Katumpakan: Ang adaptive na kalikasan ay nagpapahintulot sa ADAPT-VQE na mabawi ang mas maraming correlation energy sa bawat hakbang, na ginagawa itong partikular na epektibo para sa mga strongly correlated na sistema kung saan nahihirapan ang tradisyonal na VQE[8,9].
Scalability at Tibay sa Ingay: Ang compact na ansatz ay nagbabawas ng akumulasyon ng mga error sa Gate, nagbabawas ng computational overhead, at nililimitahan ang bilang ng mga variational parameter na kailangang i-minimize.

Hindi pa rin perpekto ang ADAPT-VQE. Sa ilang kaso ay maaari itong mabitag o mapabagal ng mga lokal na minimum, at maaaring maranasan nito ang over-parameterization. Maaari rin itong medyo resource-intensive, dahil nangangailangan ito ng kalkulasyon ng mga gradient at pag-optimize ng parameter na may maraming istruktura ng Gate.

Quantum phase estimation (QPE)

Ang QPE ay katulad sa layunin sa VQE, ngunit napakaiba sa implementasyon. Ang QPE ay nangangailangan ng mga fault-tolerant na quantum computer dahil sa pangkalahatan nitong malalim na mga quantum Circuit at mataas na antas ng coherence na kinakailangan nito. Kapag naipatupad na ang QPE, ito ay magiging mas tumpak kaysa sa VQE. Isang paraan ng paglalarawan sa pagkakaiba ay sa pamamagitan ng katumpakan bilang function ng lalim ng Circuit. Nakamit ng QPE ang katumpakan na $\epsilon$ na may mga lalim ng Circuit na sumusukat bilang $O(1/\epsilon)$ [10]. Ang VQE ay nangangailangan ng $O(1/\epsilon^2)$ na mga sample para makamit ang parehong katumpakan[10,11].

Krylov, SQD, QSCI, at iba pa sa kursong ito

Nakatulong ang VQE sa pagtatatag ng mga quantum algorithm na nakasalalay pa rin sa mga classical computer, hindi lamang para sa pagpapatakbo ng quantum computer, kundi para sa mahahalagang bahagi ng algorithm. Ang ilang gayong algorithm ang nakatuon sa natitirang bahagi ng kursong ito. Dito, nagbibigay tayo ng maikli at pangkalahatang paliwanag ng ilan, para lamang ikumpara at ikontrast ang mga ito sa VQE. Ipapaliwanag ang mga ito nang mas detalyado sa mga susunod na aralin.

Krylov quantum diagonalization (KQD)

Ang mga Krylov subspace method ay mga paraan ng pag-project ng isang matrix sa isang subspace para bawasan ang dimensyon nito at gawing mas mapamamahalaan, habang pinapanatili ang mga pinakamahalagang katangian. Isang trick sa pamamaraang ito ay ang paglikha ng isang subspace na pinapanatili ang mga katangiang ito; lumalabas na ang paglikha ng subspace na ito ay malapit na nauugnay sa isang kilalang pamamaraan sa mga quantum computer na tinatawag na Trotterization.

Mayroong ilang variant ng mga quantum Krylov method, ngunit sa pangkalahatan ang approach ay:

Gamitin ang quantum computer para makabuo ng isang subspace (ang Krylov subspace) sa pamamagitan ng Trotterization
I-project ang matrix na may interes sa Krylov subspace na iyon
I-diagonalize ang bagong projected na Hamiltonian gamit ang isang classical computer

Sampling-based quantum diagonalization (SQD)

Ang Sampling-based quantum diagonalization (SQD) ay may kaugnayan sa Krylov method dahil sinisikap din nitong bawasan ang dimensyon ng isang matrix na idi-diagonalize habang pinapanatili ang mga pangunahing katangian. Ginagawa ito ng SQD sa sumusunod na paraan:

Magsimula sa isang paunang hula para sa iyong ground state at ihanda ang sistema sa ground state na iyon.
Gamitin ang Sampler para samplahan ang mga bitstring na bumubuo sa estado na ito.
Gamitin ang koleksyon ng mga computational basis state mula sa sampler bilang subspace kung saan ipo-project ang iyong matrix na may interes.
I-diagonalize ang mas maliit, projected na matrix gamit ang isang classical computer.

Ito ay may kaugnayan sa VQE dahil ginagamit nito ang parehong classical at quantum computing para sa mahahalagang bahagi ng algorithm. Parehong nagtataglay din ng kinakailangan na maghanda ng isang mahusay na paunang hula o ansatz. Ngunit ang distribusyon ng gawain sa pagitan ng mga classical at quantum computer sa SQD ay mas katulad ng sa Krylov method.

Sa katunayan, ang Krylov method at SQD ay kamakailan nilang pinagsama sa sampling-based Krylov quantum diagonalization (SKQD) method [12].

Quantum subspace configuration interaction

Ang Quantum Selected Configuration Interaction (QSCI)[13] ay isang algorithm na gumagawa ng approximated na ground state ng isang Hamiltonian sa pamamagitan ng pagsampler ng isang trial wave function para matukoy ang mga makabuluhang computational basis state para makabuo ng isang subspace para sa classical diagonalization. Parehong gumagamit ang SQD at QSCI ng isang quantum computer para makabuo ng isang reduced subspace. Ang karagdagang kalakasan ng QSCI ay nasa state preparation nito, lalo na sa konteksto ng mga chemistry problem. Ginagamit nito ang iba't ibang estratehiya tulad ng paggamit ng mga time-evolved state [14] at isang hanay ng mga chemistry-inspired ansätze. Sa pamamagitan ng pagtuon sa mahusay na state preparation, binabawasan ng QSCI ang mga quantum computational cost para sa mga chemical Hamiltonian habang pinapanatili ang mataas na fidelity at ginagamit ang tibay sa ingay mula sa mga teknik ng quantum state sampling [15]. Nagbibigay din ang QSCI ng isang adaptive construction technique na nagbibigay ng mas maraming ansätze para sa mas magandang resulta.

Ang default na workflow ng QSCI para sa chemistry problem ay ang sumusunod:

Itayo ang molecular Hamiltonian gamit ang iyong piniling software (tulad ng SciPy).
Maghanda ng QSCI algorithm sa pamamagitan ng pagpili ng isang angkop na paunang estado at isang chemistry-inspired ansatz na may paunang napiling hanay ng mga parameter.
Samplahan ang mga makabuluhang basis state at i-diagonalize ang Hamiltonian gamit ang isang classical computer para makuha ang ground state energy.
Kadalasang ginagamit ang configuration recovery [16] at symmetry post-selection [15] bilang teknik sa post-processing.
Opsyonal, ang workflow ng adaptive QSCI ay may karagdagang optimization loop mula sa hakbang 2 hanggang hakbang 3, sa pamamagitan ng paggamit ng mas maraming ansätze na may random na mga paunang estado.

Suriin ang iyong pag-unawa

Basahin ang mga tanong sa ibaba, isipin ang iyong mga sagot, pagkatapos ay i-click ang mga tatsulok para makita ang mga solusyon.

Ano ang pagkakatulad ng VQE sa lahat ng iba pang mga pamamaraan na nakalista sa itaas (maliban sa QPE na hindi inilalarawan nang detalyado)?

Sagot:

Lahat ay may trial state o wave function sa isang anyo. Lahat ay pinakamabuti kapag ang paunang hula para sa trial state na ito ay napakahusay.

Isa pang tamang sagot ay ang lahat ay pinakamadaling ipatupad kapag ang Hamiltonian ay madaling sukatin (maaaring pagbukud-bukurin sa medyo ilang grupo ng mga commuting Pauli operator).

Ano ang pagkakatulad ng VQE sa wala sa iba pang mga pamamaraan na nakalista sa itaas?

Sagot:

Mga classical optimizer. Wala sa iba ang gumagamit ng mga classical optimization algorithm para pumili ng mga variational parameter.