minimal-lagrangians: Generating and studying dark matter model Lagrangians with just the particle content

The program minimal-lagrangians is able to generate the most general renormalizable Lagrangian describing certain classes of extensions of the Standard Model (SM) of particle physics in a fully automatic fashion, with several different output formats, requiring only the model’s field content to do so. As the program was originally written for the study of minimal dark matter models with radiative neutrino masses [1], it can handle fields beyond the Standard Model (BSM) with the following properties:

• 1.

  scalar or fermion fields¹¹1Fermions are always defined in terms of Weyl spinors, cf. A.

• 2.

  $\operatorname{SU}(3)$ singlets

• 3.

  $\operatorname{SU}(2)$ singlets, doublets or triplets

• 4.

  arbitrary $\operatorname{U}(1)$ hypercharge

• 5.

  charged under an arbitrary number of global $\operatorname{U}(1)$ symmetries (with $\mathbb{Z}_{2}$ as a special case)

minimal-lagrangians originated as an effort to study the minimal dark matter models with radiative neutrino masses introduced in [2] in a general way. A missing piece in [2] are the Lagrangians for the individual models, which are only specified via the field content for each model.

While it is a manageable task for someone experienced in building particle physics models to construct the Lagrangian for such a model manually, this process can be error-prone and time-consuming – not only because all possible terms must be enumerated without omissions, but especially when taking into account gauge anomalies and various identities for the possible terms (cf. C). Moreover, since the symmetry groups and the kinds of representations used in these models are limited and fixed, it is quite feasible to exhaustively list all the terms that could potentially appear in such a Lagrangian in full generality in an automated fashion. The models are thus checked for gauge anomalies, including the Witten $\operatorname{SU}(2)$ anomaly [3], which are avoided by introducing vector-like fermions if necessary. Redundant terms are omitted using the identities in C. Even for manually-constructed Lagrangians, minimal-lagrangians can still serve as a useful cross-check in order to verify that there are neither too few (forgotten) nor too many (redundant) terms.

In addition, model files for SARAH [4, 5] can be constructed automatically from the specified field content, which can be tedious if done manually. Thus, minimal-lagrangians enables rapid phenomenological studies using SARAH and, successively, further tools like SPheno [6, 7] and micrOMEGAs [8, 9].

For a typical number of fields, which is small in most models ($<10$), the program’s execution time should be of the order of one second or less on any hardware in current use.

minimal-lagrangians is available on the Python Package Index (PyPI) at https://pypi.org/project/minimal-lagrangians. Therefore, the simplest method to obtain and install the program files is to use the pip package manager. Provided that pip is set up on the machine, running

on the command line should be all that is necessary to install minimal-lagrangians.

Further development of the program is tracked using the git version control system. The most recent development snapshot is available at https://gitlab.com/Socob/minimal-lagrangians. Bugs or other issues should be reported there as well.

The program is written using the Python 3 programming language and should run using Python versions $\geq 3.4$. It can be run on any system which Python is available for. Apart from that, there are no external dependencies.

The program only prints the potential involving at least one new (i. e. non-SM) field, that is, the Standard Model Lagrangian $\mathcal{L}_{{\operatorfont SM}}$ and the kinetic terms $\mathcal{L}_{{\operatorfont kin}}$ (which always have the same form) are omitted. Explicitly, given a Lagrangian $\mathcal{L}$ of the form

minimal-lagrangians will output the most general renormalizable BSM potential $V_{{\operatorfont BSM}}$. The mathematical notation in the program’s output is explained in A and B. As indicated in the program’s help message, the Lagrangian can be output in three different formats, which are described in the following.

Two models will be illustrated as examples in the following subsections: the model T1-1-A with $\alpha=0$ from [2] (also studied in [12]), and the singlet–triplet scalar model (“model C”) from [13].⁴⁴4As mentioned before, minimal-lagrangians makes use of a number of identities (C) in order to eliminate redundant parameters from the Lagrangian. Since it has to make a particular and consistent choice about which terms to eliminate, some of the examples shown in this section do not exactly match the form given in the corresponding references. However, it can easily be verified that the generated Lagrangians are completely equivalent. They are defined as follows:

The way in which fields, terms and the Lagrangian as a whole are represented internally in minimal-lagrangians is very straightforward and simplistic. Fields are objects whose properties are their mathematical symbol and their quantum numbers:

• 1.

  type: scalar or fermion;

• 2.

  su2_multiplicity: the dimension of their representation under the gauge group $\operatorname{SU}(2)_{{\operatorfont L}}$ – the values $1$, $2$ and $3$ (singlets, doublets and triplets) are supported;

• 3.

  hypercharge: the charge under the gauge group $\operatorname{U}(1)_{{\operatorfont Y}}$;

• 4.

  z2: the parity ($\pm 1$) under the global $\mathbb{Z}_{2}$ symmetry;

• 5.

  (optional) u1: the list of charges under the $N$ global $\operatorname{U}(1)$ symmetries.

Terms are then essentially lists of such field objects, with code in place to ensure a consistent order and grouping of fields within a term. A Lagrangian is then an (ordered) set of such terms.

An alternative to this very basic approach could have been to adapt a symbolic computation package with some additional rules for equivalence of terms, ordering and output formatting. However, for the Lagrangian of a minimal model, the only required operations are multiplication of fields and addition of terms, where the latter is even not really needed because none of the terms of the final Lagrangian can be simplified by addition. Consequently, a symbolic computation package would not have made the implementation much easier beyond providing the commutative property $\phi_{1}\phi_{2}=\phi_{2}\phi_{1}$ in a product. On the other hand, adapting an existing library for a purpose such as this, which it was not designed for, would take a significant amount of effort.

In a sense, minimal-lagrangians works at a higher level of abstraction – it does not think in terms of individual variables in a product, but really only cares about the terms as a whole. No operations are performed on these terms and the desired concept of “equality” of terms is not a precise one down to each constant factor, because these just affect the arbitrary definition of each term’s coupling parameter. Such details are of no interest for the program’s purpose, rather complicating the decision of whether two terms should be treated as equal. Only if integration with other symbolic computation tools is desired would it be useful to investigate whether employing such a package as a lower-level component is worthwhile.

The main component implementing the generation of all possible gauge- and Lorentz-invariant terms is the method BSMModel.lagrangian, along with the methods is_valid, generate_terms and filter_terms_identities of the Model class, which it uses to construct the Lagrangian. The method BSMModel.lagrangian works as follows: First, a list containing all of the model’s fields and their adjoints is created. Then, all the possibilities of combining $n$ of these fields ($2\leq n\leq 4$) are enumerated. For example, given two real fields $\phi_{1}$ and $\phi_{2}$, this list would contain the combinations $(\phi_{1}\phi_{1}\phi_{1},\phi_{1}\phi_{1}\phi_{2},\phi_{1}\phi_{2}\phi_{2},\phi_{2}\phi_{2}\phi_{2})$ for $n=3$. Note that the order of the fields does not matter. However, only those combinations which can be used to form invariant terms at all are kept as candidates.

The check whether such a combination of fields can yield invariant terms is done by Model.is_valid. Making use of formalisms for Weyl spinors and $\operatorname{SU}(2)$ multiplets (see B), it is simple to determine whether this is the case: Every lowered index must appear in a sum with a raised index of the same kind. Since fermion fields have mass dimension $\mathsf{M}^{\nicefrac{{3}}{{2}}}$, there can be at most two of them in a renormalizable term in any case, so this reduces to a check that they are both either left-handed or conjugate left-handed (i. e. right-handed) spinors. In general, though, the number of indices must be even for each kind of index. For $\operatorname{SU}(2)$, an $n$-plet has $n-1$ indices, so the sum $\sum_{i}(n_{i}-1)$ must be an even number. For the abelian groups ($\operatorname{U}(1)$, $\mathbb{Z}_{2}$), the sum of each kind of charge must be zero: $\sum_{i}q_{i}=0$. Alternatively, since the value of the “parity group” $\mathbb{Z}_{2}$ is usually given as $p_{i}=e^{iq_{i}}=\pm 1$ (“even/odd”), the product of all $\mathbb{Z}_{2}$ values must be one: $\prod_{i}p_{i}=1$.

All the combinations of fields which are identified as potentially valid are then given to Model.generate_terms. This method contains the algorithm to determine, given an arbitrary collection of fields, what terms involving this specific combination must be added to the Lagrangian. As mentioned before, Lorentz invariance is easy to obtain since the combination of fields will either contain no or two Weyl spinors, and in both cases there is only one way to match up the spinor indices. For gauge and global invariance, $\operatorname{SU}(2)_{{\operatorfont L}}$, as the only non-abelian group, is the only one which could couple the fields in non-trivial ways. Invariance under the abelian groups is automatically ensured because the charges were checked in the previous step. In any case, a term is either not or automatically invariant under abelian groups – there is only one way to couple the fields. Finally, Model.filter_terms_identities determines if a term can be omitted due to the identities in C.

To recap, only three different representations of $\operatorname{SU}(2)$ are used in the considered models (singlets, doublets and triplets). Furthermore, the restriction to renormalizable Lagrangians limits the Lorentz structure of terms to the possibilities listed in table 1. Together, these assumptions ensure that there is only a finite number of different types of terms, so that the easiest way to enumerate all the possible terms for a given set of fields is to simply go through all the different cases.

As mentioned before, minimal-lagrangians adds another piece to a tool chain formed from existing particle physics code, allowing one to automate most of the model implementation starting just with a model’s field content.

An illustration of how a model is implemented and analyzed using these tools is shown in fig. 1. At the beginning, the model’s field content is defined in data.py (or the user-supplied model file), as explained in section 3.2. minimal-lagrangians can then be used to generate model files for SARAH containing the most general renormalizable Lagrangian, as well as the definitions for potential VEVs or mixing of the fields after electroweak symmetry breaking. Since SARAH has a great number of features, it can sometimes be necessary or desirable to make some changes or additions to the generated model files. With this potentially modified set of model files, SARAH can be used to generate both the SPheno code and model files for micrOMEGAs.

At this point, the implementation of the model is already complete. The generated code can be compiled and used to perform numerical calculations. SPheno takes a file in the SUSY Les Houches Accord (SLHA) format [15, 16] as input. In this file, the input parameters are provided and a number of settings (for example, which file formats are output, whether some calculations should be disabled and what conventions are used) can be customized. SARAH provides a template for this input file. Running SPheno then produces a spectrum file, also in SLHA format. It contains the mass spectrum (including the mixing matrices) for the specified parameter point as well as lepton and quark flavor violation observables, some observables like $g-2$ and (if enabled) branching ratios for particle decays. In turn, this spectrum file can be used as an input to micrOMEGAs, which extracts the mass spectrum and uses it to perform the calculation of dark matter observables.

minimal-lagrangians contains a comprehensive test suite, which can be run using the test.py file contained within the program package. Among other checks, this tests whether the program produces the correct Lagrangian for the following models, which have been compared with the literature:

• 1.

  T1-3-B with $\alpha = 0$, which is studied in [11].

• 2.

  T1-1-A with $\alpha = 0$, as given in [12] (which presents an implementation of this model).

• 3.

  The simplified dark matter models given in [13]:

  • (a)

    the singlet–doublet fermion model (SDF, “model A”);

  • (b)

    the singlet–doublet scalar model (SDS, “model B”);

  • (c)

    the singlet–triplet scalar model (STS, “model C”).

• 4.

  The seesaw mechanism type II, also called the Higgs triplet model (see e. g. [17]).

Additionally, it has been verified manually that the generated output is correct for a variety of different models, in particular for the seesaw mechanisms of types I and III, and the model T1-2-A ($\alpha=0$) studied in [18].

minimal-lagrangians will hopefully prove to be a useful tool both in accelerating phenomenological model building studies and providing automated, computer-assisted verification. There are currently some restrictions to specific cases which could be generalized in the future. The main limitation is the size of the $\operatorname{SU}(2)$ representation, which cannot be larger than triplets. The generalization to arbitrary representations would require a change in approach from a static list of conditions. Moreover, the code currently only handles the Standard Model gauge group, so it is not possible to use models with new gauge fields. The ultimate generalization would then be to not only handle representations of $\operatorname{SU}(2)$, but of arbitrary $\operatorname{SU}(N)$ gauge groups. This would additionally require a general condition for the cancellation of gauge anomalies.

This program resulted from work as part of the author’s master’s thesis at the Institute of Theoretical Physics at WWU Münster under the supervision of Michael Klasen. My thanks extend to Michael Klasen for his guidance and valuable input on the manuscript as well as program features, and Karol Kovařík and Sonja Esch for many enlightening discussions during that time.