MPF dinámicos

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

Devuelve el sistema lineal de ecuaciones para calcular los coeficientes MPF dinámicos.

Esta función utiliza el algoritmo DynamicMPF para calcular los componentes de la matriz de Gram (LSE.A, $M$ en [1] y [2] ) y el vector de solapamiento (LSE.b, $L$ en [1] y [2] ) para los parámetros de evolución temporal proporcionados.

Los elementos de la matriz de Gram, $M_{ij}$, y el vector de solapamiento, $L_i$, se definen como

donde $\rho(t)$ es el estado de evolución temporal exacto en el tiempo $t$ y $\rho_{k_i}(t)$ es el estado de evolución temporal aproximado utilizando $k_i$ pasos de Trotter.

Calcular los coeficientes MPF dinámicos (es decir, dependientes del tiempo) a partir de $M$ y $L$ equivale a encontrar una solución a la ecuación LSE (de forma similar a como se calculan los coeficientes static MPF) mientras se aplica la restricción de que todos los coeficientes deben sumar 1 ( $\sum_i x_i = 1$ ), que no se aplica como parte de esta LSE (a diferencia del caso estático). Los problemas de optimización que incluyen esta restricción adicional se documentan en el módulo costs módulo. El sugerido por [1] y [2] es el setup_frobenius_problem().

La evaluación de cada elemento $M_{ij}$ y $L_i$ requiere calcular el solapamiento entre dos estados de evolución temporal. El algoritmo DynamicMPF algoritmo lo hace mediante cálculos de redes tensoriales, proporcionados por una de las dependencias opcionales. Los backends disponibles se enumeran y explican con más detalle en el módulo backends módulo.

A continuación, ofrecemos un ejemplo utilizando el quimb_tebd backend. Explicamos brevemente cada elemento.

En primer lugar, inicializamos un Hamiltoniano de Heisenberg simple que nos gustaría hacer evolucionar en el tiempo. Como estamos utilizando un evolucionador temporal basado en quimbtambién inicializamos el Hamiltoniano utilizando esa biblioteca.

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

A continuación, definimos el número de pasos de Trotter que componen nuestro MPF, el tiempo de evolución objetivo, así como el estado inicial ( $\psi_{in}$ en [1] y $\psi_0$ en [2], resp.) con respecto a la cual calculamos el solapamiento entre los estados de evolución temporal. Aquí, simplemente utilizamos el estado Néel que también construimos utilizando quimb:

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

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

Dado que debemos ejecutar el algoritmo DynamicMPF para calcular cada elemento de $M_{ij}$ y $L_i$, debemos proporcionar métodos de fábrica para inicializar los argumentos de entrada de las instancias DynamicMPF instancias. Para ello, debemos ofrecer tres funciones. Para construirlas, utilizaremos la función functools.partial() función

>>> from functools import partial

En primer lugar, necesitamos una función para inicializar un estado de evolución temporal vacío (véase también DynamicMPF.evolution_state para más detalles). Esta función constructora no puede tomar ningún argumento posicional o de palabra clave y debe devolver un State objeto.

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

La segunda y tercera función deben construir los motores de evolución temporal del lado izquierdo y derecho (véase también DynamicMPF.lhs y DynamicMPF.rhs para más detalles). Estas funciones deben seguir los ExactEvolverFactory y ApproxEvolverFactory respectivamente.

La función ExactEvolverFactory debe tomar un objeto State como único argumento posicional y debe devolver un objeto Evolver que se utilizará para calcular el LHS de los elementos de $L_i$ (es decir, debe producir el estado de evolución temporal exacto, $\rho(t)$ ).

Aquí, aproximamos el estado exacto evolucionado en el tiempo con una fórmula de Suzuki-Trotter de cuarto orden utilizando un pequeño paso de tiempo de 0.05. También especificamos algunas quimb-opciones de truncamiento específicas para limitar la dimensión máxima de los enlaces de la red tensorial subyacente, así como los valores singulares mínimos de los enlaces de la red tensorial dividida.

>>> 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 función ApproxEvolverFactory debe tomar también un objeto State como único argumento posicional y, además, un argumento de palabra clave denominado dt para especificar el paso temporal de la evolución temporal. También debe devolver un objeto Evolver que produce los estados aproximados de evolución temporal, $\rho_{k_i}(t)$, donde $k_i$ viene determinado por el paso temporal elegido, dt. Como tales, estas instancias se utilizarán para calcular el RHS de $L_i$ así como ambos lados de los elementos de $M_{ij}$.

Aquí, utilizamos una fórmula de Suzuki-Trotter de segundo orden con los mismos ajustes de truncamiento que antes.

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

Por último, podemos inicializar y ejecutar la función setup_dynamic_lse() para obtener el LSE descrito en la parte superior.

>>> 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]

Parámetros

• trotter_steps (list[int]) – la secuencia de pasos de trote que se utilizará.
• time (float) – el tiempo total de evolución del objetivo.
• identity_factory (IdentityStateFactory) – una función para generar un objeto State vacío.
• exact_evolver_factory (ExactEvolverFactory) – una función para inicializar la instancia Evolver instancia que produce el estado exacto de evolución temporal, $\rho(t)$.
• approx_evolver_factory (ApproxEvolverFactory) – una función para inicializar la instancia Evolver instancia que produce el estado aproximado de evolución temporal, $\rho_{k_i}(t)$, para diferentes valores de $k_i$ en función del paso temporal proporcionado, dt.
• initial_state (Any) – el estado inicial ( $\psi_{in}$ o $\psi_0$ ) con respecto al cual calcular los elementos $M_{ij}$ de LSE.A y $L_i$ de LSE.b. El tipo de este objeto debe coincidir con el backend de red tensorial elegido para los argumentos anteriores.

Devuelve

La dirección LSE para hallar los coeficientes MPF dinámicos como se ha descrito anteriormente.

Tipo de retorno

LSE

Referencias

[1] : S. Zhuk et al., Física. 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