The Sym2Int program: going from symmetries to interactions

TL;DR

The paper introduces Sym2Int, a program that automates the process of generating all possible interactions in a Lagrangian based on given field representations and symmetries, aiding model building in theoretical physics.

Contribution

The paper presents a new software tool that systematically enumerates interactions from symmetry representations, streamlining the construction of Lagrangians in particle physics models.

Findings

Automates the generation of interaction terms from symmetry representations.

Reduces manual effort and potential errors in model building.

Facilitates exploration of possible theories with given symmetry constraints.

Abstract

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.

Figures

Equations

$$V^{(4)}={\lambda }_{ijkl}^{SS}{\left(H_i^{\ast }{H}_j^{\ast }{H}_k{H}_l\right)}_{SS}+{\lambda }_{ijkl}^{AA}{\left(H_i^{\ast }{H}_j^{\ast }{H}_k{H}_l\right)}_{AA},$$

$$V^{(4)}={\lambda }_{ijkl}^{mixed}{\left(H_i^{\ast }{H}_j^{\ast }{H}_k{H}_l\right)}_{mixed}$$

$$V^{(4)}={\lambda }_{ijkl}^{(1)}{\left(D_i{D}_j{D}_k{D}_l\right)}_{(1)}+{\lambda }_{ijkl}^{(2)}{\left(D_i{D}_j{D}_k{D}_l\right)}_{(2)},$$

$$\left(\begin{array}[]{c}\lambda_{\pi\left(ijkl\right)}^{(1)}\\ \lambda_{\pi\left(ijkl\right)}^{(2)}\end{array}\right)=R\left(\pi\right)\left(\begin{array}[]{c}\lambda_{ijkl}^{(1)}\\ \lambda_{ijkl}^{(2)}\end{array}\right)\,,$$

Full text

AHEP Group, Instituto de Física Corpuscular, C.S.I.C./Universitat de València

Parque Científico, Calle Catedrático José Beltrán, 2 E-46980 Paterna (Valencia) – Spain

1 Symmetries of the fields and their interactions

Symmetries are an ever present feature in beyond-the-Standard-Model models: there is the Lorentz symmetry of flat space-time, there is the gauge symmetry containing $SU(3)_{c}\times SU(2)_{L}\times U(1)_{Y}$, and perhaps there are even more symmetries (for example discrete ones associated to flavor). Therefore, to build a model one first needs to find the most general Lagrangian which can be formed with a given list of fields, each transforming under some irreducible representation of the full symmetry group.

This is very often (or perhaps always) done manually, taking time and potentially leading either to the accidental inclusion of forbidden interactions, or the omission of some of the allowed ones. Furthermore, it is worth emphasizing the following two points. The first one is that the list of interactions in the Standard Model (SM) is small, but with the addition of just a few extra fields their number can increase considerably. The second thing worth keeping in mind is that all SM fields transform under small representations of the gauge group, which simplifies the task of manually computing the allowed interactions.

The aim of the Sym2Int package for Mathematica is to automatize this task: with minimal effort one can quickly obtain a full picture of a model’s interactions and at the same time reduce the probability of making mistakes. It also introduces the possibility of cross-checking results obtained by hand. The program can be downloaded from the webpage

renatofonseca.net/sym2int.php

There are already many tools which automate various of the steps required to confronted theory with data (see figure 1). However, to my knowledge the very first step described previously (i.e, finding a model’s interactions) has not been addressed fully. In fact, with the notable exception of Susyno [1] and SARAH [2], most tools assume as a starting point the Lagrangian (at the very least). In this sense, the Sym2Int program (which uses Susyno functions) can be seen as a missing link in this long chain of programs which are needed to automatize the study of the phenomenology of a model. As we will see latter on, the code counts and lists the allowed interactions of a model, but it can also provide the explicit contractions of the field components (for example, the color indices, the $SU(2)_{L}$ indices, and so on) which are needed to write down the Lagrangian.

Going from fields and symmetries to a Lagrangian requires group theory code, which is available in Susyno. In fact, this program already takes as input symmetries and fields/representations, building from 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 $\partial_{\mu}$ and/or gauge bosons are not yet handled by the program in a fully satisfactory way.111This shortcoming will probably also be addressed in a latter version of the code. Regarding this matter, I would like to thank Andreas Trautner for bringing to my attention reference [3].

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.

2 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]).

Once this is done, Sym2Int can be loaded with the command

⬇

<<Sym2Int|‘|

3 Defining a model

The program assumes that the defining elements of a model are (i) a gauge group and (ii) a list of fields which are irreducible representations of the gauge and Lorentz groups. For bookkeeping reasons, a name for the model is also required:

⬇

gaugeGroup[<model name>] ^= <gauge group>;

fields[<model name>] ^= {<field 1>, <field 2>, |…|};

GenerateListOfCouplings[<model name>];

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:

⬇

gaugeGroup[SM] ^= {SU3, SU2, U1};

\parfld1 = {"u", {3, 1, 2/3}, "R", "C", 3};

fld2 = {"d", {3, 1, -1/3}, "R", "C", 3};

fld3 = {"Q", {3, 2, 1/6}, "L", "C", 3};

fld4 = {"e", {1, 1, -1}, "R", "C", 3};

fld5 = {"L", {1, 2, -1/2}, "L", "C", 3};

fld6 = {"H", {1, 2, 1/2}, "S", "C", 1};

fields[SM] ^= {fld1, fld2, fld3, fld4, fld5, fld6};

\parGenerateListOfCouplings[SM];

With this input, the program prints the following table with a list of all possible renormalizable interactions among the given fields (table 1).

By default, the list stops at mass dimension 4. To go further, for example up to dimension 5, one can use the MaxOrder command:

⬇

GenerateListOfCouplings[SM, MaxOrder -> 5];

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 third column shows, for convenience, the mass dimension of the operator: each boson(fermion) contributes $1$($3/2$) unit(s).

• •

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.222This is true in most cases. However, in cases with complex permutation symmetries, this description ceases to be accurate. For the correct/full description of this number, see the discussion in section 4 concerning table 5.

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.

4 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:

The number of copies of each field must be taken into account. For example, in the above SM example, there is a $u^{*}QH$ interaction333The star represents just field conjugation. I omit the exact contraction of Lorentz and gauge indices. on row #2, but since both $u$ and $Q$ have 3 flavors we need a tensor $Y_{ij}$ with dimensions $3\times 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. 2.

The coupling multiplying a combination of fields $\mathcal{O}$ is real if $\mathcal{O}=\mathcal{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.444Once we introduce flavors things may become a bit more complicated. For example, in a self-conjugate term $X_{ij}\phi_{i}^{*}\phi_{j}$ where the indices $i,j=1,\cdots,n$ stand for different flavors of a field $\phi$, it is not true that $X_{ij}$ equals $X_{ij}^{*}$. Instead, on must make a permutation of the $\left(ij\right)$ 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). 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. 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 $\Delta^{*}\Delta^{*}\Delta\Delta$ for an $SU(2)$ complex scalar triplet $\Delta$. This number is shown in the last entry of the sixth column. 4. 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\times 3$ coupling tensor $\kappa_{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 $\kappa_{ij}=\kappa_{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:

⬇

fld6 = {"H1", {1, 2, 1/2}, "S", "C", 1};

fld7 = {"H2", {1, 2, 1/2}, "S", "C", 1};

fields[THDM] ^= {fld1, fld2, fld3, fld4, fld5, fld6, fld7};

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.555The counting of quartic parameters in the two cases goes as follows. The operator associated to row #5 of table 3 requires $9\times 1+1\times 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\times 1+1\times 2+1\times 1=4$ real couplings, while rows #11, #12 and #14 need a total of $1\times 1+1\times 1+1\times 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

[TABLE]

where $\left(\cdots\right)_{SS}$ and $\left(\cdots\right)_{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 $\left(ij\right)$ and $\left(kl\right)$ indices, while the other contraction is anti-symmetric under both these exchanges.666The explicit form of these contractions is quite simple: $\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)_{SS}=\left(H_{i}^{\dagger}H_{k}\right)\left(H_{j}^{\dagger}H_{l}\right)+\left(H_{j}^{\dagger}H_{k}\right)\left(H_{i}^{\dagger}H_{l}\right)$ and $\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)_{AA}=\left(H_{i}^{\dagger}H_{k}\right)\left(H_{j}^{\dagger}H_{l}\right)-\left(H_{j}^{\dagger}H_{k}\right)\left(H_{i}^{\dagger}H_{l}\right)$ (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. These symmetries are transmitted to the tensors of couplings $\lambda_{ijkl}^{SS}$ and $\lambda_{ijkl}^{AA}$, so that $\lambda_{ijkl}^{SS}=\lambda_{jikl}^{SS}=\lambda_{ijlk}^{SS}$ while $\lambda_{ijkl}^{AA}=-\lambda_{jikl}^{AA}=-\lambda_{ijlk}^{AA}$. It is then straightforward to show that $\lambda_{ijkl}^{SS}$ is described by 9 independent real numbers, while $\lambda_{ijkl}^{AA}$ requires a single one.

The origin of the two terms in equation (1) can be traced back to the fact that the product $\overline{\mathbf{2}}\times\overline{\mathbf{2}}\times\mathbf{2}\times\mathbf{2}$ in $SU(2)$ contains two singlets. But, even so, it is worth mentioning that one does not need to split $V^{(4)}$ in two terms as in equation (1). For example, consider the sum $\left(\cdots\right)_{SS}+\left(\cdots\right)_{AA}\equiv\left(\cdots\right)_{mixed}$. Then one could just write

[TABLE]

since this is the same as $\lambda_{\left(ij\right)\left(kl\right)}^{mixed}\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)_{SS}+\lambda_{\left[ij\right]\left[kl\right]}^{mixed}\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)_{AA}$ 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}\times 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,\cdots,m}$ with no hypercharge.777This would lead to fractional electric charges, but we do not care about such things here. 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 that $\mathbf{2}\times\mathbf{2}=\mathbf{1}_{A}+\mathbf{3}_{S}$, so it is tempting to think that $\mathbf{2}\times\mathbf{2}\times\mathbf{2}\times\mathbf{2}=\left(\mathbf{1}_{A}+\mathbf{3}_{S}\right)\times\left(\mathbf{1}_{A}+\mathbf{3}_{S}\right)=\mathbf{1}_{A}+\mathbf{1}_{S}+\cdots$. 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

[TABLE]

where $\left(\cdots\right)_{(1),(2)}$ are the two different contractions of four doublets and, under a $\pi\in S_{4}$ permutation of the flavour indices,

[TABLE]

where crucially the twenty-four $R\left(\pi\right)$ 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 $\lambda_{ijkl}^{(1)}$ and $\lambda_{ijkl}^{(2)}$? The answer is $\frac{1}{12}m^{2}(m-1)(m+1)$ and Sym2Int computes this expression for the user:888For this purpose, Sym2Int uses code from Susyno which in turn is based on the plethysm function described in the manual of the LiE package [7].

⬇

gaugeGroup[modelX] ^= {SU2};

fields[modelX] ^= {{"D", {2}, "S", "R", m}};

GenerateListOfCouplings[modelX];

produces table 5. Note that in the second row there is neither an “S” nor an “A” symmetry: instead, there is a {2,2}. The reason is that irreducible representations of the $S_{n}$ group can be labeled/associated with the partitions of the integer $n$. So, for $S_{4}$ the irreducible representations are {4}, {3,1}, {2,2}, {2,1,1}, {1,1,1,1} with dimensions 1, 3, 2, 3 and 1.999The function SnIrrepDim from Susyno can be used to find these dimensions [5]. The program prints for the user the relevant partitions, except in the cases of {$n$} and {1,1, …,1} which are associated to the completely symmetry (“S”) and the completely anti-symmetric (“A”) representations. Finally, note that while there are two independent contractions of four doublets, in the sixth column of row #2 of table 5, the last entry is a 1. In reality, this number stands for the number of gauge and Lorentz contractions with a given permutation symmetry. In the present case, since {2,2} is a 2-dimensional representation of $S_{4}$, there are $\left(\textrm{last entry =}1\right)\times\left(\textrm{dimension of \{2,2\} =}2\right)$ independent contractions of the gauge (and Lorentz) indices.

5 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 $\boldsymbol{D}$ and $\overline{\boldsymbol{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 ($\boldsymbol{D^{\prime}}$, $\boldsymbol{D^{\prime\prime}}$, …). For those representations it is necessary to use the notation of Dynkin coefficients (see [5, 1] for details). For example, one can indicate the representations $\mathbf{3}$, $\overline{\mathbf{3}}$, $\mathbf{15}$ and $\overline{\mathbf{15}}$ of $SU(3)$ either with the numbers 3, -3, 15, -15 or with the Dynkin coefficients {1,0}, {0,1}, {2,1}, {1,2}, while the $\boldsymbol{15^{\prime}}$ can only be specified by its Dynkin coefficients, which are {4,0}.

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].

6 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:

The number associated to the operator. 2. 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. 3.

The mass dimension of the operator. 4. 4.

Is the combination of fields self-conjugated? 5. 5.

The list of fields which appear more than once in the operator (the identification of each field is done as in 2.). 6. 6.

Permutation symmetry and number of parameters associated to the operator. 7. 7.

Information on the explicit expression(s) of the gauge and Lorentz invariant contraction (or contractions if there are several) of the fields which appear in the operator. In other words, it provides the information needed to write down the Lagrangian. (Requires the use of the option CalculateInvariants -> True; otherwise this slot in the list will contain the ‘Null’ value.) 8. 8.

The exact same data/format/style as the relevant row of the table printed by the function  

GenerateListOfCouplings.

To get a quick view of what this means in practice, consider the Standard Model as defined previously in section 3. The code

⬇

operatorsSM=GenerateListOfCouplings[SM];

Grid[operatorsSM, Frame -> All]

yields the result

.

Acknowledgements

I would like to thank the organizers of the DISCRETE 2016 Symposium in Warsaw, where this computer code was first presented. I am also grateful to the other participants which provided interesting suggestions concerning the program. Lastly, this work was financially supported by the Spanish state through the grants Juan de la Cierva-formación FJCI-2014-21651, FPA2014-58183-P, Multidark CSD2009-00064 and SEV-2014-0398 (from the Ministerio de Economía, Industria y Competitividad), as well as the grant PROMETEOII/2014/084 (from the Generalitat Valenciana).