# Sym2Int

## Listing all interactions of a model

Extensions of the Standard Model (SM) might involve a different gauge group and/or new fields; in either case, it is important to understand what is the most general Lagrangian invariant under the symmetries of the model. However, sometimes one might forget to write down some valid interactions, and/or even end up writing some interactions which do not exist. Automatizing the process might help to reduce such mistakes.

This page describes the Mathematica code Sym2Int (Symmetries to Interactions) which lists all valid interactions — except those with derivatives and those involving gauge bosons — given the model's gauge group and fields (specified by their gauge and Lorentz representations). The program is valid for renormalizable interactions (mass dimension $\leq4$) as well as the ones which are not renormalizable (mass dimension $>4$). More details can be found below.

## Other references

The program is described in the paper "Renato M. Fonseca, "The Sym2Int program: going from symmetries to interactions, arXiv:1703.05221 [hep-ph]". I presented the code in Warsaw, December 2016 (the slides are available here ) and I also discussed a topic related to it (see "The symmetry column" section below) in Bonn, April 2017; more details can be found here .

## Installing the code

Sym2Int requires the group theory code of Susyno (version 3.5 or latter), so both programs must be downloaded and installed correctly. The Susyno code can be found here while Sym2Int can be obtained from this page:

Both the Susyno folder as well as the file sym2Int.m should be placed in a directory visible to Mathematica. A good place to place them is in

Linux, Mac OS
Windows

That's it. To load Sym2Int, type in the front end

<<Sym2Int


fonseca@ipnp.mff.cuni.cz

## Defining a model

A model is defined by the following elements:

• A name;
• A gauge group;
• A list of fields.

For each of the fields, it is necessary to indicate the following (the order is important):

• A name;
• The gauge representation;
• The Lorentz representation: scalar ("S"), right/left-handed Weyl fermion("R"/"L"), vector ("V"), etc.);
• Whether it is a real ("R") or a complex ("C") field;
• Number of copies/flavors present in the model.

For example, consider the Standard Model:


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

fld1 = {"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};

GenerateListOfCouplings[SM];


The following table is then printed on the screen:

Now, a bit of semantics: I will consider that an operator is the class of all gauge and Lorentz invariant contractions of a given combination of fields. So, 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.

Setting this aside, the above table contains the following data:

• First column: just a number associated to each operator.
• Second column: the combination of fields which enter the interaction. "C" means that the fields is conjugated; "R" means that it is not.
• Third column: mass dimension of the operator.
• Forth column: is the combination of fields self conjugated?
• Fifth column: list of fields which appear more than once in the operator.
• Sixth column: contains information on the permutation symmetry and number of parameters associated to the operator. More precisely ...
• If there is any repeated field(s) in the operator, the first entry indicates what is the symmetry associated to a permutation of them.
• The next entry indicates the number of couplings/numbers needed per independent contraction of the gauge+Lorentz indices of the fields.
• The next entry indicates the number of independent contractions of the gauge+Lorentz indices of the fields.

Everything should be self-evident, with the exception of the last column perhaps, so let us look into it in more detail.

## The symmetry column

Consider line #5 which corresponds to the Higgs quartic coupling in the Standard Model. In this operator, both H[C] and H[R] appear twice, hence one can ask what happens when we do permutations of the two H[C] fields, or permutations of the two H[R] fields. The answer given in the last column is that the gauge and Lorentz invariant contraction of the fields H[C]H[C]H[R]H[R] is symmetric both under the exchange of H[C]'s (first "S") as well as under the exchange of H[R]'s (second "S"). In other words, under the $S_2\times S_2$ permutation group this operator transforms under an {"S","S"} representation; the last "1" in {{"S","S"},1,1} indicates that there is just one such {"S","S"} representation. Now, in general fields may have one or more flavor, so one ask how many numbers/couplings are needed to fully parametrize an operator. In this case, given that H has a single flavor, for each {"S","S"} representation (and we have just seen that there is only one in this operator), the "1" in the middle of {{"S","S"},1,1} indicates that a single number is enough. (This number is real, given that the operator is self-conjugate.)

What is then the interpretation of the {9,1} in the last column of the second line? Clearly this line corresponds to the up-quark Yukawa interactions, where no field appears repeated, hence there is no permutation symmetry to consider. The 1 in {9,1} says that there is a single way to contract the gauge and Lorentz indices of the fields, and the 9 says that given the number of flavours of each field, nine numbers are necessary (for each gauge+Lorentz contraction of the indices which, again, is just one in this case). These 9 numbers are complex, given that the operator is not self-conjugate.

Consider now the Standard Model with an additional Higgs doublet (the Two Higgs Doublet Model). One way to specify it is simply by adding a 7th field:


fld1 = {"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 = {"H1", {1, 2, 1/2}, "S", "C", 1};
fld7 = {"H2", {1, 2, 1/2}, "S", "C", 1};
fields[TwoHDM] ^= {fld1, fld2, fld3, fld4, fld5, fld6, fld7};

GenerateListOfCouplings[TwoHDM];


The program prints the following:

There are scalar mass terms (operators #1, #2 and #3), Yukawa couplings (operators #4 to #9) and scalar quartic couplings (operators #10 to #15). Let us focus just on this last group of interactions: how many numbers/parameters are necessary to describe the scalar quartic interactions? We need in total $1+2+1=4$ real couplings for the self-conjugate operators #10, #13 and #15, plus $1+1+1=3$ complex couplings for the non-self-conjugate operators #11, #12 and #14. The grand total is then 10 real numbers. Note in particular that line #13 corresponds to the operator $H_2^* H_1 H^*_2 H_2$ and, according to the last column, there are two possible independent contractions of the gauge+Lorentz indices.

However, we could have chosen to tell the program that the second Higgs doublet is simply a second flavor of the Standard Model one:


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

fld1 = {"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", 2};
fields[TwoHDM] ^= {fld1, fld2, fld3, fld4, fld5, fld6};

GenerateListOfCouplings[TwoHDM];


One should get the same interactions as before, but in a different language:

In immediate reaction to the above result is that there are too few interactions, but in reality that is not the case. The first line says that 4 real numbers control the scalar masses, coinciding with the previous output which said that 2 real parameters + 1 complex one were required. The lines #2, #3 and #4 are the Yukawa interactions, and for each of these lines ...

• There are no permutation symmetries to consider;
• 18 (complex) numbers are needed to parametrize each Lorentz and gauge invariant contraction of the fields;
• There is just one Lorentz and gauge invariant contraction of the fields.
As for the last line (#5), it says that $9\times 1+1\times 1=10$ numbers are needed (real ones, since the operator is self-conjugate). This counting coincides with one we have seen above. But let us dig a little deeper into the meaning of the data in the last column of the last line. Since the two Higges are seens as 2 flavours of a single field $H$, one needs flavoured quartic couplings of the form $\lambda_{ijkl}$ as a prefactor to the each indepedent field product $H^*_i H^*_j H_k H_l$. However, note that even though $i,j,k,l=1,2$, it would be wrong to assume that there are $2^4=16$ real independent numbers in the tensor $\lambda_{ijkl}$. Indeed, what the "{{S,S},9,1} | {{A,A},1,1}" says is that one can break this $\lambda$ into two parts: $\lambda^{SS}_{ijkl}$ which is symmetric both under the exchange of indices $i \leftrightarrow j$ and the exchange $k \leftrightarrow l$, and $\lambda^{AA}_{ijkl}$ which is and anti-symmetric tensor under these permutations of indices. It is easy to check that these tensors have 9 ($\lambda^{SS}$) and 1 ($\lambda^{AA}$) independent entries, which is what the program says in the second entry of {{S,S},9,1} and of {{A,A},1,1}. The "1"'s in the third position of these two lists simply indicates that there is just one gauge+Lorentz contraction of the indices. But let us assume the fake scenario where the result was "{{S,S},9,2} | {{A,A},1,1}". Then we would need a total of $9\times 2+1=19$ real numbers: $V_{quartic}^{fake}=\lambda_{ijkl}^{SS}\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)+\lambda_{ijkl}^{\prime SS}\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)^{\prime}+\lambda_{ijkl}^{AA}\left(H_{i}^{*}H_{j}^{*}H_{k}H_{l}\right)^{\prime\prime}\,.$ (Primes distinguish the three field contractions of this fake scenario.)

Extra comment: Some operators might have more complex symmetries than simple S's and A's. (This is particularly true for non-renormalizable operators — see below.) Why is this? Well, if a fields appears not just once, but $n$ times in an operator, the relevant symmetry group associated to it is $S_n$. If $n=2$, we will see just S's and A's because the $S_2$ group only has two irreducible representations, which happen to be 1-dimension: the symmetric and anti-symmetric. However, starting with $S_3$ one can have mixed symmetries. Still, all one needs to know is that the irreducible representations (irreps) of $S_n$ can be labeled by the partitions of $n$. For example, the irreps of $S_4$ are {4}, {3,1}, {2,2}, {2,1,1}, {1,1,1,1} — the {4} is completely symmetric (S) and {1,1,1,1} is completely anti-symmetric (A). If an $S_n$ irrep is neither completely symmetric nor completely anti-symmetric, the program will just indicate the irrep by the corresponding partition of $n$.

## Gauge and Lorentz representations

Fields can be in any irreducible representation of the gauge and Lorentz groups.

The gauge representations for each simple factor group such as $SU(3)$ can be indicated by the representation's dimension D (e.g., 1, 3, 6, 8, ... in $SU(3)$) and -D if it is the anti-representation (e.g., -3, -6, ... in $SU(3)$). In those cases where two or more representations have the same dimensions (for example the 15 and 15' of $SU(3)$) one can use Dynkin coefficients, just like in the Susyno program . In the case of $U(1)$ factors, the program requires the charges of each field under them.

On the other hand, the Lorentz group is similar to a $SU(2)_L \times SU(2)_R$ group, and in particular it has irreducible representations which can be associated to two non-negative half-integers $j_L$ and $j_R$: $\left(j_{L},j_{R}\right)$. The program needs these numbers. Nevertheless, for the common cases of {0,0} (a scalar), {1/2,0} (a left-handed Weyl spinor), {0,1/2} (a right-handed Weyl spinor) and {1/2,1/2} (a 4-vector), the user can simply type "S", "L", "R" and "V", respectively.

For example, consider a model with $n$ vectors and $m$ left-handed spinors (both with null charge under a $U(1)$ gauge group):


gaugeGroup[modelA] ^= {U1};

fld1 = {"A", {0}, "V", "R", n};
fld2 = {"Psi", {0}, "L", "C", m};
fields[modelA] ^= {fld1, fld2};

GenerateListOfCouplings[modelA];


Notice the presence of a mixed symmetry {2,2} in the quartic vector operator. Despite the complexity of the parameter counting, a simple sum of the expressions in the last column of line #4 reveals that $\frac{1}{6} n^2 \left(n^2+5\right)$ real numbers are needed to encode the quartic interactions of the $n$ vector fields.

Extra comment: Gauge bosons are special vector fields, and the current version of Sym2Int cannot be used to reliably give a list of gauge boson interactions. That is because gauge bosons transform in a slightly different way than would a normal vector field in the adjoint representation of the gauge group. Indeed, under a gauge transformation controlled by the real parameters $\theta_{a}$, the gauge fields changes according to the formula ($C_{abc}$ are the group structure constants)

$A_{\mu}^{a}\rightarrow A_{\mu}^{\prime a}=A_{\mu}^{a}+C_{abc}\theta^{b}A_{\mu}^{c}-g^{-1}\partial_{\mu}\theta^{a}\,.$

The last term, $-g^{-1}\partial_{\mu}\theta^{a}$, is specific to gauge bosons. So gauge interactions are more constrained that those of a normal vector field, hence Sym2Int can at most be used to extract a maximum list of potential interactions of gauge fields. With derivatives the problem is similar: $\partial_{\mu}$ is a vector under the Lorentz group, and transforms similiarly, but not exactly, as a gauge singlet.

An added complication with gauge fields and derivatives is that some terms/operators might be redundant.

## Higher order, non-renormalizable terms

The program is not limited to the calculation of renormalizable interactions; it can calculate effective couplings to an arbitrarily large order. Note, however, that there will not include terms with derivatives nor terms with gauge bosons. Also, one should keep in mind that the computational time increases rapidly for higher dimensional terms (this is mainly due to the calculation of the permutation symmetries).

For example, the SM interactions up to dimension 6 that do not contain derivatives nor gauge bosons can be obtained as follows:


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

fld1 = {"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};

GenerateListOfCouplings[SM, MaxOrder -> 6];


This output is in agreement with the results in the paper B. Grzadkowski et al., JHEP 1010 (2010) 085 (the 'GIMR paper' henceforth) . Indeed, the situation is as follows:

• Operators #1 to #5 are the renormalizable ones.
• Operator #6 is well known for generating neutrino masses.
• Operators #7 to #28 involve four fermions, and correspond to those in table 3 of the GIMR paper. Take for example line #28, which corresponds to the $Q^{prst}_{\ell\ell}=\left(\overline{\ell}_{p}\gamma_{\mu}\ell_{r}\right)\left(\overline{\ell}_{s}\gamma^{\mu}\ell_{t}\right)$ operator in the language of the GIMR paper ($p,r,s,t=1,2,3$ are flavor indices). The number of independent entries of the $Q^{prst}_{\ell\ell}$ is not $3^4=81$ because, as indicated in line #28, this tensor can be split into a part which is symmetry both under an exchange of (ps) and (rt), and a part which is anti-symmetric under these exchanges of indices. Hence, the correct number of independent entries of the $Q^{prst}_{\ell\ell}$ is $36+9=45$. Now consider line #23: it indicates that there are 2 distinct ways of contracting the gauge+Lorentz indices of $Q^*Q^*QQ$, symmetric under the permutation of the $Q^*$s and $Q$s, and 2 other distinct ways of contracting the gauge+Lorentz indices in an anti-symmetric fashion. A total of $36\times 2+9\times 2=90$ parameters are required. Crucially, one cannot rely on a single tensor such as $Q^{(1)prst}_{qq}=\left(\overline{Q}_{p}\gamma_{\mu}Q_{r}\right)\left(\overline{Q}_{s}\gamma^{\mu}Q_{t}\right)$ because, by (anti)symmetrization of its indices we get just one symmetric part and one anti-symmetric part. But two are needed, hence $Q_{qq}^{(3)prst}=\left(\overline{Q}_{p}\gamma_{\mu}\tau^{I}Q_{r}\right)\left(\overline{Q}_{s}\gamma^{\mu}\tau^{I}Q_{t}\right)$ must be introduced as well in the effective Lagrangian.
• Operators #29, #30, #30 and #31 correspond to $Q_{u\varphi}$, $Q_{d\varphi}$, $Q_{e\varphi}$ and $Q_{\varphi}$.
All remaining interactions in the GIMR paper involve either derivatives of fields or gauge bosons.

## More examples

### A Left-Right model ($SU(3)_C\times SU(2)_L \times SU(2)_R \times U(1)_{B-L}$ gauge group)

Consider the LR model with the following representations. Fermions (all taken to be left-handed Weyl spinors) are distributed across three copies of the representations $Q=\left(\mathbf{3},\mathbf{2},\mathbf{1},1/3\right)$ and $Q^c=\left(\overline{\mathbf{3}},\mathbf{1},\mathbf{2},-1/3\right)$, $L=\left(\mathbf{1},\mathbf{2},\mathbf{1},-1\right)$ and $L^{c}=\left(\mathbf{1},\mathbf{1},\mathbf{2},1\right)$. The scalar sector is composed of the fields $\Phi=\left(\mathbf{1},\mathbf{2},\mathbf{2},0\right)$, $\Delta_{L}=\left(\mathbf{1},\mathbf{3},\mathbf{1},2\right)$ and $\Delta_{R}=\left(\mathbf{1},\mathbf{1},\mathbf{3},-2\right)$.


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

fld1 = {"Q", {3, 2, 1, 1/3}, "L", "C", 3};
fld2 = {"Qc", {-3, 1, 2, -1/3}, "L", "C", 3};
fld3 = {"L", {1, 2, 1, -1}, "L", "C", 3};
fld4 = {"Lc", {1, 1, 2, 1}, "L", "C", 3};
fld5 = {"Phi", {1, 2, 2, 0}, "S", "R", 1};
fld6 = {"D", {1, 3, 1, 2}, "S", "C", 1};
fld7 = {"Dc", {1, 1, 3, -2}, "S", "C", 1};
fields[LR] ^= {fld1, fld2, fld3, fld4, fld5, fld6, fld7};

GenerateListOfCouplings[LR];


### An $SU(5)$ model


gaugeGroup[modelSU5] ^= {SU5};

fld1 = {"F", {-5}, "L", "C", 3};
fld2 = {"T", {10}, "L", "C", 3};
fld3 = {"5", {5}, "S", "C", 1};
fld4 = {"24", {24}, "S", "R", 1};
fields[modelSU5] ^= {fld1, fld2, fld3, fld4};

GenerateListOfCouplings[modelSU5];


### The Pisano-Pleitez-Frampton model ($SU(3)_C \times SU(3)_L \times U(1)_X$ gauge group)


gaugeGroup[PPF331Model] ^= {SU3, SU3, U1};

Psil = {"Psil", {1, 3, 0}, "L", "C", 3};
Q23L = {"Q23L", {3, -3, -1/3}, "L", "C", 2};
Q1L = {"Q1L", {3, 3, 2/3}, "L", "C", 1};
uc = {"uc", {-3, 1, -2/3}, "L", "C", 3};
dc = {"dc", {-3, 1, 1/3}, "L", "C", 3};
J12 = {"J12", {-3, 1, 4/3}, "L", "C", 1};
J3 = {"J3", {-3, 1, -5/3}, "L", "C", 2};

Chi = {"Chi", {1, 3, -1}, "S", "C", 1};
Eta = {"Eta", {1, 3, 0}, "S", "C", 1};
Rho = {"Rho", {1, 3, 1}, "S", "C", 1};

fields[PPF331Model] ^= {Psil, Q23L, Q1L, uc, dc, J12, J3, Chi, Eta, Rho};

GenerateListOfCouplings[PPF331Model];


## Details and extra options

There are some optional parameters which can be used to change the program's behaviour.

At the moment Sym2Int has a limited capacity do deal with discrete symmetries (future versions will probably extend this part of the code). In particular, the program can only handle abelian discrete symmetries which commute with the gauge group. These symmetries associate to each field a (multiplicatively) conserved charge, which should be provided as follows:


GenerateListOfCouplings[<model>, DiscreteSym->{<charge of field #1>,
<charge of field #2>, ...}];


Each charge is a complex number (with modulus 1) associated to a $Z_n$ symmetry, or a list of such numbers, in case there are multiple $Z_{n_i}$ symmetries.

### - Suppress on-screen printing of output

The option


GenerateListOfCouplings[<model>, Verbose->False];


can be used to force the program to perform the calculation silently, in which case one should save the results of GenerateListOfCouplings to some variable (more details are given in the next section).

### - Show hermitian conjugated terms

By default, if $\mathcal{O}$ is an operator which is not self conjugate, then only $\mathcal{O}$ or $\mathcal{O}^*$ is shown. The following code can be used to obtain both $\mathcal{O}$ and $\mathcal{O}^*$ in the results:


GenerateListOfCouplings[<model>, HCTerms->True];


### - Suppress permutation symmetry information

Calculating the permutation symmetry information contained in the last column (see above) can be time consuming. The user may want to speed up things by switching off the computation of this information:


GenerateListOfCouplings[<model>, CalculateSnSymmetries->False];


However, note that the permutation symmetry can be very important. Without calculating it, the program will only check if the gauge quantum number allow, or not, a given operator. However, it might happen that due to some (uncomputed) permutation anti-symmetry, some terms are actually unrealizable (e.g.: three $SU(3)$ scalar triplets may form a trinear interaction, but only if there are more than 2 of them due to the anti-symmetric contraction of triplets).

## Saving the output for further processing

We have seen above that the program prints a table with the results. However, in many cases, one would also like to have this data in a format suitable for further processing. Such data can indeed be obtained by just saving the output of the GenerateListOfCouplings function, which returns a list containing information related to each operator. For each item in the list, corresponding to some operator, the following information is provided:

1. The number associated to the operator.
2. The combination of fields which enter the interaction. 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. Mass dimension of the operator.
4. Is the combination of fields self conjugated?
5. List of fields which appear more than once in the operator (the identification of each field is done as in 2.).
6. Information on the permutation symmetry and number of parameters associated to the operator.
7. Provides information on the explicit expression(s) of the gauge+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 Lagragian. See below for details. [Requires the use of the option CalculateInvariants->True; otherwise this slot in the list will contain the 'Null' value]
8. Contains the exact same data/format/style as the relevant row of the table printed by the GenerateListOfCouplings.

Perhaps it is easier to follow what is going on with an example (the Standard Model again):


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

fld1 = {"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};

operatorsDim4 = GenerateListOfCouplings[SM];
operatorsDim6 = GenerateListOfCouplings[SM, MaxOrder -> 6];


Note that, unlike all previous examples, now the results are being saved to the variables operatorsDim4 and operatorsDim6. We can get a quick glance at what information is in operatorsDim4, for example, by making a grid:


Grid[operatorsDim4, Frame -> All]


For instance, the second row, second column reads {-1,3,6} because the u, Q, H fields are involved (these are the fields #1, #3 and #6 in the input list), and u is conjugated (hence the -1 instead of 1). Note that the seventh column is empty because the option "CalculateInvariants -> True" was not used (see below). Finally, note also that in the last row, column 6, there is a {{2},{2}} permutation symmetry: it stands for the trivial/symmetric $S_2 \times S_2$ irreducible representation (see section "The 'Symmetry and number of parameters' column" above).

In the example above, operatorsDim6 contains the SM operators up to dimension 6 (excluding those with gauge bosons and/or derivatives). We may write a small code which picks out the position of those operators which violate lepton number, and baryon number:


lViolatingOps =
Flatten[Position[operatorsDim6[[All, 2]],
x_ /; Count[x, 4] + Count[x, 5] - Count[x, -4] - Count[x, -5] !=
0]];
SellectLines[lViolatingOps]
bViolatingOps =
Flatten[Position[operatorsDim6[[All, 2]],
x_ /; Count[x, 1] + Count[x, 2] + Count[x, 3] - Count[x, -1] -
Count[x, -2] - Count[x, -3] != 0]];
SellectLines[bViolatingOps]


The following two table are printed by the program (they list the lepton number and baryon number violating operators):

The function SellectLines used here is part of Sym2Int: it allows the user to selectively print just some of the operators of the last model which was processed with GenerateListOfCouplings. For example, SellectLines[{3,4,10}] will print only operators #3, #4 and #10 of the last model processed with the GenerateListOfCouplings function.

## Explicit expressions for the operators

Besides listing/counting the various ways in which the fields can interact, Sym2Int can call automatically the relevant Susyno code and calculate the explicit gauge and Lorentz invariant contractions of the fields (see ). However, to speed up the calculations, this is not done by default, hence the user must use the "CalculateInvariants -> True" option. As explained in the previous section, this information can then be retrieved from the output of GenerateListOfCouplings.

Consider once more the Standard Model:


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

fld1 = {"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};

operatorsDim4 = GenerateListOfCouplings[SM,CalculateInvariants -> True];


The variable operatorsDim4 will contain a list {op1,op2,...}, where the 7th position of each opN is what we are looking for. For example, take the trivial case of the Higgs mass term (operator #1):


operatorsDim4[[1, 7]]

The first part is a tensor with three indices:
• The first index goes over all the different independent gauge and Lorentz invariant contractions of the fields. In the case of $H^* H$ there is just one, hence this index goes from 1 to 1.
• The following two indices multiply the components of H[C] and H[R]. Since the Higgs field has 2 components in total these indices go from 1 to 2.

Indeed, in general one has as series of fields $F^{(1)}$, ..., $F^{(n)}$ being multiplied, and they may be contracted as $c^A_{i_1 i_2 ... i_n}$ $F_{i_1}^{(1)}$, ... $F_{i_n}^{(n)}$ for $A=1,...,m$ where $m$ is the number of independent gauge and Lorentz invariant contractions of these fields. The program returns precisely this tensor $c^A_{i_1 i_2 ... i_n}$ with $n+1$ indices.

Each field is assumed to have only a single index which condenses all information on both the gauge components and Lorentz components of the field. It works in the following straightforward way: assuming that the gauge group is $G$, then the full gauge+Lorentz group is assumed to be $G \times SU(2)_{sp,L} \times SU(2)_{sp,R}$, so the components of, say, the left-handed quark representation of the SM are Q[<color=1,2,3>,<isospin=1,2>,<Weyl SU(2)_L index=1,2>,<Weyl SU(2)_R index=1>] (note that for $U(1)$'s no index is used). Hence we have twelve components: Q[1,1,1,1], Q[1,1,2,1], Q[1,2,1,1], Q[1,2,2,1], Q[2,1,1,1], Q[2,1,2,1], Q[2,2,1,1], Q[2,2,2,1], Q[3,1,1,1], Q[3,1,2,1], Q[3,2,1,1], Q[3,2,2,1]. Going back to our example (the Higgs mass operator), we have for the Higgs field the components H[1,1,1,1] and H[1,2,1,1] (or HC[1,1,1,1] and HC[1,2,1,1] for the Higgs field conjugated; in general the program adds a "C" to the field's name). These components are shown in the second part of the above output.

For the Higgs mass, we know that $c^1_{i_1 i_2}$ should be proportional to $\delta_{i_1 i_2}$ and indeed that is the case:


MatrixForm /@ operatorsDim4[[1, 7, 1]]


To contract the tensor with the fields, one can do as following:


inv = operatorsDim4[[1, 7]];
Fold[Dot, inv[[1]], Reverse[inv[[2]]]]


One more example — the lepton Yukawa coupling (operator #4):


inv = operatorsDim4[[4, 7]];
Fold[Dot, inv[[1]], Reverse[inv[[2]]]]


In general, these explicit expressions depend on the basis chosen for the gauge representation matrices and for the Lorentz representation matrices. Concerning the gauge basis see ; as for the basis for Lorentz representations, one can make a simple toy model without a gauge group and check how the contractions $\psi_L \psi_L$ and $\psi^*_L \psi_L V_\mu$ are done:


gaugeGroup[testModel] ^= {};

fermion = {"psi", {}, "L", "C", 1};
vector = {"V", {}, "V", "R", 1};
fields[testModel] ^= {fermion, vector};

result = GenerateListOfCouplings[testModel,
CalculateInvariants -> True];

{MatrixForm /@ #[[1]], #[[2]]} &@result[[2, 7]]
result[[3, 7, 1, 1]].result[[3, 7, 2, 3]] // MatrixForm
`

In particular, the last two lines of the output imply that the indices contract as follows: $-\psi_{L}^{T}\epsilon\psi_{L}\;\;\textrm{ and }\;\;\psi_{L}^{\dagger}\left(\begin{array}{cc} V_{11} & V_{21}\\ V_{12} & V_{22} \end{array}\right)\epsilon\psi_{L}$ Here, $\epsilon$ is the usual anti-symmetric tensor with $\epsilon_{11}=\epsilon_{22}=0$ and $\epsilon_{12}=1$. Note also that the four components of a vector are labelled not by a $\mu=1,2,3,4$ but instead by two integers $\left(j_{L},j_{R}\right)=(1,1),(1,2),(2,1),(2,2)$ (this is because a vector is treated as a bi-doublet of $SU(2)_L\times SU(2)_R$).

Author
Renato Fonseca

Emails
renatofonseca@gmail.com
or
fonseca@ipnp.mff.cuni.cz

Last updated
21 November 2018