The Sym2Int program: going from symmetries to interactions

Model builders often need to find the most general Lagrangian which can be constructed from a given list of fields. These fields are actually representations of the Lorentz and gauge groups (and maybe of some discrete symmetry group as well). I will describe a simple program (Sym2Int) which helps to automate this task by listing all possible interactions between Lorentz/gauge group representations.


Sym2Int
Feynman rules Amplitudes Lagrangian Hadronization, even generation Fields and symmetries DATA THEORY Figure 1: Chain of steps needed in order to explore the phenomenology of a model. The Sym2Int package helps with the first one, by automatizing the task of finding the interactions allowed by symmetries.
there a Lagrangian. However, it does so for supersymmetric models and furthermore there is an emphasis on the calculation of renormalization group equations. The Sym2Int package uses extensively the group theory code of Susyno but gets rid of the emphasis on theses two aspects (supersymmetry and renormalization group equations): instead, for a generic model, Sym2Int simply focuses on providing a list of allowed couplings and, if the user so wishes, it also shows how to contract the indices of the fields which participate in each interaction.
The program can deal with any representation of the Lorentz and gauge groups, and it will also work with abelian discrete symmetries. There is currently no support for non-abelian discrete symmetries; this will hopefully be added in the future. As for the type of interactions, Sym2Int will compute all allowed terms up to an arbitrary mass dimension specified by the user (it is therefore not limited to renormalizable operators). Unfortunately, due to their peculiar transformation property under gauge transformations, non-renormalizable terms with derivatives ∂ µ and/or gauge bosons are not yet handled by the program in a fully satisfactory way. 1 Having introduced the Sym2Int program, in the rest of this document I will describe how to use it. This information and some more details are available on the program's webpage [4]; furthermore, the webpage [5] may be of some use since it explains how to use Susyno's group theory code in a stand-alone way.

Installing and running the program
The sym2Int.m file which can be obtained from the program's webpage [4] should be placed in a folder where Mathematica can find it. This could be for example (Mathematica base dir.)/AddOns/Applications on Linux and Mac OS or (Mathematica base dir.)\AddOns\Applications on Windows. Since the program relies on Susyno code, this program must also be installed (it is available from the webpage [6] In turn, each field consists of (i) a name, (ii) a gauge representation, (iii) a Lorentz representation [such as scalar ("S"), right/left-handed Weyl fermion ("R"/"L"), vector ("V"), etc.], (iv) an indication of whether the field is real ("R") or complex ("C"), and (v) the number of copies/flavors. <field> = {<name>, <gauge rep>, <Lorentz rep: "S", "R", "L", "V", etc.>, <"R" or "C">, <#copies>} For example, the SM can be specified as follows: With this input, the program prints the following table with a list of all possible renormalizable interactions among the given fields (table 1).
The output is the one shown in table 2, which contains an extra row corresponding to the Weinberg operator.
Let us now take a look at the information contained in these tables which are printed by the program. For that discussion, it will be convenient to use the word operator in a rather liberal way: it stands for all gauge and Lorentz invariant contractions of a given combination of fields. As such, even if there is more than one independent gauge and Lorentz invariant contraction of the fields (say) A, B, C and D, I will still consider them to be all part of a single ABCD operator. So, with this clarification, the output tables contains the following information: • The first column simply numbers each operator. • The second column indicates what are the fields which participate in the interaction; a "[C]" after the field's name means that it is conjugated, while a "[R]" means that it is not.
• The forth column tells us whether or nor the operator is self-conjugated.
• The fifth column lists the fields which appear more than once in the operator (taking into account that conjugated fields with a "[C]" are not the same as the unconjugated ones with a "[R]").
• The sixth column contains information on the permutation symmetry and number of parameters associated to the operator. In general is has the structure "{<symmetry (if any)>, <nFlav>, <nContr>}".
-If there is any repeated field(s) in the operator, the first entry indicates what is the permutation symmetry associated to them. Otherwise, this entry is omitted.
-Some fields have flavors, i.e. they come with a multiplicity. So, the next entry indicates the number of couplings/numbers needed to encode each independent contraction of the gauge and Lorentz indices of the fields.
-The last entry indicates the number of independent contractions of the gauge and Lorentz indices of the fields. 2 All this should be clear, with perhaps the exception of the last column, which deals with parameter counting and also with symmetries under permutations of fields. This is a subtle yet very important issue which we will now discuss in detail.

Counting parameters
The number of parameters needed to encode a model is not the same as the number of rows in the output table for various simple reasons. Let us go through them: 1. The number of copies of each field must be taken into account. For example, in the above SM example, there is a u * QH interaction 3 on row #2, but since both u and Q have 3 flavors we need a tensor Y ij with dimensions 3 × 3 to encode all the couplings of this operator. There is then a need for 9 parameters, and the program presents this counting on the the second(first) entry of the last column is there are(there aren't) repeated fields in the operator.
2. The coupling multiplying a combination of fields O is real if O = O * and complex otherwise, meaning that operators which are self-conjugate (forth column of the output matrix) require half as many real couplings as those which are not self-conjugate. 4 For example, the 9 parameters needed for the u * QH operator in the SM are complex, while H * H requires a single real parameter.
3. Sometimes it is possible to contract the gauge and Lorentz indices of the fields in more than one way: for example, there are two terms of the form ∆ * ∆ * ∆∆ for an SU (2) complex scalar triplet ∆. This number is shown in the last entry of the sixth column.
4. Finally, consider the well-known non-renormalizable operator L i L j HH responsible for neutrino mass generation in the SM (row #6 of table 2). The flavor indices i and j go from 1 to 3, so a 3 × 3 coupling tensor κ ij is required. Therefore, naively one would think from the previous considerations that there are 9 complex degrees of freedom association to this operator. However, it is well known that the leptons L contract symmetrically in this particular case, hence κ ij = κ ji , so there are only 6 complex parameters and indeed that is the number displayed on the last column (second entry).
In fact, the two Higgs fields also contract symmetrically (otherwise, since there is only one copy of this field, there would be no operator!). That is what the "{"S", "S"}" in the first entry of the last column means: there are two fields which appear more than once in the operator ("L[R]" and "H[R]" as indicated in the fifth column) and both of them contract symmetrically (an "A" would indicate an anti-symmetry).
In practice, this discussion implies that the number of couplings associated to each operator is obtained by making the product of the two numbers in the sixth column. However, note that sometimes an operator might have different contractions of the gauge/Lorentz components of the fields with different symmetries; in that case the sixth column will be of the form "{<symmetry1>, <nFlav1>, <nContr1>} | {<symmetry2>, <nFlav2>, <nContr2>} | ..." and the number of degrees of freedom is given by the sum of the products <nFlavI><nContrI>. This last point is better illustrated with another example: the Two Higgs Doublet Model (THDM). There are two ways of inserting a second Higgs in the SM: one of them is to say that the fields are still "{fld1, fld2, fld3, fld4, fld5, fld6}" but now there are two copies of the Higgs: fld6 = {"Hi", {1, 2, 1/2}, "S", "C", 2}; Another possibility is to keep "fld6" as it was before, and add a "fld7" with the same quantum numbers: In the first case, we get table 3, while in the second one we get table 4. At first sight, these two results seem very different, but it is easy to check that they represent the same list of interactions. Table 3 is more compact because the two scalar doublets are treated as two copies/flavours of a single field "Hi"; for example, the quartic couplings are all encoded in row #5 of table 3 while in table 4 they are shown on the last six rows. 5 4 Once we introduce flavors things may become a bit more complicated. For example, in a self-conjugate term X ij φ * i φ j where the indices i, j = 1, · · · , n stand for different flavors of a field φ, it is not true that X ij equals X * ij . Instead, on must make a permutation of the (ij) indices jointly with the conjugation operation: X ij = X * ji . However, note that it still holds that X ij contains n 2 real degrees of freedom (and not 2n 2 real = n 2 complex degrees of freedom). 5 The counting of quartic parameters in the two cases goes as follows. The operator associated to row #5 of table 3 requires 9 × 1 + 1 × 1 = 10 real couplings. As for table 4, rows #10, #13 and #15 correspond to self-conjugated operators, so they need a total of 1 × 1 + 1 × 2 + 1 × 1 = 4 real couplings, while rows #11, #12 and #14 need a total of 1 × 1 + 1 × 1 + 1 × 1 = 3 complex couplings, hence there is a total of 10 degrees of freedom in the quartic sector -just as in table 3.  Let us now focus on the first perspective, namely that there is a single scalar field with two flavors: H i with i = 1, 2. Row #5 of table 3 is saying that one can write the quartic interactions as where (· · · ) SS and (· · · ) AA stand for two different ways of contracting the SU (2) L indices of the doublets: one is symmetric under the exchange of both the (ij) and (kl) indices, while the other contraction is antisymmetric under both these exchanges. 6 These symmetries are transmitted to the tensors of couplings It is then straightforward to show that λ SS ijkl is described by 9 independent real numbers, while λ AA ijkl requires a single one. The origin of the two terms in equation (1) can be traced back to the fact that the product 2 × 2 × 2 × 2 in SU (2) contains two singlets. But, even so, it is worth mentioning that one does not need to split V (4) 6 The explicit form of these contractions is quite simple: up to some arbitrary normalization factors). Still, we will not be discussing explicit contraction of indices since that is not necessary for counting parameters/degrees of freedom of a model. in two terms as in equation (1). For example, consider the sum (· · · ) SS + (· · · ) AA ≡ (· · · ) mixed . Then one could just write (2) since this is the same as λ mixed where round(square) brackets in the indices denotes symmetrization(anti-symmetrization). So there is a trade-off: the notation gets more compact if we replace equation (1) by equation (2) but, in the latter case, the counting of independent parameters is not as obvious. This observation also highlights the fact that, if we hide different field copies in a flavor index, then there might very well be an ambiguity in the counting of interaction terms (as in equations (1) and (2), which actually stand for the same quartic potential). The approach of the Sym2Int program is to always split the interaction terms according to their properties under field permutation symmetries, which makes the counting of parameters easier.
Field permutation symmetries can be more complicated than what has been seen so far, and for completeness we should look at a more general case. Consider the quartic operator of table 3: both H * i and H i appear twice, hence the relevant permutation group is S 2 × S 2 . Crucially, the S 2 group only has two 1-dimensional (irreducible) representations: the trivial/symmetric (S) and the alternating/anti-symmetric (A) one. What happens if there are more than n > 2 repeated fields participating in an interaction? Take, for example, a model with m real scalar doublets D i=1,··· ,m with no hypercharge. 7 Is it possible to write down quartic interactions of the form D i D j D k D l ? If yes, how many couplings are needed as a function of m?
To answer these questions one needs to understand how do four SU (2) doublets contract. It is well known However, this last statement is not correct: the two SU (2) singlets in the product of four doublets are neither completely symmetric under permutations nor completely anti-symmetric. Instead, they form an irreducible doublet of the S 4 group, which is the relevant permutation group. In practical terms, this means that we could write the D i D j D k D l quartic interactions as where (· · · ) (1), (2) are the two different contractions of four doublets and, under a π ∈ S 4 permutation of the flavour indices, where crucially the twenty-four R (π) matrices cannot be simultaneously diagonalized. In other words, these matrices form a 2-dimensional irreducible representation of S 4 . Knowing this, how many independent couplings are there between λ (1) ijkl and λ (2) ijkl ? The answer is 1 12 m 2 (m − 1)(m + 1) and Sym2Int computes this expression for the user:

Other groups, representations, and program options
The program is meant to work with any group and gauge/Lorentz representations (obviously, practical constraints associated to computational time and/or memory space do apply). To indicate a gauge group the user only has to write down its name (SU2, SU5, SO10, E6, ...). As for gauge representations of dimension D of some group, in the case of D and D, it is enough to provide the numbers D and −D (respectively). However, there might exist more than one representation with size D, and so primes are added to their names (D , D , ...). For those representations it is necessary to use the notation of Dynkin coefficients (see [1,5]  As for Lorentz representations, in most cases fields are either scalars ("S"), left/right-handed Weyl spinors ("L"/"R") or perhaps vectors ("V"), in which case it is enough to provide one of these four strings as input. More generally, irreducible representations of the Lorentz can be labeled with with two spins (i.e., two non-negative half-integers) j L and j R . Sym2Int will accept such an input if it is really necessary: for instance "S", "L", "R", "V" is equivalent to {0,0}, {1/2,0}, {0,1/2}, {1/2,1/2}. Furthermore, the function GenerateListOfCouplings has several options.
• There is support for abelian discrete symmetries through the option DiscreteSym. Multiplicative conservation of the field charges will then be enforced by the program: GenerateListOfCouplings[<model>, DiscreteSym->{<charge of field #1>, <charge of field #2>, ...}]; • The function GenerateListOfCouplings not only prints the list of interactions but it also returns this data in a particular format (see section 6). If the table with a model's interactions is not necessary/desired, it can be suppress with the Verbose->False option.
• Hermitian conjugated operators are not shown by default. This can be changed with the option HCTerms->True. • Computing the permutation symmetries which were discussed in section 4 is time consuming hence, if this information is not needed, one can use the option CalculateSnSymmetries->False to speed up the calculation of the list of interactions.
• As mentioned previously, beyond listing the allowed interactions, Sym2Int can also calculate how the field components are contracted in each case. To do that, the option CalculateInvariants -> True must be used. Note that, depending on the number and size of the fields, this can be very time consuming. For more details on this part of the program, the user is referred to the online documentation [4].

Saving the program's results for further processing
The program prints by default a human-readable table with all the allowed operators. However, one might want to further process Sym2Int's results in Mathematica, and in that case one should save and use instead the output returned by the function GenerateListOfCouplings. This output consists of a list with the following 8 pieces of information for each operator: 1. The number associated to the operator.
2. The combination of fields which are interacting. Each field is identified by its position in the list provided by the user as input (if the field does not appear conjugated in the operator) or minus its position in the list provided by the user as input (if the field does appear conjugated in the operator).
3. The mass dimension of the operator.
4. Is the combination of fields self-conjugated?
5. The list of fields which appear more than once in the operator (the identification of each field is done as in 2.).
6. Permutation symmetry and number of parameters associated to the operator.