| from functools import partial |
|
|
| from varipeps.config import Wavevector_Type |
| import jax.numpy as jnp |
| import jax.scipy as jsp |
| from jax import jit |
|
|
| from typing import Sequence, Union |
|
|
|
|
| @partial(jit, static_argnums=(5, 6, 7, 8)) |
| def apply_unitary( |
| gate: jnp.ndarray, |
| delta_r: jnp.ndarray, |
| q: Sequence[jnp.ndarray], |
| unitary_operator_D: jnp.ndarray, |
| unitary_operator_sigma: jnp.ndarray, |
| phys_d: int, |
| number_sites: int, |
| apply_to_index: Sequence[int], |
| wavevector_type: Wavevector_Type, |
| ) -> jnp.ndarray: |
| """ |
| Apply the unitary of the spiral iPEPS approach to a gate. The function |
| calculates the relative unitary gate from the operator, the spatial |
| difference and the wavevector. |
| |
| Args: |
| gate (:obj:`jax.numpy.ndarray`): |
| The gate which should be updated with the unitary operator. |
| delta_r (:obj:`jax.numpy.ndarray`): |
| Vector for the spatial difference. Can be a sequence if the spatial |
| difference are different for the single indices. |
| q (:term:`sequence` of :obj:`jax.numpy.ndarray`): |
| Sequence with the relevant wavevector for the different indices of |
| the gate. |
| unitary_operator_D (:obj:`jax.numpy.ndarray`): |
| Array with the eigenvalues of the operator from which the unitary |
| is generated. |
| unitary_operator_sigma (:obj:`jax.numpy.ndarray`): |
| Array with the eigenvectors of the operator from which the unitary |
| is generated. |
| phys_d (:obj:`int`): |
| Physical dimension of the indices of the gate. |
| number_sites (:obj:`int`): |
| Number of sites the gate is applied to. |
| apply_to_index (:term:`sequence` of :obj:`int`): |
| The indices of the gate which should be modified by the unitary |
| generated to the same ordered sequence of wavevectors. |
| wavevector_type (:obj:`~varipeps.config.Wavevector_Type`): |
| Type of the wavevector (see type definition for details). |
| Returns: |
| :obj:`jax.numpy.ndarray`: |
| The updated gate with the unitary applied. |
| """ |
| if isinstance(delta_r, jnp.ndarray): |
| delta_r = (delta_r,) * len(apply_to_index) |
|
|
| if isinstance(q, jnp.ndarray): |
| q = (q,) * len(apply_to_index) |
|
|
| if len(q) != len(apply_to_index) or len(q) != len(delta_r): |
| raise ValueError("Length mismatch!") |
|
|
| working_gate = gate.reshape((phys_d,) * 2 * number_sites) |
|
|
| for index, i in enumerate(apply_to_index): |
| w_q = q[index] |
| w_r = delta_r[index] |
|
|
| if w_q.ndim == 0: |
| w_q = jnp.array((w_q, w_q)) |
| elif w_q.size == 1: |
| w_q = jnp.array((w_q[0], w_q[0])) |
|
|
| if wavevector_type is Wavevector_Type.TWO_PI_POSITIVE_ONLY: |
| w_q = w_q % 2 |
| elif wavevector_type is Wavevector_Type.TWO_PI_SYMMETRIC: |
| w_q = w_q % 4 - 2 |
| else: |
| raise ValueError("Unknown wavevector type!") |
|
|
| |
| U = jnp.exp(1j * jnp.pi * jnp.dot(w_q, w_r) * unitary_operator_D) |
| U = jnp.dot( |
| unitary_operator_sigma * U[jnp.newaxis, :], unitary_operator_sigma.T.conj() |
| ) |
|
|
| working_gate = jnp.tensordot(U, working_gate, ((1,), (i,))) |
| working_gate = jnp.tensordot( |
| U.conj(), working_gate, ((1,), (number_sites + i,)) |
| ) |
|
|
| new_i_list = list(range(2, 2 * number_sites)) |
| new_i_list.insert(i, 1) |
| new_i_list.insert(number_sites + i, 0) |
|
|
| working_gate = working_gate.transpose(new_i_list) |
|
|
| working_gate = working_gate.reshape(phys_d**number_sites, phys_d**number_sites) |
|
|
| return working_gate |
|
|
