Ang ugnayan ng package na ito sa ffsim

Mahalaga

Ang mga konsepto sa gabay na ito ay available lang sa Python API.

Naghahati ang ffsim at ang package na ito ng trabaho imbes na magpatong, sa isang linya:

Pag-aari ng ffsim	Pag-aari ng qiskit-fermions
Ang mga high-level na ansatz operator (UCJOpSpinBalanced, UCCSDOpRestrictedReal at ang mga kamag-anak nila), na binuo mula sa coupled-cluster amplitude o parameter vector	Ang fermionic circuit (FermionicCircuit) na kinahihinatnan ng mga operator na iyon, at ang transpilation nito tungo sa qubit circuit sa ilalim ng anumang fermion-to-qubit encoding
Mabilis na simulation sa isang compact na fixed-particle-number na espasyo	Ang mapper framework at ang mga operator data structure na pinagbubuuan ng circuit

Dalawang direksyon ang praktikal na kahihinatnan. Nasa ffsim ang ansatz math, kaya ang UCJ at UCC ay direktang tumatanggap ng ffsim operator bilang input nila. Sa kabilang banda, partikular sa Jordan-Wigner transformation ang sariling mga Qiskit gate ng ffsim, kaya ang makukuha mo sa pagdadala nito rito ay ang pag-lower ng isa sa mga ansatz operator nito sa pamamagitan ng ibang encoding.

Dito nagtatagpo ang dalawa sa simulation, at ipinapaliwanag ito ng gabay na ito. Ang ffsim ang simulation backend ng package na ito, na naaabot sa pamamagitan ng sarili nitong mga protocol imbes na wrapper: tinatawag ng SKQD guide ang ffsim.apply_unitary(), ffsim.linear_operator(), at ffsim.sample_state_vector() nang direkta sa mga FermionicCircuitobject at FermionOperatorobject, na walang hakbang ng conversion.

Pagsaksak sa simulation interface ng ffsim

Ang ffsim ay isang high-performance na simulator para sa mga fermionic quantum circuit na sinasamantala ang particle number at spin-Z conservation para katawanin ang mga state vector nang mas compact kaysa sa generic na $2^n$-dimensional na qubit statevector. Nagtatakda ito ng mga protocol na maaaring ipatupad ng anumang object para makilahok sa simulation machinery nito (tingnan ang qiskit_fermions.protocols para sa sariling mga protocol ng package na ito, na sumusunod sa parehong disenyo):

• ffsim.SupportsApplyUnitary, sa pamamagitan ng method na _apply_unitary_(vec, norb, nelec, copy), na naglalapat sa object bilang unitary sa isang fixed-particle-number na state vector

• ffsim.SupportsLinearOperator, sa pamamagitan ng method na _linear_operator_(norb, nelec), na nagbabalik ng scipy.sparse.linalg.LinearOperator na view ng object sa parehong sector na iyon

• ffsim.SupportsTrace, sa pamamagitan ng method na _trace_(norb, nelec), na nagbabalik ng trace ng object sa sector na iyon.

Ipinapatupad ng package na ito ang interface na iyon: bawat fermionic gate sa qiskit_fermions.circuit.library ay nagbibigay ng _apply_unitary_, at ang FermionOperator ay nagbibigay ng _linear_operator_ at _trace_. Iyon ang dahilan kaya compatible sa ffsim ang mga operator at circuit ng package na ito, kaya natural na gumagana ang mga tool nito sa kanila, nang walang hakbang ng conversion. Kayang i-simulate ng ffsim.apply_unitary() ang isang FermionicCircuit mula simula hanggang dulo, kayang i-diagonalize ng ffsim.linear_operator() ang isang FermionOperator, at gumagana nang walang pagbabago ang mga sampling utility tulad ng ffsim.sample_state_vector() (ginamit sa SKQD guide para gawing measurement count ang isang na-simulate na statevector).

Ang ibinabalik ng _linear_operator_ ay isang ordinaryong SciPy LinearOperator, kaya gumagana rin dito ang scipy.sparse.linalg.eigsh() at mga kauri nito.

>>> import ffsim
>>> import numpy as np
>>>
>>> from qiskit_fermions.circuit import FermionicCircuit
>>> from qiskit_fermions.circuit.library import Evolution
>>> from qiskit_fermions.operators import FermionOperator, ann, cre
>>>
>>> norb, nelec = 2, (1, 1)
>>> hamiltonian = FermionOperator.from_terms([
...     ([cre(0), ann(1)], 0.5),
...     ([cre(1), ann(0)], 0.5),
... ])
>>>
>>> circuit = FermionicCircuit(2 * norb)
>>> circuit.append(Evolution(2 * norb, hamiltonian, time=1.0), circuit.modes)
>>>
>>> reference = ffsim.hartree_fock_state(norb, nelec)
>>> state = ffsim.apply_unitary(reference, circuit, norb=norb, nelec=nelec)  # native ffsim call

Ang pagkakabit sa pamamagitan ng mga protocol ng ffsim ang nagbibigay nito: ang aktibong nade-develop nitong ecosystem ng mga simulation at sampling utility ay nalalapat nang walang pagbabago sa mga circuit at operator ng package na ito, at maaaring ihalo ng mga user na gumagamit na ng ffsim ang mga gate at operator ng package na ito nang hindi na kailangang matuto ng isa pang simulation API.

Opsyonal na dependency ang ffsim

Idinedeklara ang ffsim bilang opsyonal na extra (pip install "qiskit-fermions[ffsim]", o transitively ng [all]), na binabantayan sa runtime ng HAS_FFSIM (gaya ng ipinakita sa itaas). Ang pag-install nito ang nagbubukas ng simulation: ang ffsim.SupportsLinearOperator at ffsim.SupportsTrace ay ipinapatupad sa pamamagitan ng pag-convert ng FermionOperator ng package na ito sa isang ffsim.FermionOperator, kaya kapag walang ffsim ay nagtataas sila ng MissingOptionalLibraryError. Lahat ng hindi nagsi-simulate (pagbuo ng mga operator, pag-map sa mga ito, at pag-transpile ng mga nagresultang circuit) ay hindi nangangailangan nito.

Nasa fixed particle-number sector ang fermionic simulation

Parehong kumukuha ng argumentong nelec ang _apply_unitary_ at _linear_operator_ at kinakatawan ang state vector sa fixed-particle-number determinant basis para sa sector na (norb, nelec), na ginagaya ang FCI space setup ng ffsim (at, sa pamamagitan nito, ng PySCF), imbes na ang buong $2^{\text{num\_modes}}$-dimensional na espasyong gagamitin ng isang general na qubit simulator. Mas maliit na espasyo ito nang malaki (ang laki nito ay produkto ng mga binomial coefficient imbes na power ng dalawa), ngunit may kasama itong mahigpit na restriksyon. Mga operator at gate lang na nagpapanatili ng particle number (at, sa spinful na kaso, ng particle number ng bawat spin species nang hiwalay) ang maaaring katawanin dito. Ang operator na ang aksyon ay maglilipat ng amplitude sa ibang particle number ay walang mapaglalagyan nito.

Nilulutas ito ng ffsim sa pamamagitan ng tuwirang pagtanggi sa ganoong operator: ang pag-convert ng isa sa linear operator ay nagtataas ng ValueError na pinangangalanan kung aling conservation law ang pumapalya. Tamang default iyon, dahil ang paglalapat ng $\exp(-i t H)$ para sa isang Hamiltonian na $H$ na may term na hindi nagpapanatili ng particle ay gagawing non-unitary at walang pisikal na kahulugang mapa ang dapat sana ay unitary.

• Inilalantad ng Evolution ang pagtanggi na iyon mula sa operator na ine-evolve nito.

• Sinusuri ng OrbitalRotation na ang (naka-embed na) rotation matrix nito ay block-diagonal sa alpha/beta split sa spinful na kaso, at nagtataas ito ng ValueError kung hinahalo nito ang mga spin sector.

>>> from qiskit_fermions.circuit.library import Evolution
>>>
>>> non_conserving = FermionOperator.from_terms([([cre(0), cre(1)], 1.0)])  # creates 2 particles
>>> gate = Evolution(2 * norb, non_conserving, time=1.0)
>>>
>>> try:
...     gate._apply_unitary_(reference, norb, nelec, copy=True)
... except ValueError as exc:
...     print("rejected:", exc)
rejected: The given FermionOperator could not be converted to a LinearOperator because it does not conserve particle number and the z component of spin. Conserves particle number: False Conserves spin z: False

Kaya hindi posible sa fermionic space ang simulation na hindi nagpepreserba ng particle, dahil sa disenyo ng fixed-sector na representasyon, at iyon ang kapalit ng compact na FCI space na siyang nagpapadali sa fermionic simulation sa unang lugar. Kung kailangan ng algorithm mo ang mga operator na lumalabag sa particle-number (halimbawa, isang qubit-native na error channel, o isang operator na binuo para sa mapped Hamiltonian na hindi nagpepreserba ng bilang ng particle sa bawat term), mag-transpile muna sa mga qubit at i-simulate ang nagresultang QuantumCircuit gamit ang qubit-level na simulator. Gagana ang anumang ruta ng transpilation para dito; mas detalyado ang fermionic circuit at transpilation na mga gabay, pero ang generate_preset_jw_pass_manager() ay isang makatwirang default na pagpipilian.

Ang block-spin convention para sa mga spinful na sistema

Ang nelec ay may type na int | tuple[int, int], at ang type nito, hindi ang hiwalay na flag, ang pumipili ng isa sa mga sinusuportahang mode layout:

• Ang int ay pumipili ng spinless na interpretasyon. Ang norb na mga mode ay direktang tinatrato bilang spinless na mga orbital, at ang nelec ay ang kabuuang bilang ng particle.

• Ang pair na (n_alpha, n_beta) ay pumipili ng spinful na interpretasyon ng 2 * norb na mga mode sa ilalim ng nakapirming block-spin convention. Ang mga mode na 0 .. norb ay ang mga alpha (spin-up) na orbital at ang mga mode na norb .. 2 * norb ay ang mga beta (spin-down) na orbital. Ang bawat spin species ay napepreserba nang hiwalay; ang alpha-only na term ay maaaring maglipat ng electron sa pagitan ng mga alpha mode pero hindi kailanman papunta sa beta mode, at vice versa.

Nangyayari ang dispatch na ito sa bawat ffsim-protocol entry point sa package na ito (mga gate constructor, mga implementasyon ng _apply_unitary_placed_, at ang sector compilation ng native Rust kernel), at ito ang convention na ginagamit sa buong LUCJ at SKQD na mga gabay (halimbawa, nilalagay ng InitializeModes.from_hartree_fock() ang mga alpha occupation sa mga mode na 0 .. n_alpha at ang mga beta occupation sa mga mode na norb .. norb + n_beta). Makabubuting ihambing ito sa module na qiskit_fermions.operators at sa FermionicCircuit sa pangkalahatan, na gumagamit ng generic na mga mode index na walang likas na kahulugang spin (tingnan ang gabay sa fermionic circuit). Ang kahulugang block-spin ay ipinapataw lamang kapag may ibinigay na spinful na nelec sa isang simulation call, at hindi nakabaon sa mismong representasyon ng operator o circuit.

>>> from qiskit_fermions.circuit.library import InitializeModes
>>>
>>> norb, nelec = 3, (2, 1)
>>> init = InitializeModes.from_hartree_fock(norb, nelec)
>>> print([bool(occ) for occ in init.occupation])  # alpha modes 0,1; beta mode 3 (= norb + 0)
[True, True, False, True, False, False]

Mga susunod na hakbang

• Pag-aralan ang gabay na SKQD para makita kung paano ginagamit nang magkasama ang ffsim.apply_unitary() at ffsim.sample_state_vector() para mag-sample ng mga circuit na binuo mula sa mga gate ng package na ito, at para i-evaluate ang expectation value ng Hamiltonian sa pamamagitan ng ffsim.linear_operator() (na sinusuportahan din ng parehong _linear_operator_ protocol method na inilarawan dito).

• Pag-aralan ang gabay na LUCJ para sa kabilang kalahati ng kuwento: ang pagdaan ng ffsim ansatz operator sa transpilation pipeline ng package na ito hanggang sa coupling map ng device.

• Basahin ang gabay sa fermionic circuit para sa generic, spin-agnostic na mode indexing na ginagamit sa labas ng mga simulation call.

• Basahin ang gabay sa transpilation kung paano lumabas sa fermionic space

  at mag-simulate sa mga qubit, na kinakailangan para sa mga operator na hindi nagpepreserba ng particle.

• I-browse ang qiskit_fermions.protocols para sa buong katalogo ng mga protocol na dine-define ng package na ito, kasama ang mga conversion protocol (SupportsFermionOperator, SupportsMajoranaOperator) na walang kaugnayan sa ffsim.

• Basahin ang sariling mga gabay ng ffsim para sa mga workflow na pagmamay-ari nito, lalo na ang pagbuo ng UCJ ansatz at pag-optimize nito nang variational. Ang mga parameter vector na minamaneho ng mga gabay na iyon ang tinatanggap ng UCJ at UCC, sa pamamagitan ng mga operator na binubuo nila.