The Standard Model Effective Field Theory Toolkit

We present DsixTools, a Mathematica package for the handling of the dimension-six Standard Model Effective Field Theory. Among other features, DsixTools allows the user to perform the full one-loop Renormalization Group Evolution of the Wilson coefficients in the Warsaw basis. This is achieved thanks to the SMEFTrunner module, which implements the full one-loop anomalous dimension matrix previously derived in the literature. In addition, DsixTools also contains modules devoted to the matching to the ∆B = ∆S = 1,2 and ∆B = ∆C = 1 operators of the Weak Effective Theory at the electroweak scale, and their QCD and QED Renormalization Group Evolution below the electroweak scale. aEmail: Alejandro.Celis@physik.uni-muenchen.de bEmail: Javier.Fuentes@ific.uv.es cEmail: Avelino.Vicente@ific.uv.es dEmail: jvirto@mit.edu ar X iv :1 70 4. 04 50 4v 3 [ he pph ] 2 1 Ju n 20 17


Introduction
The experimental success of the Standard Model (SM) of particle physics and the absence of new physics (NP) signals so far seem to hint at the presence of a mass gap between the SM degrees of freedom and the new dynamics. In this case, departures from the SM at energies much smaller than the new physics scale can be described using effective field theory (EFT) methods. The so-called Standard Model EFT (SMEFT) parametrizes possible deviations from the SM caused by heavy degrees of freedom in a model independent way.
The SMEFT Lagrangian is organized as an expansion in powers of 1/Λ, where Λ represents the new physics scale and compensates the canonical dimension of the effective operators. The leading order of the SMEFT corresponds to the renormalizable SM Lagrangian. Dominant new physics contributions to most processes of interest are expected to be encoded in the Wilson Coefficients (WC) of effective operators of canonical dimension six [1].
In recent years, a non-redundant basis for the dimension-six SMEFT operators was derived [2]. This basis is currently known as the Warsaw basis. The complete one-loop anomalous dimension matrix (ADM) for the dimension-six operators has been calculated very recently in this basis [3][4][5][6]. These advances, together with simultaneous theoretical developments occurring in the field (such as in the matching of specific models to the SMEFT at one loop [7-12, 14, 15] and in the automatization of calculations within the SMEFT [13]), pave the way to the systematic use of EFT methods in the analysis of new physics models. The power of the SMEFT approach is that it allows to relate physics at disparate energy scales, in our case properties of the high-energy dynamics at the scale Λ, with measurements that take place at low energies, while performing an expansion in 1/Λ that allows to keep leading new physics effects in a consistent manner. Here we present DsixTools, a Mathematica 1 package that aims to facilitate such enterprise.
Given some initial conditions for the Warsaw basis at the high-energy scale Λ, obtained from the matching of a UV model to the SMEFT, DsixTools allows the user to perform the full oneloop Renormalization Group Evolution (RGE) down to the electroweak scale. Furthermore, when the physics of interest lies well below the electroweak scale, it is useful to perform a matching of the dimension-six basis to a low-energy EFT in the broken electroweak phase. In the so-called Weak Effective Theory (WET), the SM heavy degrees of freedom (top quark, Higgs, W ± and Z) have been integrated out. DsixTools implements the tree-level matching of the Warsaw basis to ∆B = ∆S = 1, 2 and ∆B = ∆C = 1 operators of the WET based on the results obtained in [17]. Last but not least, the relevant effects due to QCD and QED running from the electroweak scale down to the b-quark mass scale in the WET is also implemented in DsixTools, using the results in [18].
DsixTools is structured into different modules, each of them taking care of a specific task. Their functionality is described in Sec. 2. Sec. 3 explains how to download and load DsixTools whereas a detailed review of DsixTools and its modules is given in Sec. 4. A summary is given in Sec. 5. Finally, this manual includes several appendices to document all the features present in DsixTools: A contains details of the conventions used for the implementation of the SMEFT, B contains the SMEFT RGEs, C describes relevant aspects of the WET, D contains a detailed description of the DsixTools routines, E is devoted to compile the SMEFT and WET parameters list and F gives results for the Baryon-number-violating operators in the fermion mass basis. The EWmatcher module implements: • The tree-level matching of the Warsaw basis to the ∆B = ∆S = 1, 2 and ∆B = ∆C = 1 operators of the WET at the electroweak scale, using the results in [17].
The WETrunner module implements: • QCD and QED RGEs in the WET from the electroweak scale down to the low-energy scale Λ IR . The WETrunner module fixes by default Λ IR = m b , the b-quark mass scale, and uses the RGEs derived in [18].
The functionality of the DsixTools modules is illustrated in Fig. 2, where one can also see how they relate to the different energy ranges and effective theories. Relevant details of the SMEFT and WET implementations are given in A to C, where our conventions are also presented.

Needs [ " DsixTools ' " ]
Alternatively, the user can place the DsixTools folder in a given directory and call the package by specifying its location via pathtoDsixTools = " < directory > " ; AppendTo [ $Path , pathtoDsixTools ]; before executing the Needs command. We also recommend to use

SetDirectory [ NotebookDirectory []];
at the beginning of all projects with DsixTools.

Using DsixTools
In this Section we describe how to use DsixTools in detail. Once the package has been loaded, the user can already execute some basic I/O functions and routines. Several global variables are also introduced at this stage. Here we list the general DsixTools routines: • LoadModule[moduleName]: Loads the DsixTools module moduleName.
• MyPrint[string]: Prints the message string. It can be switched on and off by using the DsixTools routines TurnOnMessages and TurnOffMessages.
• TurnOnMessages: Turns on the messages written by DsixTools.
• TurnOffMessages: Turns off the messages written by DsixTools.
• ReadInputFiles[options_file, WCsInput_file, {SMInput_file}]: Reads all the input files. The third argument is optional and should be absent when the routine is used to read WET input.
• WriteInputFiles[options_file, WCsInput_file, {SMInput_file},data]: Creates input files with the parameter values in data. The third argument is optional and should be absent when the routine is used to write WET input.
• WriteAndReadInputFiles[options_file,WCsInput_file,{SMInput_file}]: Writes data into new input files and then reads them. The third argument is optional and should be absent when the routine is used to write and read WET input.
• NewInput[parameter,newvalue,dispatch]: Replaces the current input (contained in the Mathematica dispatch dispatch) by a new one in which parameter takes the value newvalue. 3 • NewScale[scale,newvalue]: Replaces the current value of scale by newvalue. Here scale can be either "high" or "low".
• H[mat]: Returns the Hermitian conjugate of the matrix mat. If the option CPV has been set to 0 then it returns the transpose.
• CC[x]: Returns the complex conjugate of x. If the option CPV is set to 0 then it returns x.
A more detailed description of these DsixTools routines can be found in D.1. Once DsixTools is loaded the user can already perform some basic operations. However, the real power of DsixTools resides in its modules. A project with DsixTools can involve one or many modules, depending on the user's goals. For instance, if one is interested in the running of WET operators between the electroweak scale and the b-quark mass scale, the WETrunner module suffices for the task. But if one wants to study the RGE evolution of the SMEFT operators and their matching to WET ones at the electroweak scale, both the SMEFTrunner and EWmatcher modules must be included in the project. In the following we proceed to describe the existing modules, the routines they include and how they can be combined together in a practical DsixTools project.

SMEFTrunner module
The SMEFTrunner module takes care of the one-loop RGE of the SMEFT between the high-energy scale Λ and the electroweak scale. The module is based on the anomalous dimension matrices computed in [3][4][5] (for the Baryon-number-conserving operators) and [6] (for the Baryon-numberviolating operators). This is the list of routines implemented in this module: • InitializeSMEFTrunnerInput: Initializes the input for the SMEFTrunner module.
• FindParameterSMEFT[parameter]: Returns the position in which parameter is located within the Parameters list.
• LoadBetaFunctions: Constructs the SMEFT β functions or reads them from a file.
• ExportSMEFTrunner: Exports the SMEFTrunner results to an output file.
More details about these routines can be found in D.2. The general flowchart of the SMEFTrunner module can be seen in Fig. 3. The first step is to read the input. This not only includes the numerical values of the SMEFT WCs at the high-energy scale Λ, but also the numerical values of the SM parameters and some options. The input and output format of DsixTools is inspired by the Supersymmetry Les Houches Accord (SLHA) [24,25]. A complete options card would read: For this particular example we have chosen the default options. In fact, if a flag is not present in the options file, its value will be taken as in this example. The user defines the high-energy and electroweak scales in the first block. We see that in this example the electroweak scale is fixed to 80.385 GeV, the W -boson mass, whereas the high-energy scale is Λ = 10 TeV. Then the user defines several options. For instance, in this case CP-violation has been switched off by setting CPV to 0, but the user can also consider complex parameters setting CPV to 1. The comments accompanying the other options are self-explanatory, but we will review them below. A sample of a typical input card for the SM parameters is as follows:  (3 ,3) ...

The notation for the operators is self-explanatory:
BlockWC1 It is important to note that all WCs are assumed to vanish by default. Therefore, it suffices to include the non-zero WCs (and only these) in the input card. The rest can be absent. In addition to getting input values at Λ, the SMEFTrunner module constructs the SMEFT RGEs and prepares a routine for their evaluation. There are two ways to do this: (i) to "compute" the RGEs, or (ii) to read them from a file. In the first case, DsixTools takes their saved forms and computes all flavor traces and expands over all possible indices. In the second case, DsixTools simply reads them from a file (already present in the DsixTools folder). In both cases, the command to give this step is LoadBetaFunctions. The user can choose between these two methods in the options file using flag number 2. Method (i) is more time consuming but provides nice-looking β functions in Mathematica format. This would be very useful for analytical studies. Moreover, the user can obtain these equations at any moment by using the routine GetBeta. Method (ii) is much faster and produces the RGEs in the format required for their immediate evaluation with the SMEFTrunner routines (in particular with RunRGEsSMEFT).
Once both the initial conditions (input values at Λ) and the RGEs are completely built, the user can apply the RGE to obtain the goal of SMEFTrunner: the SMEFT WCs at the electroweak scale. This is done with the RunRGEsSMEFT routine. We have implemented two different methods for the resolution of the RGEs: • "Exact": This method applies the Mathematica internal command NDSolve for the numerical resolution of differential equations. Given the large number of differential equations involved in this case (several thousand), this might be time consuming, with each evaluation requiring a few (< 10) seconds, the exact number depending on the particular case and computer.
• First leading log: This approximate method might be sufficient for many phenomenological studies, in particular when Λ is not too far from the electroweak scale. The solution of the RGEs is obtained as where C i is any of the running parameters, µ is the renormalization scale and β i is the β function for the C i evaluated at µ = Λ. This method is much faster but neglects subleading effects.
The user chooses between these two methods by setting the global option RGEsMethod to 0 (for the NDSolve method) or 1 (for the first leading log approximate method). This is also done via flag number 3 in the options card. After running, the results are saved in the array outSMEFTrunner as a function of t = log 10 µ. The ordering of the parameters is the same as in the Parameters global array, see E. 5 Moreover, two important values of t are predefined: tLOW (= log 10 µ EW ) and tHIGH (= log 10 Λ). Therefore, for instance, one can obtain the value of the C eϕ 12 at the electroweak scale by evaluating Finally, the output of SMEFTrunner can be exported to a text file. This is done by running ExportSMEFTrunner. The file Output_SMEFTrunner.dat is then generated, also with an SLHA format, completely analogous to the SMEFT WCs input card.

EWmatcher module
The EWmatcher module applies the tree-level matching of the Warsaw basis of the SMEFT to the ∆B = ∆S = 1, 2 and ∆B = ∆C = 1 operators of the WET. For this purpose we make use of the analytical results obtained in [17]. This is the list of routines implemented in this module: • InitializeEWmatcherInput: Initializes the input for the EWmatcher module.
• FindParameterWET[parameter]: Returns the position where parameter is located within the WETParameters list.
• RotateToMassBasis: Transforms the SMEFT WCs to the fermion mass basis.
• Match[WC]: Returns the value of the WET Wilson coefficient WC after matching it to the SMEFT.
• MatchAnalytical[WC]: Returns the analytical expression of the WET Wilson coefficient WC after matching it to the SMEFT.
• ExportEWmatcher: exports the EWmatcher results to an output file.
Appendix D.3 contains more details about these routines and functions.
The EWmatcher module flowchart can be seen in Fig. 4. The first step is, as usual, to determine the input of the module. If the SMEFTrunner module has preceded the EWmatcher, the input is automatically created using the output of the former. Otherwise, the user can also provide an input file and start the DsixTools project with the EWmatcher module as first step.
In what concerns the input card, the same WCsInput.dat file that is read by the SMEFTrunner module can also be used as WCs input for the EWmatcher module. Instead of interpreting the input values as given at µ = Λ, the EWmatcher module will interpret them as given at µ = µ EW .
Next, the EWmatcher transforms the SMEFT WCs to the fermion mass basis, applying the required biunitary transformations to the fermion mass matrices. 6 This necessary step is done by means of the RotateToMassBasis routine and gives, as a result, the SMEFT WCs in the fermion mass basis, generally denoted as C i . 7 In case the user is particularly interested in these coefficients, they can be exported to an external text file by running

Wri teWCsMassBasisOutputFile [ Output_file ]
Furthermore, RotateToMassBasis also creates the replacements array ToMassBasis, which can be used to print the numerical values of the SMEFT WCs in the fermion mass basis. For example, LL [1 , 1 , 2 , 2]/. ToMassBasis would print the numerical value of the coefficient C 1122 . The next step is the matching to the WET operators. For this the user must execute

ApplyEWmatching
This creates the arrays BS2, BC1, BS1Hunprimed, BS1Hprimed, BS1GB, BS1SLunprimed and BS1SLprimed, containing the numerical values of the WET WCs at the electroweak scale. While BS2 and BC1 contain the results for the ∆B = ∆S = 2 and ∆B = ∆C = 1 coefficients, respectively, the other arrays contain the results for the ∆B = ∆S = 2 ones, split into several sub-arrays with hadronic (H), semileptonic (SL) and magnetic, or gauge boson (GB) involving, WCs. They can also be accessed individually thanks to the function Match. For example, CBS1[e] [1] // Match would print the numerical value of C bsee 1 . If one is interested in the analytical expression after matching the function to use is MatchAnalytical, which only replaces the energy scales and the SM parameters by their numerical values.
Finally, the output of EWmatcher can be exported to a text file. This is done by running ExportEWmatcher, which generates the file Output_EWmatcher.dat with a compilation of all results obtained with this module.

WETrunner module
The WETrunner module is devoted to the RGE of the WET WCs between the electroweak scale and the infrared scale Λ IR . In the current version of DsixTools, Λ IR is set by default at b-quark mass scale, m b = 4.18 GeV, and the RGE is based on the analytical results obtained in Ref. [18]. This is the list of routines implemented in this module: • InitializeWETrunnerInput: Initializes the input for the WETrunner module.
• ExportWETrunner: Exports the WETrunner results to an output file.
For more details about these routines see Appendix D.4.
The general flowchart of the WETrunner module can be seen in Fig. 5. As for the EWmatcher module, the input for the WETrunner can be obtained directly (and automatically) from the previous module (EWmatcher in this case) if this is run before. Otherwise, the user can also provide new input values and begin a DsixTools project in this step of the chain. In this case, the input card for the WET WCs, which we will call WCsInput.dat as for the SMEFT ones, also follows a simple SLHA-inspired format: We see that the first block gives the input value for the electroweak scale while the other blocks give the input values for the WET WCs. In this particular example the only non-vanishing WET WC is C sbsb 4 = 1. It is important to note, however, that DsixTools must know that the input WCs are of WET type. This is done via the option inputWCsType, which must be set to 2 (the default value is 1, which indicates SMEFT WCs) before reading the input file with the ReadInputFiles routine. This option choice can also be achieved by using the flag number 9 in the options card: Options.dat 9 2 # Type of input WCs : 1 ( SMEFT ) or 2 ( WET ) Once the input has been read (or taken from the EWmatcher module) one can proceed to the RGE of the WET WCs. The WETrunner module implements an evolution matrix formalism for this step, based on the results of Ref. [18]. This can be performed with the RunRGEsWET which creates the numerical arrays BS2Low, BC1Low, BS1unprimedLow and BS1primedLow, all of them functions of t = log 10 µ. Therefore, in order to find the values of the WET WCs at the b-quark mass scale one can evaluate commands like BS2Low [ [4]] /. t -> Log [10 , mb ] where mb is the global DsixTools variable containing the b-quark mass (in GeV). This command would print the numerical value of C sbsb 4 (m b ). Finally, the results can be exported to an output file with the routine ExportWETrunner. This creates the text file Output_WETrunner.dat with the values of all WET WCs at the infrared scale.

Summary
We have presented DsixTools, a Mathematica package for the handling of the dimension-six SMEFT and WET. DsixTools facilitates the treatment of these two effective theories in a systematic and complete manner.
DsixTools is a modular code. In the current version, it includes three independent modules, designed for specific tasks related to the SMEFT and WET. The SMEFTrunner performs the oneloop RGE from the UV scale Λ to the electroweak scale, the EWmatcher matches the SMEFT Wilson coefficients to the ∆B = ∆S = 1, 2 and ∆B = ∆C = 1 operators of the WET, and the WETrunner runs these down to an IR scale, in this case the b-quark mass scale.
The structure of DsixTools allows for an easy implementation of new modules. Therefore, the current content of the package is expected to grow substantially with future improvements, including additional tools and features. The final outcome of this endevour will be a complete and powerful framework for the systematic exploration of new physics models using the language of Effective Field Theories.

A Standard Model Effective Field Theory
The Lagrangian for the SMEFT can be written as Here Λ is the new physics scale suppressing higher dimensional operators, assumed to be much larger than the electroweak scale. There is only one operator of dimension five, the so-called Weinberg operator that gives a Majorana mass term for the neutrinos [26]. A non-redundant basis of dimension-six operators was introduced in [2] and is known as the Warsaw basis. We list these operators in Tables 2, 3 and 4. Barring flavor structure, and assuming Baryon number conservation, there are 59 operators, some of which are non-Hermitian, yielding in total 76 real coefficients. Taking into account flavour indices, the dimension-six Lagrangian contains 1350 CP-even and 1149 CP-odd operators, for a total of 2499 hermitian operators [5]. Finally, the complete set of independent dimension-6 Baryon number violating operators were identified in [27]. Barring flavor structure, there are only 4 Baryon-number-violating operators. These are listed in Table 5.
The implementation of the SMEFT in DsixTools follows the conventions used in [2]. 8 The SM renormalizable Lagrangian L (4) SM is given by where {g s , g, g } and {G,W, B} are, respectively, the SU(3) c , SU(2) L and U(1) Y gauge couplings and gauge fields. T A and T I are the corresponding gauge group generators. The hypercharge assignments for the matter fields are given in Table 1. DsixTools also implements the running of calculated in [3]. The dual tensors are defined as X = 1 2 ε µνρσ X ρσ (with ε 0123 = +1).

B SMEFT Renormalization Group Equations
At leading order, the RGEs governing the energy evolution of the SMEFT Wilson coefficients C i can be written as Here µ is the renormalization scale, γ is the anomalous dimensions matrix and β i are the β functions. The complete anomalous dimension matrix for the dimension-six SMEFT operators has been recently computed in [3][4][5][6]. We collect here the resulting β functions, adapted to our notation and conventions.
¯ j σ µν e ε jk q k σ µν u Table 5: Baryon-number-violating operators. We use C to denote the Dirac charge conjugation matrix. Baryon-number-violating First, we give some definitions that turn out to be useful in order to simplify the β functions: as well as and the wavefunction renormalization terms Finally we also use the following definitions Baryon-number-violating (B.79)

SM parameters
The RGEs for the SM parameters get also modified in the presence of the dim-6 operators. Using an analogous notation for their β functions dX dt ≡ 1 16π 2 β X .
(B.80) these are given by In the absence of contributions from the dim-6 operators one recovers the well-known SM RGEs [19][20][21][22]. Notice however that we do not include an SU(5) normalization factor for g , and hence the usual expressions are found by replacing g 2 = 3/5 g 2 1 . Finally, we also have in the SM Lagrangian

C Weak Effective Theory for B physics
The Hamiltonian for the WET can be written as where L (u,d,c,s,b,e,µ,τ) QCD+QED is the usual QCD and QED Lagrangian for the light fermions, L SM contains pure-SM dimension-six operators and the C i coefficients contain all beyond the Standard Model effects. The sum over the i index runs over all operators O i defined below. 9 See Ref. [18] for definitions and conventions.

C.1 ∆B = ∆S = 2 operators
In the case of ∆B = ∆S = 2 operators, the basis is given by where we denote with primed indices the operators with opposite chirality. α and β are SU(3) c indices.

C.3 ∆B = ∆S = 1 operators
There are three classes of ∆B = ∆S = 1 operators: Magnetic, hadronic (4-quark) and semileptonic operators. These are chosen as: • Magnetic penguins: • Hadronic (q = s): where q = {u, d, c}. In the case of q = b, the color-octet operators O sbbb 2,4,6,8,10 are Fierz-equivalent to the color-singlet ones and are not included in the basis. In addition, the analogous set with opposite chirality is needed: • Hadronic (q = s): Again, the color-octet operators are Fierz-redundant and have been ommited.

D DsixTools routines
In this Appendix we list the public routines implemented in DsixTools. The user can take advantage of them when writing a project with DsixTools.

D.1 General DsixTools routines LoadModule[moduleName]
Loads the DsixTools module moduleName. Once this command is evaluated, the module is initialized and all its routines are available to the user.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.

MyPrint[string]
Prints the message string. It can be switched on and off by using the DsixTools routines TurnOnMessages and TurnOffMessages.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Arguments: string must be a valid Mathematica string.

TurnOnMessages
Turns on the messages written by the DsixTools routines.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.

TurnOffMessages
Turns off the messages written by the DsixTools routines. The only exception are the messages written when a new module is loaded, which cannot be switched off.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Arguments: options_file and WCsInput_file are the paths to the options and WCs input files. WCsInput_file can contain either SMEFT or WET WCs. The SMInput_file argument is the path to the input card with the values of the SM parameters and is optional: it should be absent when this routine is used to read WET input.

WriteInputFiles[options_file,WCsInput_file,{SMInput_file},data]
Creates input files with the parameter values in data. This routine can be used to export the input values defined by the user in a project to external text files, later to be read by DsixTools.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Arguments: options_file and WCsInput_file are the paths to the options and WCs input files created by this routine. data is an array where the input values have a precise ordering, defined by the ordering in the Parameters (for SMEFT input) and WETParameters (for WET input) global arrays, see E. The SMInput_file argument is the path to the input card with the values of the SM parameters and is optional: it should be absent when this routine is used to write WET input.

WriteAndReadInputFiles[options_file,WCsInput_file,{SMInput_file}]
Writes data into new input files and then reads them. In essence, running this routine is equivalent to running WriteInputFiles and ReadInputFiles.
Requires: Before using the routine the data to be exported (and later read) must be declared. In case of SMEFT input, all SM parameters must be set to their input values by giving values to variables of the form Init[SM_parameter] and all WC values will be assumed to vanish unless they are declared in a similar way. In case of WET input, only the WC values must be declared. Finally, the options will be assumed to take default values unless set to other choices.
Arguments: options_file and WCsInput_file are the paths to the options and WCs input files created by this routine. The SMInput_file argument is the path to the input card with the values of the SM parameters and is optional: it should be absent when this routine is used to write and read WET input.
WriteAndReadInputFiles["Options.dat", "WCsInput.dat"] exports the previously declared values to two WET input files and then reads them.

NewInput[parameter,newvalue,dispatch]
Replaces the current input (contained in the Mathematica dispatch dispatch) by a new one in which parameter takes the value newvalue. This routine is particularly useful for projects involving loops with varying parameters.
Requires: Input values must have been introduced before using this routine, for instance using the ReadInputFiles routine. Only in this way the dispatch dispatch would have been defined.
Arguments: parameter must be a valid name for a DsixTools parameter. These can be found in the global arrays Parameters (in case of SMEFT input) and WETparameters (in case of WET input), see E. newvalue must be a valid number (in general complex). dispatch is the name of the Mathematica dispatch where the input values are saved. By default, this is input.
In the SMEFTrunner module there is also the internal dispatch inputSMEFTrunner.

NewScale[scale,newvalue]
Replaces the current value of scale by newvalue. This routine is particularly useful for projects involving loops with varying energy scales.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Arguments: scale can be either "high" or "low". newvalue must be a valid positive real number. As with other dimensionful parameters, the scale should be given in GeV.

H[mat]
Returns the Hermitian conjugate of the matrix mat. If the option CPV has been set to 0 then it returns the transpose.
Requires: The global variable CPV must have been set to either 0 (for real parameters) or 1 (for complex parameters) before using this function.
Arguments: mat must be a valid matrix.
Example: H[Gu] returns the Hermitian conjugate of the up-quarks Yukawa matrix Γ u .

CC[x]
Returns the complex conjugate of x. If the option CPV has been set to 0 then it returns x.
Requires: The global variable CPV must have been set to either 0 (for real parameters) or 1 (for complex parameters) before using this function.
Arguments: x must be a valid complex number.  12 if CPV has been set to 0, using for [Γ u ] 12 its input value.

D.2 SMEFTrunner routines InitializeSMEFTrunnerInput
Initializes the input for the SMEFTrunner module. This initialization creates the dispatches inputSMEFTrunner and inputSMEFTrunnerSM. The user does not need to use this routine, as it is automatically executed when the SMEFTrunner module is loaded.
Requires: The SMEFTrunner module must have been loaded in order to use this routine.

FindParameterSMEFT[parameter]
Returns the position of parameter in the Parameters list. If one uses a generic element name as argument, FindParameterSMEFT will return a list with all positions where it appears in Parameters.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Arguments: parameter can be either the name of a SM parameter or SMEFT WC, or the generic name of an element of one of the 2-or 4-fermion parameters.
Requires: The SMEFTrunner module must have been loaded in order to use this routine. Moreover, the global variable CPV must have been set to either 0 (for real parameters) or 1 (for complex parameters) before using this function.

LoadBetaFunctions
Constructs the SMEFT β functions (using GetBeta internally) or reads them from a file.
Requires: The SMEFTrunner module must have been loaded and the option ReadRGEs set in order to use this routine.
Requires: The SMEFTrunner module must have been loaded and the option RGEsMethod set in order to use this routine.

ExportSMEFTrunner
Exports the SMEFTrunner results to the output file Output_SMEFTrunner.dat.
Requires: The SMEFTrunner module must have been loaded and the option exportSMEFTrunner set in order to use this routine.
Requires: The SMEFTrunner module must have been loaded in order to use this routine.
Arguments: Output_file is the path to the SMEFTrunner output file. data is an array containing the results obtained with SMEFTrunner. It must contain the same of elements and ordered in exactly the same way as outSMEFTrunner.

D.3 EWmatcher routines InitializeEWmatcherInput
Initializes the input for the EWmatcher module. The user does not need to use this routine, as it is automatically executed when the EWmatcher module is loaded.
Requires: The EWmatcher module must have been loaded in order to use this routine.

FindParameterWET[parameter]
Returns the position of parameter in the WETParameters list. If one uses a generic element name as argument, FindParameterWET will return a list with all positions where it appears in WETParameters.
Requires: Nothing. This routine can be used as soon as DsixTools is loaded.
Arguments: parameter must be the name of a WET WC. WCs are saved in these positions of the WETParameters list.

RotateToMassBasis
Transforms the SMEFT WCs to the fermion mass basis. It also creates the replacements array ToMassBasis, which can be used to print the numerical values of the SMEFT WCs in the fermion mass basis.
Requires: The EWmatcher module must have been loaded in order to use this routine.

Biunitary[mat,dim]
Applies a biunitary transformation that diagonalizes the dim × dim matrix mat. It returns three outputs: the square root of the eigenvalues of mat † mat (or, equivalently, mat mat † ) and the unitary matrices U L and U R that diagonalize mat as U † L mat U R = mat diag .
Requires: The EWmatcher module must have been loaded in order to use this function.
Arguments: mat must be a valid dim × dim matrix.
Example: Biunitary[Gu/.input,3] returns the square root of the eigenvalues of Γ † u Γ u (or, equivalently, Γ u Γ † u ), as well as the matrices U L and U R that diagonalize Γ u as U † L Γ u U R = (Γ u ) diag . Here Γ u is the input value for the up-quarks Yukawa matrix.

ApplyEWmatching
Matches the SMEFT WCs onto the WET WCs. After using this routine several arrays containing the numerical values of the WET WCs at the electroweak scale are created. The result of this step can also be accessed by using the Match and MatchAnalytical functions.
Requires: The EWmatcher module must have been loaded in order to use this function.

Match[WC]
Returns the value of the WET Wilson coefficient WC after matching it to the SMEFT.
Requires: The EWmatcher module must have been loaded in order to use this function. Furthermore, the ApplyEWmatching routines must have been run before using this function.
Arguments: WC must be the name of a valid SMEFT WC. [1]] prints the numerical value of the C sbdd 1 WC.

MatchAnalytical[WC]
Returns the analytical expression of the WET Wilson coefficient WC after matching it to the SMEFT. Only the energy scales and the SM parameters are replaced by numerical values in this function.
Requires: The EWmatcher module must have been loaded in order to use this function. Furthermore, the ApplyEWmatching routines must have been run before using this function.
Arguments: WC must be the name of a valid SMEFT WC.
Requires: The EWmatcher module must have been loaded in order to use this function. Furthermore, the ApplyEWmatching routines must have been run before using this function.
Arguments: Output_file is the path to the text file where the SMEFT WCs in the fermion mass basis will be exported.

ExportEWmatcher
Exports the EWmatcher results to the output file Output_EWmatcher.dat.
Requires: The EWmatcher module must have been loaded and the option exportEWmatcher set in order to use this routine.
Requires: The EWmatcher module must have been loaded in order to use this routine.
Arguments: Output_file is the path to the EWmatcher output file. data is an array containing the results obtained with EWmatcher. The precise ordering of the WET WCs in data is given by that in WETParameters, see E.

D.4 WETrunner routines InitializeWETrunnerInput
Initializes the input for the WETrunner module. The user does not need to use this routine, as it is automatically executed when the WETrunner module is loaded.
Requires: The WETrunner module must have been loaded in order to use this routine.
Requires: The WETrunner module must have been loaded in order to use this routine.

ExportWETrunner
Exports the WETrunner results to the output file Output_WETrunner.dat.
Requires: The WETrunner module must have been loaded and the option exportWETrunner set in order to use this routine.

WriteWETrunnerOutputFile[Output_file,data,scale]
Exports the WETrunner results in data to Output_file after evaluating them at µ = scale.
Requires: The WETrunner module must have been loaded in order to use this routine.
Arguments: Output_file is the path to the WETrunner output file. data is an array containing the results obtained with WETrunner. The precise ordering of the WET WCs in data is given by BS2Low-BC1Low-BS1unprimedLow-BS1primedLow, following exactly the ordering in WETParameters (see E), and they must be evaluated at t = log 10 scale.

E DsixTools parameters
In this Appendix we provide additional details about the SMEFT and WET parameters used in DsixTools. These can be useful to properly read or write some variables in a Mathematica session using DsixTools. Table 6 provides a complete list of the SMEFT parameters used in DsixTools. In addition to the SMEFT WCs, this includes the SM parameters (gauge couplings, Yukawa matrices and scalar and θ parameters). This table is particularly useful to identify the names given to the elements of 2and 4-fermion WCs, as well as the β functions used in the SMEFTrunner module. Table 6: SMEFT parameters. Position denotes the position of the parameter (or parameters for 2-and 4-fermion objects) in the Parameters global array. The column β function gives the name of the β function (obtained with β [parameter] after using the GetBeta routine). Type indicates the type of parameter (with nF standing for n-fermion) and Category denotes the index symmetry category of the coefficient, being relevant for 2-and 4-fermion WCs.

Position
Parameter(s) DsixTools name Elements β function Type Category It is well known that some of the 2-and 4-fermion operators in the SMEFT posess specific symmetries under the exchange of flavor indices. This translates into an index symmetry for the corresponding WCs. For instance, the Wilson coefficient C ϕe is a Hermitian matrix, hence following the symmetry relation C ϕe i j = C ϕe * ji . More complicated index symmetries exist for some of the 4-fermion WCs. In all these cases, the number of independent WCs gets reduced. For example, the C ee 4-fermion WC does not contain 81 (= 3 4 ) independent complex WCs, but just 21 real and 15 imaginary independent components. Therefore, it is convenient to restrict the number of parameters considered in SMEFT calculations to just the independent ones. In DsixTools we have followed this approach, dropping redudant WCs in all calculations. This is what motivates the introduction of an index symmetry category column in Table 6 We see that, apart from the WCs in categories 0, 1 and 3, all other WCs have index symmetries. Furthermore, there are three WCs with special symmetries, not shared by any other WC: C ee , C qque and C qqql . In Table 7 we list the independent WCs contained in each category. This, combined with Table 6, completely allows the user to determine the position of a given parameter in the Parameters array. In any case, we remind the reader that the function FindParametersSMEFT can also be used for this purpose. Table 8 provides a complete list of the WET parameters considered in DsixTools.   Table 9: Baryon-number-violating operators in the mass basis.

F Baryon-number-violating operators in the mass basis
After electroweak symmetry breaking, the Warsaw basis operators can be rotated to the fermion mass basis. This is achieved by performing unitary transformations of the fermion fields in order to diagonalize the fermion mass matrices, e L →V e L e L , e R → V e R e R . (F.1) In this way is a diagonal and positive matrix corresponding to the physical fermion masses. We note that these definitions imply that the CKM matrix is given by V = V † u L V d L . The resulting operators after applying these unitary transformations to the Baryon-number-violating operators are shown in Table 9. For the rest of Wilson coefficients see [17].