Fix formating of source files

Author: JanLuca

varipeps/ctmrg/absorption.py

@@ -274,7 +274,7 @@ class definition for details.
             right_proj, smallest_S = calc_right_projectors(
                 *_get_ctmrg_2x2_structure(peps_tensors, view, "top-right"),
                 config,
-                state
+                state,
             )
             right_projectors[(x, y)] = right_proj
             smallest_S_list.append(smallest_S)
@@ -474,7 +474,7 @@ class definition for details.
             bottom_proj, smallest_S = calc_bottom_projectors(
                 *_get_ctmrg_2x2_structure(peps_tensors, view, "bottom-left"),
                 config,
-                state
+                state,
             )
             bottom_projectors[(x, y)] = bottom_proj
             smallest_S_list.append(smallest_S)
@@ -894,7 +894,7 @@ def do_right_absorption_split_transfer(
             ) = calc_right_projectors_split_transfer(
                 *_get_ctmrg_2x2_structure(peps_tensors, view, "top-right"),
                 config,
-                state
+                state,
             )
             right_projectors[(x, y)] = right_proj
             smallest_S_list.append(smallest_S_ket)
@@ -1226,7 +1226,7 @@ def do_bottom_absorption_split_transfer(
             ) = calc_bottom_projectors_split_transfer(
                 *_get_ctmrg_2x2_structure(peps_tensors, view, "bottom-left"),
                 config,
-                state
+                state,
             )
             bottom_projectors[(x, y)] = bottom_proj
             smallest_S_list.append(smallest_S_ket)

varipeps/ctmrg/routine.py

@@ -579,22 +579,24 @@ def calc_ctmrg_env(
             )
 
         if tmp_count < varipeps_config.ctmrg_max_steps:
-            working_unitcell, converged, end_count, norm_smallest_S = _ctmrg_while_wrapper(
-                (
-                    peps_tensors,
-                    working_unitcell,
-                    False,
+            working_unitcell, converged, end_count, norm_smallest_S = (
+                _ctmrg_while_wrapper(
                     (
-                        corner_singular_vals
-                    if corner_singular_vals is not None
-                    else init_corner_singular_vals
-                    ),
-                    eps,
-                    tmp_count,
-                    enforce_elementwise_convergence,
-                    jnp.inf,
-                    varipeps_global_state,
-                    varipeps_config,
+                        peps_tensors,
+                        working_unitcell,
+                        False,
+                        (
+                            corner_singular_vals
+                            if corner_singular_vals is not None
+                            else init_corner_singular_vals
+                        ),
+                        eps,
+                        tmp_count,
+                        enforce_elementwise_convergence,
+                        jnp.inf,
+                        varipeps_global_state,
+                        varipeps_config,
+                    )
                 )
             )
         else:

varipeps/ctmrg/structure_factor_absorption.py

@@ -313,7 +313,7 @@ class definition for details.
             right_proj, smallest_S = calc_right_projectors(
                 *_get_ctmrg_2x2_structure(peps_tensors, view, "top-right"),
                 config,
-                state
+                state,
             )
             right_projectors[(x, y)] = right_proj
             smallest_S_list.append(smallest_S)
@@ -683,7 +683,7 @@ class definition for details.
             bottom_proj, smallest_S = calc_bottom_projectors(
                 *_get_ctmrg_2x2_structure(peps_tensors, view, "bottom-left"),
                 config,
-                state
+                state,
             )
             bottom_projectors[(x, y)] = bottom_proj
             smallest_S_list.append(smallest_S)

varipeps/mapping/triangular.py

@@ -64,12 +64,15 @@ class Triangular_Expectation_Value(Expectation_Model):
     \\
 
     Args:
-      nearest_neighbor_gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
-        Sequence with the gates that should be applied to each nearest
+      horizontal_gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
+        Sequence with the gates that should be applied to each nearest horizontal
+        neighbor.
+      vertical_gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
+        Sequence with the gates that should be applied to each nearest vertical
+        neighbor.
+      diagonal_gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
+        Sequence with the gates that should be applied to each nearest diagonal
         neighbor.
-      downward_triangle_gates (:term:`sequence` of :obj:`jax.numpy.ndarray`):
-        Sequence with the gates that should be applied to the downward
-        triangles.
       normalization_factor (:obj:`int`):
         Factor which should be used to normalize the calculated values.
         If for example three sites are mapped into one PEPS site this
@@ -81,24 +84,38 @@ class Triangular_Expectation_Value(Expectation_Model):
         if spiral iPEPS ansatz is used.
     """
 
-    nearest_neighbor_gates: Sequence[jnp.ndarray]
+    horizontal_gates: Sequence[jnp.ndarray]
+    vertical_gates: Sequence[jnp.ndarray]
+    diagonal_gates: Sequence[jnp.ndarray]
     real_d: int
     normalization_factor: int = 1
 
     is_spiral_peps: bool = False
     spiral_unitary_operator: Optional[jnp.ndarray] = None
 
     def __post_init__(self) -> None:
-        if isinstance(self.nearest_neighbor_gates, jnp.ndarray):
-            self.nearest_neighbor_gates = (self.nearest_neighbor_gates,)
+        if isinstance(self.horizontal_gates, jnp.ndarray):
+            self.horizontal_gates = (self.horizontal_gates,)
+        else:
+            self.horizontal_gates = tuple(self.horizontal_gates)
+
+        if isinstance(self.vertical_gates, jnp.ndarray):
+            self.vertical_gates = (self.vertical_gates,)
         else:
-            self.nearest_neighbor_gates = tuple(self.nearest_neighbor_gates)
+            self.vertical_gates = tuple(self.vertical_gates)
+
+        if isinstance(self.diagonal_gates, jnp.ndarray):
+            self.diagonal_gates = (self.diagonal_gates,)
+        else:
+            self.diagonal_gates = tuple(self.diagonal_gates)
 
         self._result_type = (
             jnp.float64
             if all(
                 jnp.allclose(g, g.T.conj())
-                for g in self.nearest_neighbor_gates
+                for g in self.horizontal_gates
+                + self.vertical_gates
+                + self.diagonal_gates
             )
             else jnp.complex128
         )
@@ -120,7 +137,7 @@ def __call__(
     ) -> Union[jnp.ndarray, List[jnp.ndarray]]:
         result = [
             jnp.array(0, dtype=self._result_type)
-            for _ in range(len(self.nearest_neighbor_gates))
+            for _ in range(len(self.horizontal_gates))
         ]
 
         if self.is_spiral_peps:
@@ -145,7 +162,7 @@ def __call__(
                     (1,),
                     varipeps_config.spiral_wavevector_type,
                 )
-                for h in self.nearest_neighbor_gates
+                for h in self.horizontal_gates
             )
             working_v_gates = tuple(
                 apply_unitary(
@@ -159,7 +176,7 @@ def __call__(
                     (1,),
                     varipeps_config.spiral_wavevector_type,
                 )
-                for v in self.nearest_neighbor_gates
+                for v in self.vertical_gates
             )
             working_d_gates = tuple(
                 apply_unitary(
@@ -173,12 +190,12 @@ def __call__(
                     (1,),
                     varipeps_config.spiral_wavevector_type,
                 )
-                for d in self.nearest_neighbor_gates
+                for d in self.diagonal_gates
             )
         else:
-            working_h_gates = self.nearest_neighbor_gates
-            working_v_gates = self.nearest_neighbor_gates
-            working_d_gates = self.nearest_neighbor_gates
+            working_h_gates = self.horizontal_gates
+            working_v_gates = self.vertical_gates
+            working_d_gates = self.diagonal_gates
 
         for x, iter_rows in unitcell.iter_all_rows(only_unique=only_unique):
             for y, view in iter_rows:

varipeps/optimization/optimizer.py

@@ -755,7 +755,11 @@ def random_noise(a):
                     "Energy": f"{working_value:0.10f}",
                     "Retries": random_noise_retries,
                     "Convergence": f"{conv:0.8f}",
-                    "Line search step": f"{linesearch_step:0.8f}" if linesearch_step is not None else "0",
+                    "Line search step": (
+                        f"{linesearch_step:0.8f}"
+                        if linesearch_step is not None
+                        else "0"
+                    ),
                     "Max. trunc. err.": f"{max_trunc_error:0.8g}",
                 }
             )

varipeps/peps/unitcell.py

@@ -211,7 +211,7 @@ def __post_init__(self):
 
     @staticmethod
     def _check_structure(
-        structure: Tuple[Tuple[int, ...], ...]
+        structure: Tuple[Tuple[int, ...], ...],
     ) -> Tuple[Tuple[Tuple[int, ...], ...], jnp.ndarray]:
         structure = np.array(structure)