SMEFT Wilson coefficient `qqql` not correctly symmetrized

[peterstangl]

According to arXiv:1405.0486, Eqs. (10) and (13), the SMEFT Wilson coefficient C_qqql should satisfy

$C_{prst}^{qqql} + C_{rpst}^{qqql} = C_{sprt}^{qqql} + C_{srpt}^{qqql}$

The code below sets all non-redundant qqql coefficients to 1, uses smeftutil.wcxf2arrays_symmetrized to obtain the symmetrized coefficient in the redundant basis, and then evaluates the difference between the LHS and RHS in the equation above:

import numpy as np
from wilson import Wilson
from wilson.util import smeftutil

def check_qqql_sym(T):
    lhs = T + T.transpose(1,0,2,3)
    rhs = T.transpose(2,0,1,3) + T.transpose(2,1,0,3)
    return np.max(np.abs(lhs - rhs))

qqql_coefficients = [
    'qqql_1111',
    'qqql_1121',
    'qqql_1131',
    'qqql_1211',
    'qqql_1221',
    'qqql_1231',
    'qqql_1311',
    'qqql_1321',
    'qqql_1331',
    'qqql_2121',
    'qqql_2131',
    'qqql_2221',
    'qqql_2231',
    'qqql_2311',
    'qqql_2321',
    'qqql_2331',
    'qqql_3131',
    'qqql_3231',
    'qqql_3331',
]
wc = Wilson({k: 1 for k in qqql_coefficients}, 1000, 'SMEFT', 'Warsaw').wc

C_qqql_redundant_symmetrized = smeftutil.wcxf2arrays_symmetrized(wc.dict)['qqql']

print(check_qqql_sym(C_qqql_redundant_symmetrized))

The result should be close to 0, but is actually 0.5. There might be a bug in smeftutil.scale_8,

wilson/wilson/util/common.py

Lines 814 to 851 in bae6624

	def scale_8(b):
	"""Translations necessary for class-8 coefficients
	to go from a basis with only non-redundant WCxf
	operators to a basis where the Wilson coefficients are symmetrized like
	the operators."""
	a = np.array(b, copy=True, dtype=complex)
	for i in range(3):
	a[0, 0, 1, i] = 1 / 2 * b[0, 0, 1, i]
	a[0, 0, 2, i] = 1 / 2 * b[0, 0, 2, i]
	a[0, 1, 1, i] = 1 / 2 * b[0, 1, 1, i]
	a[0, 1, 2, i] = (
	2 / 3 * b[0, 1, 2, i]
	- 1 / 6 * b[0, 2, 1, i]
	- 1 / 6 * b[1, 0, 2, i]
	+ 1 / 6 * b[1, 2, 0, i]
	)
	a[0, 2, 1, i] = (
	-(1 / 6) * b[0, 1, 2, i]
	+ 2 / 3 * b[0, 2, 1, i]
	+ 1 / 6 * b[1, 0, 2, i]
	+ 1 / 3 * b[1, 2, 0, i]
	)
	a[0, 2, 2, i] = 1 / 2 * b[0, 2, 2, i]
	a[1, 0, 2, i] = (
	-(1 / 6) * b[0, 1, 2, i]
	+ 1 / 6 * b[0, 2, 1, i]
	+ 2 / 3 * b[1, 0, 2, i]
	- 1 / 6 * b[1, 2, 0, i]
	)
	a[1, 1, 2, i] = 1 / 2 * b[1, 1, 2, i]
	a[1, 2, 0, i] = (
	1 / 6 * b[0, 1, 2, i]
	+ 1 / 3 * b[0, 2, 1, i]
	- 1 / 6 * b[1, 0, 2, i]
	+ 2 / 3 * b[1, 2, 0, i]
	)
	a[1, 2, 2, i] = 1 / 2 * b[1, 2, 2, i]
	return a

and/or smeftutil.symmetrize_8,

wilson/wilson/util/common.py

Lines 779 to 811 in bae6624

	def symmetrize_8(b):
	"""Symmetrize class-8 coefficients.
	Note that this function does not correctly take into account the
	translation between a basis where Wilson coefficients are symmetrized
	like the operators and the non-redundant WCxf basis!
	"""
	a = np.array(b, copy=True, dtype=complex)
	a[1, 0, 0, 0] = a[0, 0, 1, 0]
	a[1, 0, 0, 1] = a[0, 0, 1, 1]
	a[1, 0, 0, 2] = a[0, 0, 1, 2]
	a[1, 1, 0, 0] = a[0, 1, 1, 0]
	a[1, 1, 0, 1] = a[0, 1, 1, 1]
	a[1, 1, 0, 2] = a[0, 1, 1, 2]
	a[2, 0, 0, 0] = a[0, 0, 2, 0]
	a[2, 0, 0, 1] = a[0, 0, 2, 1]
	a[2, 0, 0, 2] = a[0, 0, 2, 2]
	a[2, 0, 1, 0] = a[1, 2, 0, 0] + a[1, 0, 2, 0] - a[0, 2, 1, 0]
	a[2, 0, 1, 1] = a[1, 2, 0, 1] + a[1, 0, 2, 1] - a[0, 2, 1, 1]
	a[2, 0, 1, 2] = a[1, 2, 0, 2] + a[1, 0, 2, 2] - a[0, 2, 1, 2]
	a[2, 1, 0, 0] = a[0, 2, 1, 0] + a[0, 1, 2, 0] - a[1, 2, 0, 0]
	a[2, 1, 0, 1] = a[0, 2, 1, 1] + a[0, 1, 2, 1] - a[1, 2, 0, 1]
	a[2, 1, 0, 2] = a[0, 2, 1, 2] + a[0, 1, 2, 2] - a[1, 2, 0, 2]
	a[2, 1, 1, 0] = a[1, 1, 2, 0]
	a[2, 1, 1, 1] = a[1, 1, 2, 1]
	a[2, 1, 1, 2] = a[1, 1, 2, 2]
	a[2, 2, 0, 0] = a[0, 2, 2, 0]
	a[2, 2, 0, 1] = a[0, 2, 2, 1]
	a[2, 2, 0, 2] = a[0, 2, 2, 2]
	a[2, 2, 1, 0] = a[1, 2, 2, 0]
	a[2, 2, 1, 1] = a[1, 2, 2, 1]
	a[2, 2, 1, 2] = a[1, 2, 2, 2]
	return a

used in smeftutil.symmetrize_nonred,

wilson/wilson/util/common.py

Lines 936 to 977 in bae6624

	def symmetrize_nonred(self, C):
	"""Symmetrize the Wilson coefficient arrays.
	This function takes into account the symmetry factors
	that occur when transitioning from a basis with only non-redundant operators
	(like in WCxf) to a basis where the Wilson coefficients are symmetrized
	like the operators."""
	C_symm = {}
	C = self.pad_C(C)
	for i, v in C.items():
	if i in self.C_symm_keys.get(0, ()):
	C_symm[i] = v.real
	elif i in self.C_symm_keys.get(1, []) + self.C_symm_keys.get(
	3, []
	):
	C_symm[i] = v # nothing to do
	elif i in self.C_symm_keys.get(2, ()):
	C_symm[i] = self.symmetrize_2(C[i])
	elif i in self.C_symm_keys.get(4, ()):
	C_symm[i] = self.symmetrize_4(C[i])
	C_symm[i] = C_symm[i] / self._d_4
	elif i in self.C_symm_keys.get(41, ()):
	C_symm[i] = self.symmetrize_41(C[i])
	C_symm[i] = C_symm[i] / self._d_4
	elif i in self.C_symm_keys.get(5, ()):
	C_symm[i] = self.symmetrize_5(C[i])
	elif i in self.C_symm_keys.get(6, ()):
	C_symm[i] = self.symmetrize_6(C[i])
	C_symm[i] = C_symm[i] / self._d_6
	elif i in self.C_symm_keys.get(7, ()):
	C_symm[i] = self.symmetrize_7(C[i])
	C_symm[i] = C_symm[i] / self._d_7
	elif i in self.C_symm_keys.get(71, ()):
	C_symm[i] = self.symmetrize_71(C[i])
	C_symm[i] = C_symm[i] / self._d_7
	elif i in self.C_symm_keys.get(8, ()):
	C_symm[i] = self.scale_8(C[i])
	C_symm[i] = self.symmetrize_8(C_symm[i])
	elif i in self.C_symm_keys.get(9, ()):
	C_symm[i] = self.symmetrize_9(C[i])
	C_symm = self.unpad_C(C_symm)
	return C_symm

[DavidMStraub]

Do you know what this means? 🤔

https://github.com/wilson-eft/wilson/blob/master/wilson/util/common.py#L782-L784

[peterstangl]

This comment was added in f882a7e together with the scale_8 and unscale_8 function. I always assumed that the meaning of the comment was that in contrast to all other symmetrization functions, symmetrize_8 requires the additional scale_8 function. This can be seen by comparing the symmetrize function (which contains a similar comment as symmetrize_8), and the symmetrize_nonred function.

[DavidMStraub]

Oh ok. Yeah probably that's what the guy meant.

[peterstangl]

I think as a solution, I would reimplement the symmetrization in a more simple way that doesn't rescale individual components and directly enforces the synmmetry relation of qqql. In arXiv:1405.0486, Eq. (12), they decompose the 4-index tensor $T_{prst}$ into four components with definite symmetry under permutation of indices:
$T_{prst} = S_{prst} + A_{prst} + M_{prst} + N_{prst}$,
where $S$ and $A$ are totally symmetric and anitsymmetric, respectively, while $M$ and $N$ have mixed symmetry. $N$ is defined in such a way that it exactly vanishes if the qqql symmetry relation is satisfied. This means that the symmetric tensor is given by $S+A+M = T-N$. So I think for any given $T$ (not necessarily symmetrized), we can just compute $N$ and subtract it to obtain the symmetrized $S+A+M$.

[peterstangl]

I think something like this should do the trick:

def symmetrize_8(T):
    """
    Enforce the qqql symmetry relation:
      T_prst + T_rpst = T_sprt + T_srpt
    by decomposing T = S + A + M + N as in arXiv:1405.0486
    and removing the mixed-symmetry component N (keep S + A + M)
    Axes: (p, r, s, t).
    """
    sprt = T.transpose(2,0,1,3)
    rpst = T.swapaxes(0,1)
    srpt = T.transpose(2,1,0,3)
    N = 1/3 * (T - sprt + rpst - srpt)  # Eq. (13) in arXiv:1405.0486
    return T - N