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 (

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 .

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`
```

For questions, comments or bug reports, please contact me at
fonseca@ipnp.mff.cuni.cz

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.

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.

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

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.

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

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

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}$.

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];
```

```
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];
```

```
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];
```

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

At the moment

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

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

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];
```

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

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:

- The number associated to the operator.
- 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).
- Mass dimension of the operator.
- Is the combination of fields self conjugated?
- List of fields which appear more than once in the operator (the identification of each field is done as in 2.).
- Information on the permutation symmetry and number of parameters associated to the operator.
- 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]
- 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

Besides listing/counting the various ways in which the fields can interact,

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 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$).

Renato Fonseca

renatofonseca@gmail.com

or

fonseca@ipnp.mff.cuni.cz

21 November 2018