MPF dinamici

setup_dynamic_lse(trotter_steps, time, identity_factory, exact_evolver_factory, approx_evolver_factory, initial_state)

Restituisce il sistema di equazioni lineari per il calcolo dei coefficienti MPF dinamici.

Questa funzione utilizza l'algoritmo DynamicMPF per calcolare le componenti della matrice di Gram (LSE.A, $M$ in [1] e [2] ) e del vettore di sovrapposizione (LSE.b, $L$ in [1] e [2] ) per i parametri di evoluzione temporale forniti.

Gli elementi della matrice di Gram, $M_{ij}$, e del vettore di sovrapposizione, $L_i$, sono definiti come

dove $\rho(t)$ è lo stato di evoluzione temporale esatto al tempo $t$ e $\rho_{k_i}(t)$ è lo stato di evoluzione temporale approssimato utilizzando $k_i$ passi di Trotter.

Calcolare i coefficienti MPF dinamici (cioè dipendenti dal tempo) da $M$ e $L$ equivale a trovare una soluzione alla formula LSE (analogamente a come vengono calcolati i coefficienti static MPF), rispettando il vincolo che tutti i coefficienti devono avere somma 1 ( $\sum_i x_i = 1$ ), che non viene applicato in questo LSE (a differenza del caso statico). I problemi di ottimizzazione che includono questo vincolo aggiuntivo sono documentati nel modulo costs modulo. Quello suggerito da [1] e [2] è il setup_frobenius_problem().

La valutazione di ogni elemento $M_{ij}$ e $L_i$ richiede il calcolo della sovrapposizione tra due stati di evoluzione temporale. L'algoritmo DynamicMPF lo fa per mezzo di calcoli di reti tensoriali, forniti da una delle dipendenze opzionali. I backend disponibili sono elencati e spiegati in dettaglio nel modulo backends modulo.

Di seguito, viene fornito un esempio che utilizza il quimb_tebd backend. Spieghiamo brevemente ogni elemento.

Per prima cosa, inizializziamo una semplice Hamiltoniana di Heisenberg che vogliamo far evolvere nel tempo. Poiché utilizziamo un time-evolver basato su quimb, inizializziamo anche l'hamiltoniana utilizzando quella libreria.

>>> from quimb.tensor import ham_1d_heis
>>> num_qubits = 10
>>> hamil = ham_1d_heis(num_qubits, 0.8, 0.3, cyclic=False)

Quindi, definiamo il numero di passi di Trotter che compongono il nostro MPF, il tempo di evoluzione target e lo stato iniziale ( $\psi_{in}$ in [1] e $\psi_0$ in [2], rispettivamente) rispetto al quale si calcola la sovrapposizione tra gli stati dell'evoluzione temporale. In questo caso, utilizziamo semplicemente lo stato di Néel, che costruiamo anche utilizzando quimb:

>>> trotter_steps = [3, 4]
>>> time = 0.9

>>> from quimb.tensor import MPS_neel_state
>>> initial_state = MPS_neel_state(num_qubits)

Poiché dobbiamo eseguire l'intero DynamicMPF per calcolare ogni elemento di $M_{ij}$ e $L_i$, dobbiamo fornire metodi di fabbrica per inizializzare gli argomenti di ingresso delle istanze DynamicMPF istanze. A tal fine, dobbiamo fornire tre funzioni. Per costruirli, utilizzeremo la funzione functools.partial() funzione.

>>> from functools import partial

Per prima cosa, abbiamo bisogno di una funzione per inizializzare uno stato di evoluzione temporale vuoto (vedere anche DynamicMPF.evolution_state per maggiori dettagli). Questa funzione costruttore non può accettare argomenti posizionali o parole chiave e deve restituire un oggetto State oggetto.

>>> from qiskit_addon_mpf.backends.quimb_tebd import MPOState
>>> from quimb.tensor import MPO_identity
>>> identity_factory = lambda: MPOState(MPO_identity(num_qubits))

La seconda e la terza funzione devono costruire i motori di evoluzione temporale di sinistra e di destra (vedi anche DynamicMPF.lhs e DynamicMPF.rhs per maggiori dettagli). Queste funzioni devono seguire i parametri ExactEvolverFactory e ApproxEvolverFactory rispettivamente.

La funzione ExactEvolverFactory deve prendere un oggetto State come unico argomento posizionale e deve restituire un oggetto Evolver che sarà usato per calcolare l'LHS degli elementi di $L_i$ (cioè dovrebbe produrre lo stato esatto dell'evoluzione temporale, $\rho(t)$ ).

Qui approssimiamo lo stato esatto evoluto nel tempo con una formula di Suzuki-Trotter del quarto ordine, utilizzando un piccolo passo temporale di 0.05. Specifichiamo inoltre alcune quimb-opzioni di troncamento specifiche per limitare la dimensione massima dei legami della rete tensoriale sottostante e i valori singolari minimi dei legami della rete tensoriale divisa.

>>> from qiskit_addon_mpf.backends.quimb_tebd import TEBDEvolver
>>> exact_evolver_factory = partial(
...     TEBDEvolver,
...     H=hamil,
...     dt=0.05,
...     order=4,
...     split_opts={"max_bond": 10, "cutoff": 1e-5},
... )

La funzione ApproxEvolverFactory deve accettare anche un oggetto State come unico argomento posizionale e in aggiunta un argomento chiave chiamato dt per specificare il passo temporale dell'evoluzione del tempo. Dovrebbe inoltre restituire un Evolver che produce gli stati approssimati dell'evoluzione temporale, $\rho_{k_i}(t)$, dove $k_i$ è determinato dal passo temporale scelto, dt. Di conseguenza, queste istanze saranno utilizzate per calcolare l'RHS di $L_i$ ed entrambi i lati degli elementi di $M_{ij}$.

In questo caso, utilizziamo una formula di Suzuki-Trotter del secondo ordine con le stesse impostazioni di troncamento di prima.

>>> approx_evolver_factory = partial(
...     TEBDEvolver,
...     H=hamil,
...     order=2,
...     split_opts={"max_bond": 10, "cutoff": 1e-5},
... )

Infine, possiamo inizializzare ed eseguire la funzione setup_dynamic_lse() per ottenere il risultato LSE descritto in alto.

>>> from qiskit_addon_mpf.dynamic import setup_dynamic_lse
>>> lse = setup_dynamic_lse(
...     trotter_steps,
...     time,
...     identity_factory,
...     exact_evolver_factory,
...     approx_evolver_factory,
...     initial_state,
... )
>>> print(lse.A)  
[[1.         0.99998513]
 [0.99998513 1.        ]]
>>> print(lse.b)  
[1.00001585 0.99998955]

Parametri

• trotter_steps (list[int]) – la sequenza di passi di trotto da utilizzare.
• time (float) – il tempo totale di evoluzione dell'obiettivo.
• identity_factory (IdentityStateFactory) – una funzione per generare un oggetto State oggetto vuoto.
• exact_evolver_factory (ExactEvolverFactory) – una funzione per inizializzare l'istanza Evolver che produce lo stato di evoluzione temporale esatto, $\rho(t)$.
• approx_evolver_factory (ApproxEvolverFactory) – una funzione per inizializzare l'istanza Evolver che produce lo stato approssimativo dell'evoluzione temporale, $\rho_{k_i}(t)$, per diversi valori di $k_i$ a seconda del passo temporale fornito, dt.
• initial_state (Any) – lo stato iniziale ( $\psi_{in}$ o $\psi_0$ ) rispetto al quale calcolare gli elementi $M_{ij}$ di LSE.A e $L_i$ di LSE.b. Il tipo di questo oggetto deve corrispondere al backend della rete tensoriale scelto per gli argomenti precedenti.

Risultati

Il LSE per trovare i coefficienti MPF dinamici come descritto sopra.

Tipo di restituzione

LSE

Riferimenti

[1] : S. Zhuk et al, Fisico. Rev. Research 6, 033309 (2024).

https://journals.aps.org/prresearch/abstract/10.1103/PhysRevResearch.6.033309

[2] : N. Robertson et al, arXiv:2407.17405v2 (2024).

https://arxiv.org/abs/2407.17405v2