MPFs dinâmicos

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

Retorna o sistema linear de equações para calcular os coeficientes dinâmicos do MPF.

Essa função usa o algoritmo DynamicMPF para calcular os componentes da matriz de Gram (LSE.A$M$ em [1] e [2] ) e o vetor de sobreposição (LSE.b, $L$ em [1] e [2] ) para os parâmetros de evolução temporal fornecidos.

Os elementos da matriz Gram, $M_{ij}$, e o vetor de sobreposição, $L_i$, são definidos como

em que $\rho(t)$ é o estado exato da evolução do tempo no momento $t$ e $\rho_{k_i}(t)$ é o estado da evolução do tempo aproximado usando as etapas de Trotter de $k_i$.

O cálculo dos coeficientes MPF dinâmicos (ou seja, dependentes do tempo) de $M$ e $L$ equivale a encontrar uma solução para a equação LSE (de forma semelhante a como os coeficientes static MPF são calculados) e, ao mesmo tempo, impor a restrição de que todos os coeficientes devem somar 1 ( $\sum_i x_i = 1$ ), que não é imposta como parte desse LSE (diferentemente do caso estático). Os problemas de otimização que incluem essa restrição adicional estão documentados no módulo costs módulo. O sugerido por [1] e [2] é o setup_frobenius_problem().

A avaliação de cada elemento $M_{ij}$ e $L_i$ exige o cálculo da sobreposição entre dois estados de evolução temporal. O algoritmo DynamicMPF faz isso por meio de cálculos de rede tensorial, fornecidos por uma das dependências opcionais. Os backends disponíveis são listados e explicados em mais detalhes no módulo backends módulo.

Abaixo, fornecemos um exemplo usando o quimb_tebd backend. Explicamos brevemente cada elemento.

Primeiro, inicializamos um Hamiltoniano de Heisenberg simples que gostaríamos de fazer evoluir no tempo. Como estamos usando um time-evolver baseado em quimbtambém inicializamos o Hamiltoniano usando essa biblioteca.

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

Em seguida, definimos o número de etapas de Trotter para compor nosso MPF, o tempo de evolução desejado, bem como o estado inicial ( $\psi_{in}$ em [1] e $\psi_0$ em [2], respectivamente) em relação ao qual calculamos a sobreposição entre os estados de evolução temporal. Aqui, simplesmente usamos o estado Néel, que também construímos usando quimb:

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

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

Como precisamos executar o algoritmo DynamicMPF para calcular cada elemento de $M_{ij}$ e $L_i$, precisamos fornecer métodos de fábrica para inicializar os argumentos de entrada das instâncias DynamicMPF instâncias. Para isso, precisamos oferecer três funções. Para construí-los, usaremos a função functools.partial() função.

>>> from functools import partial

Primeiro, precisamos de uma função para inicializar um estado de evolução temporal vazio (consulte também DynamicMPF.evolution_state para obter mais detalhes). Essa função de construtor não pode receber nenhum argumento posicional ou de palavra-chave e deve retornar um objeto 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))

A segunda e a terceira função devem construir os mecanismos de evolução temporal dos lados esquerdo e direito (consulte também DynamicMPF.lhs e DynamicMPF.rhs para obter mais detalhes). Essas funções devem seguir os parâmetros ExactEvolverFactory e ApproxEvolverFactory respectivamente.

A função ExactEvolverFactory deve receber um objeto State como seu único argumento posicional e deve retornar um objeto Evolver que será usado para calcular o LHS dos elementos de $L_i$ (ou seja, deve produzir o estado exato da evolução do tempo, $\rho(t)$ ).

Aqui, aproximamos o estado exato da evolução do tempo com uma fórmula Suzuki-Trotter de quarta ordem usando uma pequena etapa de tempo de 0.05. Também especificamos algumas quimb-opções de truncamento específicas para limitar a dimensão máxima da ligação da rede de tensores subjacente, bem como os valores singulares mínimos das ligações da rede de tensores 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},
... )

A função ApproxEvolverFactory também deve receber um objeto State como seu único argumento posicional e, adicionalmente, um argumento de palavra-chave chamado dt para especificar a etapa de tempo da evolução temporal. Ele também deve retornar um objeto Evolver que produz os estados de evolução temporal aproximados, $\rho_{k_i}(t)$, em que $k_i$ é determinado pela etapa de tempo escolhida, dt. Dessa forma, essas instâncias serão usadas para calcular o RHS do $L_i$, bem como os dois lados dos elementos do $M_{ij}$.

Aqui, usamos uma fórmula Suzuki-Trotter de segunda ordem com as mesmas configurações de truncamento anteriores.

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

Por fim, podemos inicializar e executar a função setup_dynamic_lse() para obter a função LSE descrito na 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]) – a sequência de passos do trotador a ser usada.
• time (float) – o tempo total de evolução do alvo.
• identity_factory (IdentityStateFactory) – uma função para gerar um objeto State vazio.
• exact_evolver_factory (ExactEvolverFactory) – uma função para inicializar a instância Evolver que produz o estado exato da evolução temporal, $\rho(t)$.
• approx_evolver_factory (ApproxEvolverFactory) – uma função para inicializar a instância Evolver que produz o estado de evolução temporal aproximado, $\rho_{k_i}(t)$, para diferentes valores de $k_i$ dependendo da etapa de tempo fornecida, dt.
• initial_state (Any) – o estado inicial ( $\psi_{in}$ ou $\psi_0$ ) com relação ao qual serão computados os elementos $M_{ij}$ de LSE.A e $L_i$ de LSE.b. O tipo desse objeto deve corresponder ao backend da rede de tensores escolhido para os argumentos anteriores.

Retorna

O LSE para encontrar os coeficientes MPF dinâmicos, conforme descrito acima.

Tipo de retorno

LSE

Referências

[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