Approximate na quantum compilation gamit ang tensor networks (AQC-Tensor)

Ang Approximate quantum compilation with tensor networks (AQC-Tensor) Qiskit addon ay nagbibigay-kakayahan sa mga user na i-compile ang paunang bahagi ng isang circuit sa isang halos katumbas na approximation ng circuit na iyon, ngunit may mas kaunting layers. Nagagawa ito gamit ang tensor networks ayon sa pamamaraang inilarawan sa [1]. Ang pangunahing gamit nito ay sa mga circuit na nag-simulate ng time evolution, ngunit maaaring ilapat sa anumang klase ng circuit na may access sa:

1. Isang mahusay na intermediate state, na kilala bilang "target state," na maaaring makamit sa pamamagitan ng tensor-network simulation; at,
2. Isang magandang circuit na naghahanda ng approximation sa target state, ngunit may mas kaunting layers kapag na-compile sa target hardware device.

Ang teknik ay gumagawa ng ansatz circuit batay sa isang mas malaking target circuit na nais isagawa ng user sa isang QPU. Nagagawa ito sa pamamagitan ng unang pag-simulate ng ilang bahagi ng target circuit gamit ang tensor network methods at pagkuha ng tumpak na paglalarawan ng isang intermediate state na approximahin ng ansatz circuit. Kapag nahanap na ang intermediate state na ito, ginagamit ito bilang cost function para ma-optimize ang mga parameter ng ansatz circuit. Pagkatapos ng optimization, ang natitirang bahagi ng target circuit ay idinaragdag sa ansatz at pagkatapos ay isinasagawa sa quantum hardware.

I-install ang AQC-Tensor package

May dalawang paraan para i-install ang AQC-Tensor package: PyPI at pag-build mula sa source. Inirerekomenda na i-install ang mga package na ito sa isang virtual environment upang matiyak ang paghihiwalay ng mga dependencies ng package.

I-install mula sa PyPI

Ang pinakamadaling paraan para i-install ang AQC-Tensor package ay sa pamamagitan ng PyPI. Para magamit ang package, kailangan mo ring mag-install ng hindi bababa sa isang tensor network backend. Ang sumusunod na code snippet ay mag-i-install ng addon, kasama ang quimb (para sa tensor network support) at jax (para sa automatic differentiation). Kung interesado ka, tingnan ang package sa GitHub

pip install 'qiskit-addon-aqc-tensor[quimb-jax]'

I-install mula sa source

I-click dito para malaman kung paano i-install ang package na ito nang mano-mano.

Kung nais mong mag-ambag sa package na ito o gusto mong i-install ito nang mano-mano, i-clone muna ang repository:

git clone git clone git@github.com:Qiskit/qiskit-addon-aqc-tensor.git

at i-install ang package sa pamamagitan ng pip. Kung plano mong patakbuhin ang mga tutorial na makikita sa package repository, i-install din ang mga notebook dependencies. Kung plano mong mag-develop sa repository, maaari mo ring i-install ang mga dev dependencies.

pip install tox jupyterlab -e '.[notebook-dependencies,dev]'

Teoretikal na Background

Ang proseso ng AQC-Tensor ay inipaliwanag nang detalyado sa [1]. Ang seksyong ito ay nagbibigay ng pangkalahatang-ideya ng teknik.

Sa pangkalahatan, tatlong bagay ang kailangan ng AQC-Tensor bilang input:

1. Isang paglalarawan ng target state sa anyo ng isang tensor network. Maaari itong mabuo sa pamamagitan ng pag-simulate ng isang circuit sa isang tensor network simulator, o maaari itong mabuo sa ibang paraan (halimbawa, sa pamamagitan ng pagsasagawa ng time evolution sa isang matrix-product state gamit ang time-dependent variational principle).
2. Isang parametrized ansatz circuit. Ang pinakaideal ay ang isa na naglalaman ng hardware-efficient na connectivity, upang magkaroon ito ng makatwirang depth sa target hardware.
3. Mga paunang parameter na ilalagay sa ansatz circuit, upang ang resultang state ay isang magandang approximation na ng target state. (Hindi ito kinakailangan sa prinsipyo para sa AQC, ngunit nakakatulong ito upang maibigay sa optimizer ang isang makatwirang panimulang punto.)

Ang teknik ay ang paulit-ulit na pag-optimize ng mga parameter ng ansatz circuit, upang ang state na nalilikha nito ay maging kalapit-kalapit sa target state hangga't maaari.

Pagbuo ng Ansatz

Para mabuo ang (2) at (3) mula sa listahan sa itaas, ang qiskit-addon-aqc package ay mayroon ng isang function, generated_ansatz_from_circuit() na kukuha ng isang input circuit at maglalabas ng parametrized ansatz at paunang hanay ng mga parameter. Ang mga parameter na ibinalik ng function ay nagbibigay, kapag inilagay sa ansatz, ng state na eksakto katumbas ng input circuit, hanggang sa isang global phase.

Ang ansatz na ginawa ng function na ito ay gumagamit ng 9 na parameter bawat two-qubit block at batay sa KAK decomposition, na nagpaparameterize ng anumang two-qubit gate sa tatlong parameter, hanggang sa single-qubit rotations. Ang mga single-qubit rotation ay pagkatapos ay na-decompose bilang $ZXZ$, bawat isa ay may tatlong parameter. Nagreresulta ito sa ansatz circuit na naglalaman ng 3 parameter para sa bawat two-qubit block ng orihinal na circuit, kasama ang 3 parameter para sa papalabas na single-qubit rotation sa bawat isa sa dalawang qubit (para sa kabuuang 9 na parameter). Pagkatapos idagdag ang mga block na ito, nakumpleto ang ansatz sa pamamagitan ng pagdaragdag ng isang layer ng single-qubit rotations sa bawat aktibong qubit sa simula ng circuit.

Tensor-network simulation

Para makakuha ng paglalarawan ng nais na target state, gumagamit ang addon na ito ng matrix product state (ang pinakasimpleng anyo ng tensor network) at sinusuportahan ang mga sumusunod na tensor-network simulator:

• MPS simulator na makikita sa Qiskit Aer
• Quimb's eager CircuitMPS simulator
• Quimb's lazy Circuit simulator

Ang pinakamahalagang parameter ng isang tensor network ay ang maximum bond dimension nito, $\chi$. Nililimitahan ng parameter na ito kung gaano karaming entanglement ang maaaring katawanin ng isang tensor network, at samakatuwid hanggang saan ang depth ng isang ibinigay na circuit na maaaring tumpak na ma-simulate.

Kung ang isang circuit ay may $L$ qubit, ang isang matrix-product state ay nangangailangan ng maximum bond dimension na $\chi_{exact} = 2^{L/2}$ upang eksakto na ma-simulate ang circuit hanggang sa anumang depth. Ito ay hindi maabot para sa mga pangkalahatang utility-scale circuit na kumikilos sa 100+ qubit. Para sa kadahilanang ito, kung sumusubok kang mag-eksperimento gamit ang addon na ito para sa isang simpleng problema na may kakaunting qubit, mahalagang tiyaking $\chi < 2^{L/2}$. Sa ganitong paraan, kapag pinalaki mo ang problema sa isang mas malaking circuit, ang target state ay nananatiling classically simulable.

Mga susunod na hakbang

Mga Rekomendasyon

• Basahin ang pahina tungkol sa pagsisimula sa AQC-Tensor
• Basahin ang tutorial sa paggamit ng AQC para mapabuti ang Trotterized time evolution.

Mga Sanggunian

[1] Robertson, Niall F., et al. "Approximate Quantum Compiling for Quantum Simulation: A Tensor Network based approach" arXiv preprint arXiv:2301.08609 (2023).