symfc 1.3.2__tar.gz → 1.3.4__tar.gz

{symfc-1.3.2/src/symfc.egg-info → symfc-1.3.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: symfc
-Version: 1.3.2
+Version: 1.3.4
 Summary: This is the symfc module.
 Author-email: Atsuto Seko <seko@cms.mtl.kyoto-u.ac.jp>
 Maintainer-email: Atsushi Togo <atztogo@gmail.com>

{symfc-1.3.2 → symfc-1.3.4}/src/symfc/utils/eig_tools.py

@@ -359,10 +359,23 @@ def eigsh_projector_sumrule_large(p: csr_array, verbose: bool = True) -> np.ndar
     When p = diag(A,B), Av = v, and Bw = w, p[v,0] = [v,0] and p[0,w] = [0,w]
     are solutions.
 
-    This function solves numpy.eigh for all block matrices.
-    This function is efficient for matrix p composed of nonequivalent
-    block matrices.
-
+    This algorithm is optimized to solve an eigenvalue problem for
+    projection matrix p with large block submatrices.
+    The algorithm for solving each block submatrix is as follows.
+    1. Divide each block submatrix into reasonable sizes of submatrices,
+       not projectors.
+    2. Solve eigenvalue problems for these submatrices and eigenvectors
+       with eigenvalues of one are extracted. The eigenvectors with
+       eigenvalues e < 1 are used for compressing the complementary matrix
+       in the next step.
+    3. Calculate the complementary matrix, which corresponds to the complement
+       of the vector space spanned by the eigenvectors. The complementary matrix
+       is compressed using the eigenvectors with e < 1.
+    4. Solve eigenvalue problem for the complementary matrix and eigenvectors
+       with e = 1 are calculated. The eigenvalue problems are efficiently solved
+       using the compressed complementary matrix and the eigenvectors are recovered by
+       the compression matrix.
+    5. Collect all eigenvectors with e = 1.
     """
     group = _find_projector_blocks(p)
     if verbose:

symfc-1.3.4/src/symfc/utils/matrix_tools.py

@@ -0,0 +1,35 @@
+"""Matrix utility functions."""
+
+import numpy as np
+from scipy.sparse import csr_array
+
+
+def permutation_dot_lat_trans(
+    combinations_ijk: np.ndarray,
+    combinations_abc: np.ndarray,
+    atomic_decompr_idx: np.ndarray,
+    n_perms: int,
+    n_perms_group: int,
+    n_lp: int,
+    order: int,
+    natom: int,
+) -> csr_array:
+    """Return C_perm.T @ C_trans for permulation symmetry rules."""
+    assert combinations_ijk.shape[0] == combinations_abc.shape[0]
+
+    sum_abc = 3**order
+    sum_ijkabc = natom**order * sum_abc
+    n_combinations = combinations_ijk.shape[0] // n_perms
+    n_perms_sym = n_perms // n_perms_group
+    c_pt = csr_array(
+        (
+            np.full(n_combinations * n_perms, 1 / np.sqrt(n_perms_sym * n_lp)),
+            (
+                np.repeat(np.arange(n_combinations * n_perms_group), n_perms_sym),
+                atomic_decompr_idx[combinations_ijk] * sum_abc + combinations_abc,
+            ),
+        ),
+        shape=(n_combinations * n_perms_group, sum_ijkabc // n_lp),
+        dtype="double",
+    )
+    return c_pt

{symfc-1.3.2 → symfc-1.3.4}/src/symfc/utils/matrix_tools_O2.py

@@ -7,7 +7,8 @@ import scipy
 from scipy.sparse import csr_array
 
 from symfc.utils.cutoff_tools import FCCutoff
-from symfc.utils.matrix_tools import get_combinations, permutation_dot_lat_trans
+from symfc.utils.matrix_tools import permutation_dot_lat_trans
+from symfc.utils.permutation_tools import get_combinations
 from symfc.utils.solver_funcs import get_batch_slice
 from symfc.utils.utils import get_indep_atoms_by_lat_trans
 from symfc.utils.utils_O2 import _get_atomic_lat_trans_decompr_indices
@@ -103,7 +104,7 @@ def optimize_batch_size_sum_rules_O2(natom: int, n_batch: Optional[int] = None):
     return batch_size
 
 
-def compressed_projector_sum_rules_O2_index_atoms(
+def compressed_projector_sum_rules_O2(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -111,18 +112,67 @@ def compressed_projector_sum_rules_O2_index_atoms(
     n_batch: int = 1,
     use_mkl: bool = False,
 ) -> csr_array:
-    """Return projection matrix for sum rule.
+    r"""Return projection matrix for translational sum rule.
 
-    Calculate a complementary projector for sum rules.
-    This is compressed by C_trans and n_a_compress_mat without
-    allocating C_trans.
-    Memory efficient version using get_atomic_lat_trans_decompr_indices_O3.
+    Calculate a compressed projector for translational sum rules
+    efficiently using independent atom with respect to lattice translations.
+    This compression is achieved using C_trans and n_a_compress_mat,
+    without the need to allocate C_trans. The implementation utilizes
+    get_atomic_lat_trans_decompr_indices_O3 to ensure efficient memory usage.
 
     Return
     ------
-    Compressed projector I - P^(c)
-    P^(c) = n_a_compress_mat.T @ C_trans.T @ C_sum^(c)
-            @ C_sum^(c).T @ C_trans @ n_a_compress_mat
+    Compressed projector I - P^(c).
+    I - P^(c)
+    = n_a_compress_mat.T @ C_trans.T
+      @ [I - C_sum^(c) @ C_sum^(c).T] @ C_trans @ n_a_compress_mat
+    = I - [n_a_compress_mat.T @ C_trans.T @ C_sum^(c)]
+          @ [C_sum^(c).T @ C_trans @ n_a_compress_mat]
+
+    Algorithm
+    ---------
+    1. C_sum^(c).T = [I, I, I, ...] of size (27N, 27N^2).
+       I denotes the unit matrix of size (27N, 27N).
+       C_sum^(c).T is composed of N unit matrices.
+       In this representation, the translational sum rules are given by
+       \sum_i FC2(i, j, a, b) = 0.
+
+    2. To divide the computation of a compressed projector into several batches,
+       C_sum^(c) and C_trans are permuted from the index order of (i, j, a, b)
+       to (a, b, j, i).
+       This is represented by C_sum^(c).T @ C_trans = C_sum^(c).T @ S.T @ S @ C_trans,
+       where S denotes the permutation matrix that changes the index order to
+       (a, b, j, i). Using this permutation, the translational sum rules are
+       represented as
+       C_sum^(c).T @ S.T = [
+           [1_N.T, 0_N.T, 0_N.T, ...]
+           [0_N.T, 1_N.T, 0_N.T, ...]
+           [0_N.T, 0_N.T, 1_N.T, ...]
+           ...
+       ],
+       where 1_N and 0_N are column vectors of size N with all elements
+       equal to one and zero, respectively.
+       (Example) C_sum^(c).T @ S.T = [
+                    [1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ...]
+                    [0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 ...]
+                    [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 ...]
+                    ...
+                 ]
+        In this function, the permutation is achieved by using matrix reshapes.
+
+    3. Set C_trans.T @ C_sum^(c) @ C_sum^(c).T @ C_trans
+       = [(C_trans.T @ S.T) @ (S @ C_sum^(c))] @ [(C_sum^(c).T @ S.T) @ (S @ C_trans)]
+       =   [T_1, T_2, ..., T_N33]
+         @ (S @ C_sum^(c)) @ (C_sum^(c).T @ S.T)
+         @ [T_1, T_2, ..., T_N33].T
+       = \sum_i t_i @ t_i.T,
+       where t_i = \sum_c T_i[:, c].
+       t_i is represented by c_sum_cplmt.T in this function.
+       T_i is the submatrix of size (N, n_aN33) of permuted C_trans.
+
+    4. Compute P^(c) = \sum_i (n_a_compress_mat.T @ t_i) @ (t_i.T @ n_a_compress_mat)
+
+    5. Compute P = I - P^(c)
     """
     n_lp, natom = trans_perms.shape
     NN9 = natom**2 * 9
@@ -135,14 +185,15 @@ def compressed_projector_sum_rules_O2_index_atoms(
         atomic_decompr_idx = _get_atomic_lat_trans_decompr_indices(trans_perms)
 
     decompr_idx = atomic_decompr_idx.reshape((natom, natom)).T.reshape(-1) * 9
-    if fc_cutoff is None:
-        indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
-        nonzero = np.zeros((natom, natom), dtype=bool)
-        nonzero[indep_atoms, :] = True
-        nonzero = nonzero.reshape(-1)
-    else:
-        nonzero = fc_cutoff.nonzero_atomic_indices_fc2()
-        nonzero = nonzero.reshape((natom, natom)).T.reshape(-1)
+
+    indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
+    nonzero = np.zeros((natom, natom), dtype=bool)
+    nonzero[indep_atoms, :] = True
+    nonzero = nonzero.reshape(-1)
+    if fc_cutoff is not None:
+        nonzero_c = fc_cutoff.nonzero_atomic_indices_fc2()
+        nonzero_c = nonzero_c.reshape((natom, natom)).T.reshape(-1)
+        nonzero = nonzero & nonzero_c
 
     batch_size = optimize_batch_size_sum_rules_O2(natom, n_batch=n_batch)
     ab = np.arange(9)
@@ -171,11 +222,11 @@ def compressed_projector_sum_rules_O2_index_atoms(
         c_sum_cplmt = dot_product_sparse(c_sum_cplmt, n_a_compress_mat, use_mkl=use_mkl)
         proj_cplmt += dot_product_sparse(c_sum_cplmt.T, c_sum_cplmt, use_mkl=use_mkl)
 
-    proj_cplmt /= n_lp * natom
+    proj_cplmt /= natom
     return scipy.sparse.identity(proj_cplmt.shape[0]) - proj_cplmt
 
 
-def compressed_projector_sum_rules_O2(
+def compressed_projector_sum_rules_O2_stable(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -183,18 +234,66 @@ def compressed_projector_sum_rules_O2(
     n_batch: int = 1,
     use_mkl: bool = False,
 ) -> csr_array:
-    """Return projection matrix for sum rule.
+    r"""Return projection matrix for translational sum rule.
 
-    Calculate a complementary projector for sum rules.
-    This is compressed by C_trans and n_a_compress_mat without
-    allocating C_trans.
-    Memory efficient version using get_atomic_lat_trans_decompr_indices_O3.
+    Calculate a compressed projector for translational sum rules.
+    This compression is achieved using C_trans and n_a_compress_mat,
+    without the need to allocate C_trans. The implementation utilizes
+    get_atomic_lat_trans_decompr_indices_O3 to ensure efficient memory usage.
 
     Return
     ------
-    Compressed projector I - P^(c)
-    P^(c) = n_a_compress_mat.T @ C_trans.T @ C_sum^(c)
-            @ C_sum^(c).T @ C_trans @ n_a_compress_mat
+    Compressed projector I - P^(c).
+    I - P^(c)
+    = n_a_compress_mat.T @ C_trans.T
+      @ [I - C_sum^(c) @ C_sum^(c).T] @ C_trans @ n_a_compress_mat
+    = I - [n_a_compress_mat.T @ C_trans.T @ C_sum^(c)]
+          @ [C_sum^(c).T @ C_trans @ n_a_compress_mat]
+
+    Algorithm
+    ---------
+    1. C_sum^(c).T = [I, I, I, ...] of size (27N, 27N^2).
+       I denotes the unit matrix of size (27N, 27N).
+       C_sum^(c).T is composed of N unit matrices.
+       In this representation, the translational sum rules are given by
+       \sum_i FC2(i, j, a, b) = 0.
+
+    2. To divide the computation of a compressed projector into several batches,
+       C_sum^(c) and C_trans are permuted from the index order of (i, j, a, b)
+       to (a, b, j, i).
+       This is represented by C_sum^(c).T @ C_trans = C_sum^(c).T @ S.T @ S @ C_trans,
+       where S denotes the permutation matrix that changes the index order to
+       (a, b, j, i). Using this permutation, the translational sum rules are
+       represented as
+       C_sum^(c).T @ S.T = [
+           [1_N.T, 0_N.T, 0_N.T, ...]
+           [0_N.T, 1_N.T, 0_N.T, ...]
+           [0_N.T, 0_N.T, 1_N.T, ...]
+           ...
+       ],
+       where 1_N and 0_N are column vectors of size N with all elements
+       equal to one and zero, respectively.
+       (Example) C_sum^(c).T @ S.T = [
+                    [1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ...]
+                    [0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 ...]
+                    [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 ...]
+                    ...
+                 ]
+        In this function, the permutation is achieved by using matrix reshapes.
+
+    3. Set C_trans.T @ C_sum^(c) @ C_sum^(c).T @ C_trans
+       = [(C_trans.T @ S.T) @ (S @ C_sum^(c))] @ [(C_sum^(c).T @ S.T) @ (S @ C_trans)]
+       =   [T_1, T_2, ..., T_N33]
+         @ (S @ C_sum^(c)) @ (C_sum^(c).T @ S.T)
+         @ [T_1, T_2, ..., T_N33].T
+       = \sum_i t_i @ t_i.T,
+       where t_i = \sum_c T_i[:, c].
+       t_i is represented by c_sum_cplmt.T in this function.
+       T_i is the submatrix of size (N, n_aN33) of permuted C_trans.
+
+    4. Compute P^(c) = \sum_i (n_a_compress_mat.T @ t_i) @ (t_i.T @ n_a_compress_mat)
+
+    5. Compute P = I - P^(c)
     """
     n_lp, natom = trans_perms.shape
     NN9 = natom**2 * 9

{symfc-1.3.2 → symfc-1.3.4}/src/symfc/utils/matrix_tools_O3.py

@@ -7,7 +7,8 @@ import scipy
 from scipy.sparse import csr_array, vstack
 
 from symfc.utils.cutoff_tools import FCCutoff
-from symfc.utils.matrix_tools import get_combinations, permutation_dot_lat_trans
+from symfc.utils.matrix_tools import permutation_dot_lat_trans
+from symfc.utils.permutation_tools import get_combinations
 from symfc.utils.solver_funcs import get_batch_slice
 from symfc.utils.utils import get_indep_atoms_by_lat_trans
 from symfc.utils.utils_O3 import get_atomic_lat_trans_decompr_indices_O3
@@ -308,7 +309,7 @@ def optimize_batch_size_sum_rules_O3(natom: int, n_batch: Optional[int] = None):
     return batch_size
 
 
-def compressed_projector_sum_rules_O3_indep_atoms(
+def compressed_projector_sum_rules_O3(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -317,18 +318,67 @@ def compressed_projector_sum_rules_O3_indep_atoms(
     use_mkl: bool = False,
     verbose: bool = False,
 ) -> csr_array:
-    """Return projection matrix for sum rule.
+    r"""Return projection matrix for translational sum rule.
 
-    Calculate a complementary projector for sum rules.
-    This is compressed by C_trans and n_a_compress_mat without
-    allocating C_trans.
-    Memory efficient version using get_atomic_lat_trans_decompr_indices_O3.
+    Calculate a compressed projector for translational sum rules
+    efficiently using independent atom with respect to lattice translations.
+    This compression is achieved using C_trans and n_a_compress_mat,
+    without the need to allocate C_trans. The implementation utilizes
+    get_atomic_lat_trans_decompr_indices_O3 to ensure efficient memory usage.
 
     Return
     ------
-    Compressed projector I - P^(c)
-    P^(c) = n_a_compress_mat.T @ C_trans.T @ C_sum^(c)
-            @ C_sum^(c).T @ C_trans @ n_a_compress_mat
+    Compressed projector I - P^(c).
+    I - P^(c)
+    = n_a_compress_mat.T @ C_trans.T
+      @ [I - C_sum^(c) @ C_sum^(c).T] @ C_trans @ n_a_compress_mat
+    = I - [n_a_compress_mat.T @ C_trans.T @ C_sum^(c)]
+          @ [C_sum^(c).T @ C_trans @ n_a_compress_mat]
+
+    Algorithm
+    ---------
+    1. C_sum^(c).T = [I, I, I, ...] of size (27N^2, 27N^3).
+       I denotes the unit matrix of size (27N^2, 27N^2).
+       C_sum^(c).T is composed of N unit matrices.
+       In this representation, the translational sum rules are given by
+       \sum_i FC3(i, j, k, a, b, c) = 0.
+
+    2. To divide the computation of a compressed projector into several batches,
+       C_sum^(c) and C_trans are permuted from the index order of (i, j, k, a, b, c)
+       to (a, b, c, j, k, i).
+       This is represented by C_sum^(c).T @ C_trans = C_sum^(c).T @ S.T @ S @ C_trans,
+       where S denotes the permutation matrix that changes the index order to
+       (a, b, c, j, k, i). Using this permutation, the translational sum rules are
+       represented as
+       C_sum^(c).T @ S.T = [
+           [1_N.T, 0_N.T, 0_N.T, ...]
+           [0_N.T, 1_N.T, 0_N.T, ...]
+           [0_N.T, 0_N.T, 1_N.T, ...]
+           ...
+       ],
+       where 1_N and 0_N are column vectors of size N with all elements
+       equal to one and zero, respectively.
+       (Example) C_sum^(c).T @ S.T = [
+                    [1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ...]
+                    [0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 ...]
+                    [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 ...]
+                    ...
+                 ]
+        In this function, the permutation is achieved by using matrix reshapes.
+
+    3. Set C_trans.T @ C_sum^(c) @ C_sum^(c).T @ C_trans
+       = [(C_trans.T @ S.T) @ (S @ C_sum^(c))] @ [(C_sum^(c).T @ S.T) @ (S @ C_trans)]
+       =   [T_1, T_2, ..., T_NN333]
+         @ (S @ C_sum^(c)) @ (C_sum^(c).T @ S.T)
+         @ [T_1, T_2, ..., T_NN333].T
+       = \sum_i t_i @ t_i.T,
+       where t_i = \sum_c T_i[:, c].
+       t_i is represented by c_sum_cplmt.T in this function.
+       T_i is the submatrix of size (N, n_aNN333) of permuted C_trans.
+
+    4. Compute P^(c) = \sum_i (n_a_compress_mat.T @ t_i) @ (t_i.T @ n_a_compress_mat)
+
+    5. Compute P = I - P^(c)
     """
     n_lp, natom = trans_perms.shape
     NNN27 = natom**3 * 27
@@ -343,14 +393,14 @@ def compressed_projector_sum_rules_O3_indep_atoms(
 
     decompr_idx = atomic_decompr_idx.reshape((natom, NN)).T.reshape(-1) * 27
 
-    if fc_cutoff is None:
-        indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
-        nonzero = np.zeros((natom, natom, natom), dtype=bool)
-        nonzero[indep_atoms, :, :] = True
-        nonzero = nonzero.reshape(-1)
-    else:
-        nonzero = fc_cutoff.nonzero_atomic_indices_fc3()
-        nonzero = nonzero.reshape((natom, NN)).T.reshape(-1)
+    indep_atoms = get_indep_atoms_by_lat_trans(trans_perms)
+    nonzero = np.zeros((natom, natom, natom), dtype=bool)
+    nonzero[indep_atoms, :, :] = True
+    nonzero = nonzero.reshape(-1)
+    if fc_cutoff is not None:
+        nonzero_c = fc_cutoff.nonzero_atomic_indices_fc3()
+        nonzero_c = nonzero_c.reshape((natom, NN)).T.reshape(-1)
+        nonzero = nonzero & nonzero_c
 
     batch_size = optimize_batch_size_sum_rules_O3(natom, n_batch=n_batch)
     abc = np.arange(27)
@@ -381,11 +431,11 @@ def compressed_projector_sum_rules_O3_indep_atoms(
         c_sum_cplmt = dot_product_sparse(c_sum_cplmt, n_a_compress_mat, use_mkl=use_mkl)
         proj_cplmt += dot_product_sparse(c_sum_cplmt.T, c_sum_cplmt, use_mkl=use_mkl)
 
-    proj_cplmt /= n_lp * natom
+    proj_cplmt /= natom
     return scipy.sparse.identity(proj_cplmt.shape[0]) - proj_cplmt
 
 
-def compressed_projector_sum_rules_O3(
+def compressed_projector_sum_rules_O3_stable(
     trans_perms: np.ndarray,
     n_a_compress_mat: csr_array,
     atomic_decompr_idx: Optional[np.ndarray] = None,
@@ -394,18 +444,66 @@ def compressed_projector_sum_rules_O3(
     use_mkl: bool = False,
     verbose: bool = False,
 ) -> csr_array:
-    """Return projection matrix for sum rule.
+    r"""Return projection matrix for translational sum rule.
 
-    Calculate a complementary projector for sum rules.
-    This is compressed by C_trans and n_a_compress_mat without
-    allocating C_trans.
-    Memory efficient version using get_atomic_lat_trans_decompr_indices_O3.
+    Calculate a compressed projector for translational sum rules.
+    This compression is achieved using C_trans and n_a_compress_mat,
+    without the need to allocate C_trans. The implementation utilizes
+    get_atomic_lat_trans_decompr_indices_O3 to ensure efficient memory usage.
 
     Return
     ------
-    Compressed projector I - P^(c)
-    P^(c) = n_a_compress_mat.T @ C_trans.T @ C_sum^(c)
-            @ C_sum^(c).T @ C_trans @ n_a_compress_mat
+    Compressed projector I - P^(c).
+    I - P^(c)
+    = n_a_compress_mat.T @ C_trans.T
+      @ [I - C_sum^(c) @ C_sum^(c).T] @ C_trans @ n_a_compress_mat
+    = I - [n_a_compress_mat.T @ C_trans.T @ C_sum^(c)]
+          @ [C_sum^(c).T @ C_trans @ n_a_compress_mat]
+
+    Algorithm
+    ---------
+    1. C_sum^(c).T = [I, I, I, ...] of size (27N^2, 27N^3).
+       I denotes the unit matrix of size (27N^2, 27N^2).
+       C_sum^(c).T is composed of N unit matrices.
+       In this representation, the translational sum rules are given by
+       \sum_i FC3(i, j, k, a, b, c) = 0.
+
+    2. To divide the computation of a compressed projector into several batches,
+       C_sum^(c) and C_trans are permuted from the index order of (i, j, k, a, b, c)
+       to (a, b, c, j, k, i).
+       This is represented by C_sum^(c).T @ C_trans = C_sum^(c).T @ S.T @ S @ C_trans,
+       where S denotes the permutation matrix that changes the index order to
+       (a, b, c, j, k, i). Using this permutation, the translational sum rules are
+       represented as
+       C_sum^(c).T @ S.T = [
+           [1_N.T, 0_N.T, 0_N.T, ...]
+           [0_N.T, 1_N.T, 0_N.T, ...]
+           [0_N.T, 0_N.T, 1_N.T, ...]
+           ...
+       ],
+       where 1_N and 0_N are column vectors of size N with all elements
+       equal to one and zero, respectively.
+       (Example) C_sum^(c).T @ S.T = [
+                    [1 1 1 1 1 0 0 0 0 0 0 0 0 0 0 ...]
+                    [0 0 0 0 0 1 1 1 1 1 0 0 0 0 0 ...]
+                    [0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 ...]
+                    ...
+                 ]
+        In this function, the permutation is achieved by using matrix reshapes.
+
+    3. Set C_trans.T @ C_sum^(c) @ C_sum^(c).T @ C_trans
+       = [(C_trans.T @ S.T) @ (S @ C_sum^(c))] @ [(C_sum^(c).T @ S.T) @ (S @ C_trans)]
+       =   [T_1, T_2, ..., T_NN333]
+         @ (S @ C_sum^(c)) @ (C_sum^(c).T @ S.T)
+         @ [T_1, T_2, ..., T_NN333].T
+       = \sum_i t_i @ t_i.T,
+       where t_i = \sum_c T_i[:, c].
+       t_i is represented by c_sum_cplmt.T in this function.
+       T_i is the submatrix of size (N, n_aNN333) of permuted C_trans.
+
+    4. Compute P^(c) = \sum_i (n_a_compress_mat.T @ t_i) @ (t_i.T @ n_a_compress_mat)
+
+    5. Compute P = I - P^(c)
     """
     n_lp, natom = trans_perms.shape
     NNN27 = natom**3 * 27