Computing Tools for Effective Field Theories

SMEFT-Tools 2022 Workshop Report, 14-16th September 2022, Zürich

Jason Aebischer${}^a$, Matteo Fael${}^b$, Javier Fuentes-Martín${}^c$,

Anders Eller Thomsen${}^d$, Javier Virto${}^{e,f}$

Lukas Allwicher${}^a$,
Supratim Das Bakshi${}^c$,
Hermès Bélusca-Maïto${}^g$,
Jorge de Blas${}^c$,
Mikael Chala${}^c$,
Juan Carlos Criado${}^c$,
Athanasios Dedes${}^h$,
Renato M. Fonseca${}^c$,
Angelica Goncalves${}^i$,
Amon Ilakovac${}^g$,
Matthias König${}^j$,
Sunando Kumar Patra${}^k$,
Paul Kühler${}^l$,
Marija Mađor-Božinović${}^g$,
Mikołaj Misiak${}^m$,
Víctor Miralles${}^n$,
Ignacy Nałȩcz${}^m$,
Méril Reboud${}^o$,
Laura Reina${}^i$,
Janusz Rosiek${}^m$,
Michal Ryczkowski${}^m$,
José Santiago${}^c$,
Luca Silvestrini${}^n$,
Peter Stangl${}^b$,
Dominik Stöckinger${}^l$,
Peter Stoffer${}^{a,p}$,
Avelino Vicente${}^{q,r}$,
Matthias Weißwange${}^l$

Physik-Institut, Universität Zürich, CH-8057 Zürich, Switzerland

${}^b$ CERN, Theoretical Physics Department, CH-1211 Geneva 23, Switzerland

Departamento de Física Teórica y del Cosmos, Universidad de Granada, Campus de Fuentenueva, E–18071 Granada, Spain

${}^d$ Department of Physics, University of Basel, Klingelbergstrasse 82, CH-4056 Basel, Switzerland

${}^e$ Departament de Física Quàntica i Astrofísica, Universitat de Barcelona,
Martí i Franqués 1, 08028 Barcelona, Catalunya

${}^f$ Institut de Ciències del Cosmos (ICCUB), Universitat de Barcelona,
Martí i Franqués 1, 08028 Barcelona, Catalunya

Department of Physics, Faculty of Sciences, University of Zagreb,
Bijenička cesta 32, HR-10000 Zagreb, Croatia

${}^h$ Department of Physics, University of Ioannina, GR 45110, Ioannina, Greece

${}^i$ Physics Department, Florida State University,
Tallahassee, FL 32306-4350, USA

${}^j$ Physik Department T31, Technische Universität München, James-Franck-Str. 1, D-85748 Garching, Germany

${}^k$ Bangabasi Evening College, Kolkata, India

${}^l$ Institut für Kern- und Teilchenphysik, TU Dresden,
Zellescher Weg 19, DE-01069 Dresden, Germany

${}^m$ Faculty of Physics, University of Warsaw, Pasteura 5, 02-093 Warsaw, Poland

${}^n$ INFN, Sezione di Roma, Piazzale A. Moro 2, I-00185 Roma, Italy

${}^o$ Institute for Particle Physics Phenomenology and Department of Physics,
Durham University, Durham DH1 3LE, UK

${}^p$ Paul Scherrer Institut, 5232 Villigen PSI, Switzerland

${}^q$ Instituto de Física Corpuscular, CSIC-Universitat de València, 46980 Paterna, Spain

${}^r$ Departament de Física Teòrica, Universitat de València, 46100 Burjassot, Spain

In recent years, theoretical and phenomenological studies with effective field theories have become a trending and prolific line of research in the field of high-energy physics. In order to discuss present and future prospects concerning automated tools in this field, the SMEFT-Tools 2022 workshop was held at the University of Zurich from 14th-16th September 2022. The current document collects and summarizes the content of this workshop.

§ PREFACE BY THE EDITORS

tocsectionPreface by the Editors

The current developments in beyond-the-Standard-Model (BSM) phenomenology point to an ever greater use of Effective Field Theories (EFTs). With no concrete hints of a forthcoming discovery of on-shell new physics (NP), we see no reason that this trend should change any time soon. In fact, even a discovery of new high-energy resonances would call for the use of EFTs to study many of their observable effects. The role of computer tools is central to the successful use of EFT in BSM physics: simply put, the amount of repetitive computations is all but impossible to perform on a case by case basis without them. For these reasons, we gathered creators and developers of EFT tools for another workshop three years after the first SMEFT-Tools workshop [1].

The SMEFT-Tools 2022 workshop received contributions from a large part of the EFT theory community, especially, as it pertains to the computer tools of the field. As a result, this review is a comprehensive, if not quite complete, report on the current status of the tools available in the field. Additionally, several speakers at the workshop were presenting new results dealing with the more formal theory aspects. These results frame the current and future developments of EFT tools and are crucial to the ever growing capabilities of the tools. However, the theory developments included in this report are merely a sample of what is being undertaken in the field as a whole; the field is simply too active to include all, or even most, of the developments here.

The introductory section provides some context and motivation for the use of EFTs and discusses some of the trends in EFT used for BSM. We have grouped the other contributions in two main sections: On the one hand, Section <ref> details computer tools for the study of ultraviolet (UV) models using EFTs. This section describes tools for matching ultraviolet (UV) models to EFTs, automating the renormalization-group (RG) evolution of EFT coefficients, generating EFT operator bases, and a proposal for a unified format for the storage of EFT matching results. On the other hand,  Section <ref> describes computer tools necessary for the phenomenological study of EFTs. These tools are equally invaluable for bottom–up or top–down analyses. This section contains four different tools for the key task of performing global fits to experimental data, along with a code for automatically deriving the Feynman rules of the Standard Model Effective Theory (SMEFT). In both sections, contributions covering recent theory developments relevant for future implementations or practical applications of EFT tools are also included.

§ INTRODUCTION AND MOTIVATION

José Santiago and Peter Stoffer

EFTs have been a basic tool in particle physics for many years. In most cases EFTs were used in the context of well-defined, usually renormalizable, models, either because they were the only way to compute certain observables (for example, due to the strong coupling of QCD at low energies) or because their use greatly simplified the calculation of interest (gluon-fusion Higgs production at a high perturbative order in the infinite mass limit is a clear example). Their application to the study of physics beyond the Standard Model (SM), while already present in the past, has experienced an exponential increase in the last decade. The reasons for this are two-fold: first, the LHC and other experiments are producing increasingly better limits on the mass of new particles, searching in a multitude of different channels, which seems to clearly indicate the presence of a mass gap between the scale of new physics and the energies at which most experimental observables are measured; second, and this is especially relevant for this workshop, the last few years have seen the appearance of a plethora of new computer tools, that simplify, and in many cases fully automate, the tedious calculations needed to apply EFTs to new physics searches.

§.§ Connecting Theory and Experiment via EFTs

tocsubsectionConnecting Theory and Experiment via EFTs

The problem of obtaining the implications of experimental data on models of new physics is highly non-trivial. The vast number of observables measured experimentally has to be computed, via complicated, sometimes multi-loop calculations, for each particular model of new physics. These difficult calculations have to be repeated for every experimental observable and every model with the added complication that, despite the very large number of new physics models developed by theorists, we are not guaranteed that the true description of Nature falls into one of these models.

EFTs simplify the problem of obtaining the phenomenological implications of experimental data on new models by splitting the calculation in two (mostly independent) steps. In the first one, the bottom-up approach, the experimental observables are computed, to the required order in perturbation theory, in terms of the Wilson coefficients (WCs) of the corresponding effective Lagrangian. This process can be performed with no mention of any new physics model and therefore represents a mostly model-independent parametrization of experimental data in the form of global fits (or rather a global likelihood), see Section <ref>. In the second step, the top-down approach, the WCs of the effective Lagrangian are computed in terms of the couplings and masses of specific UV models, that complete the EFT at high energies. This calculation, called matching, has to be done for every model of new physics (but not any more for every observable) but, thanks to recently developed tools, it can be fully automated (see Section <ref>). When the bottom-up and top-down approaches are combined one can obtain the phenomenological implications of any experimental observable in any UV model and, thanks to existing computer tools, in a mostly automated way.

§.§ The SMEFT and the LEFT

tocsubsectionThe SMEFT and the LEFT

The absence of evidence for physics beyond the SM in direct LHC searches suggests that new particles are either very weakly coupled [2] or much heavier than the electroweak scale. In the latter scenario, their effects at energies below the scale of new physics can be described by an EFT. Depending on the assumption about the nature of the Higgs particle, this is either the Standard Model Effective Field Theory (SMEFT) [3, 4] or Higgs Effective Field Theory (HEFT) [5, 6].  In particular, the SMEFT is the most general EFT invariant under the SM gauge symmetry, $SU(3)_c\times SU(2)_L\times U(1)_Y$, involving only SM particles with the Higgs field taken as an $SU(2)_L$ doublet.

The SMEFT Lagrangian up to dimension-six operators is given by

\begin{align}
{\mathcal L}_{\rm SMEFT}^{d\leq6} &= {\mathcal L}_{\rm SM} + \sum_{k} C_k^{(5)} Q_k^{(5)}+ \sum_{k} C_k^{(6)}Q_k^{(6)}\,,
\end{align}

with ${\mathcal L}_{\rm SM}$ being the SM Lagrangian. There is only one term at dimension five corresponding to the Weinberg operator [7]. This operator violates baryon number in two units and yields Majorana masses for the neutrinos after electroweak symmetry breaking. At dimension six, there are $59$ terms that preserve baryon number and another $5$ that violate baryon and lepton numbers in one unit. These are commonly presented in the so-called Warsaw basis [4]. The complete set of RG equations for the dimension-six SMEFT in the Warsaw basis has been calculated in [8, 9, 10, 11]. As we describe in the sections below, these advances, together with simultaneous theoretical and computational developments towards the automation of one-loop matching calculations, pave the way to the systematic use of EFT methods in the analysis of NP models.

For processes below the electroweak scale, another EFT should be used, wherein the heavy SM particles, i.e., the top quark, the Higgs scalar, and the heavy gauge bosons, are integrated out. This low-energy effective field theory (LEFT) is a gauge theory invariant only under the unbroken SM groups $SU(3)_c \times U(1)_{\rm em}$, i.e., QCD and QED augmented by a complete set of effective operators. If matched to the SM at the electroweak scale, it corresponds to the Fermi theory of weak interaction [12], but when all operators invariant under the unbroken gauge groups are included, it also describes the low-energy effects of arbitrary heavy physics beyond the SM.

The LEFT is defined by the Lagrangian

\begin{align}
\label{eq:LEFTLagrangian}
\L_{\rm LEFT} = \L_{\rm QCD+QED} + \L^{(3)}_{\slashed L} + \sum_{d\ge5} \sum_i L_i^{(d)} \O_i^{(d)} \, ,
\end{align}

where the QCD and QED Lagrangian is given by

\begin{align}
\label{eq:qcdqed}
\L_{\rm QCD + QED} &= - \frac14 G_{\mu \nu}^A G^{A \mu \nu} -\frac14 F_{\mu \nu} F^{\mu\nu} + \theta_{\rm QCD} \frac{g^2}{32 \pi^2} G_{\mu \nu}^A \widetilde G^{A \mu \nu} +  \theta_{\rm QED} \frac{e^2}{32 \pi^2} F_{\mu \nu} \widetilde F^{\mu \nu} \nn
&\quad + \sum_{\psi=u,d,e,\nu_L}\overline \psi i \slashed{D} \psi   - \left[ \sum_{\psi=u,d,e}  \overline \psi_{Rr} [M_\psi]_{rs} \psi_{Ls} + \text{h.c.} \right] \, .
\end{align}

The additional operators are the Majorana-neutrino mass terms $\L_{\slashed L}^{(3)}$ at dimension three, as well as operators at dimension five and above. At dimension five, there are photonic dipole operators for all the fermions (including a lepton–number-violating neutrino dipole operator) as well as gluonic dipole operators for the up- and down-type quarks. At dimension six, there are the CP-even and CP-odd three-gluon operators and a large number of four-fermion operators. The entire list of operators up to dimension six can be found in [13], including operators that violate baryon and lepton number.

This theory has been extensively studied in the context of $B$ physics. The operator basis relevant for $B$-meson decay and mixing has been constructed in [14]. The complete LEFT operator basis up to dimension six in the power counting has been derived in [13], where also the tree-level matching to the dimension-six SMEFT above the weak scale was provided. By now, the LEFT operator basis is known up to dimension 9 [15, 16, 17]. Recently, the tree-level matching to the SMEFT has been extended to dimension eight in the SMEFT power counting [18]. Partial results for lepton–flavor-violating operators were given already in [19].

The complete one-loop LEFT RG equations were derived in [20]. Partial results for the RG equations were known before and have been studied to higher loop orders [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 14, 43, 44, 45].
Within the SMEFT/LEFT framework, the one-loop RG equations at the high scale [8, 9, 10], the tree-level matching [13], and the RG equations below the weak scale [20] allow one to resum the leading logarithms and to describe the indirect low-energy effects of heavy physics beyond the SM within one unified framework. The RG and matching equations have been implemented in several software tools, many of which were presented at the SMEFT-Tools workshops. Consistent EFT analyses at leading-log accuracy that combine constraints from experiments at very different energy scales are becoming standard.

For certain high-precision observables at low energies it is desirable to extend the analysis beyond leading logarithms. Steps in this direction have been taken, e.g., in [33, 38, 45]. Partial results for the matching at the weak scale at one loop were derived in the context of $B$ physics in [35, 46]. The complete one-loop matching between the SMEFT and the LEFT at dimension six was calculated in [47]. It can be used for fixed-order calculations at one-loop accuracy in cases where the logs are not large, and it is an ingredient in next-to-leading-log analyses within a resummed framework. Several tools are being developed that automate the one-loop matching between the EFT framework and UV models for new physics [48, 49].

At energies as low as the hadronic scale, additional complications appear due to the non-perturbative nature of QCD. In these low-energy processes, one should not work with perturbative quark and gluon degrees of freedom but rather perform either direct non-perturbative calculations of hadronic matrix elements of effective operators or switch to another effective theory in terms of hadronic degrees of freedom, i.e., chiral perturbation theory () [50, 51, 52]. In [53], the matching of semileptonic LEFT operators to  has been discussed, which can be obtained within standard  augmented by tensor sources [54]. The chiral realization of four-quark operators was studied in [55], while [56] analyzed $C$- and CP-odd LEFT operators up to dimension 8. If lattice QCD is employed to deal with the non-perturbative effects at low energies, one faces the problem that the EFT framework requires matrix elements of dimensionally renormalized operators. This necessitates another matching calculation to a scheme amenable to lattice computations. This matching has to be performed at a scale of a few GeV, which is already accessible to lattice computations but at the same time sufficiently high that perturbation theory can be assumed to work reasonably well. Traditionally, these matching calculations are based on regularization-independent momentum-subtraction (RI-MOM)  schemes [57, 58, 59, 34, 60], whereas in recent years the gradient flow [61, 62] has received attention [63, 64, 65, 66, 67].

§.§ Going Beyond

tocsubsectionGoing Beyond

The great sensitivity achieved in the search for CP violation, rare meson decays, magnetic and electric dipole moments and lepton-flavor-violating processes requires improvements in the theoretical precision with EFTs.
The need to include higher-order corrections is twofold. On the one hand, the inclusion of higher-order corrections, especially in QCD, allows to better assess
the uncertainties in the theoretical calculation. On the other hand, some new-physics effects are only generated once higher-loop effects have been accounted for in certain UV completions, thus including them naturally yields to better constraints on the underlying theory.

In fact, it is often the case that the leading effects of new physics are due to loop-level processes. The last decade has seen results for one-loop running in the SMEFT [8, 9, 10, 11, 68] and the LEFT [20] and the one-loop SMEFT to LEFT matching [47]. Likewise, as we highlight in this manuscript, there has been recent substantial progress in the connection of NP models to their EFTs. Going beyond the leading logarithm effects requires systematic treatment of RG effects in the EFTs because of the scheme dependence of the anomalous dimension matrix and the matching coefficients appearing, for instance, in the chosen prescription for $\gamma_5$ in $d$ dimensions [69, 70, 71, 72, 73, 74, 75, 76, 77, 78] and the definition of evanescent operators [22, 79, 80, 47, 81, 82].
To this end, consistent calculations across different EFTs and bases have given cause for a new look at the role of evanescent contributions [49, 81]. In the perspective of systematic multi-loop computations within EFTs, there has been a recent interest in the proper treatment of $ \gamma_5 $ [78, 83, 84], a notorious stumbling block in dimensional regularization.

Higher-order anomalous dimensions have been calculated for subsets of dimension-six operators [21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 14, 43, 44, 45], but due to the hard technical nature of the calculations the complete matrix is not known. Given the large number of operators of the SMEFT and LEFT, it may be more convenient to consider first a generic EFT with an arbitrary number of real scalars and left-handed fermions and compute the anomalous dimensions and the RG in such theory invariant under
a generic gauge group. Results for NLO running of the SMEFT or LEFT WCs can be then extracted in a second step by specifying the field content and the gauge group.

There has also been recent progress in expanding the EFT formulation beyond dimension-six operators, sparking the formulation of geometric EFTs [85, 86] and the determination of higher-dimension bases [15, 87, 88], as well as the  counting of the EFT operators through the use of Hilbert series [89]. Recent work has also started constraining the effects from higher-dimensional operators through the use of unitarity bounds, e.g., [90, 91, 92, 93, 94, 95, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106].

§ EFFECTIVE FIELD THEORY MATCHING AND RUNNING

Despite the usefulness of the EFT approach, the interpretation of data in terms of NP models requires a direct connection between those models and their EFT description. This typically involves the calculation of sequential matching steps at the relevant mass thresholds, and RG equations between these thresholds and the scale of the observables. In recent years, many tools that (at least partially) automate these calculations have been developed.

In the absence of light particles beyond those in the SM, the necessary calculations for RG running and matching below the NP mass threshold are known up to dimension-six operators [8, 9, 10, 11, 35, 13, 47, 20]. These results have been implemented into several computer tools including  [107, 42] (which we describe in Section <ref>),  [108], and  [109]. The SMEFT RG evolution has also been incorporated [110] into the  Monte Carlo generator [111]. As far as tree-level matching is concerned, the Python package  [112] allows to perform a fully automated matching computation for arbitrary heavy particles and gauge groups. Furthermore, the matching code  (see Section <ref>) implements formulae based on path-integral methods [113, 114, 115, 116] to automate the matching of some NP models into the dimension-six SMEFT. Further matching tools that rely on functional methods are  [117] and  [118].

Although it might be tempting to think of the target EFT as the SMEFT, many realistic BSM constructions contain several energy scales, calling for intermediate EFTs, or feature additional light states, such as axion-like or dark-matter particles, thus, demanding extensions of the SMEFT (see, e.g., [119, 120, 121, 2, 122]). Furthermore, some phenomenological studies require extending EFT calculations beyond dimension-six operators (see, e.g., [104, 123, 124, 125, 126] for recent literature examples). Reflecting on this, a new generation of tools is now aiming at solving the more general problem of completely automating one-loop matching and RG evolution of arbitrary weakly-coupled models. The most notable examples in this direction are  and , described in Sections <ref> and <ref>, respectively.

Additional developments to assist matching calculations are also described in this section. In particular, the computer tool  (see Section <ref>),[Other tools that allow for finding higher-dimensional operators in the SMEFT are  [127],  [128] and  [129].] which automates the construction of EFT basis, and the MatchingDB format (see Section <ref>), aimed at standardizing the storage of matching results.

[]: The Effective Field Theory ToolkitAvelino Vicente

is a Mathematica [107, 42] package for the matching and renormalization group evolution from the NP scale to the scale of low energy observables. The current version of fully integrates the SMEFT and the LEFT, treating both theories on an equal footing. It allows the user to perform the full one-loop renormalization group evolution of the WCs in the SMEFT and in the LEFT (with SM $\beta$ functions up to 5-loop order in QCD), and the full one-loop SMEFT-LEFT matching at the electroweak scale. Therefore, the user can start with some numerical values for the SMEFT WCs at the high-energy scale $\Lambda_{\rm UV}$, in principle obtained after matching to a specific NP model, and translate them into numerical values for the LEFT WCs at the low-energy scale $\Lambda_{\rm IR}$, where some observables of interest can be computed. This is achieved by adopting some conventions and implementing some results in the recent literature:

* The Warsaw basis [4] for the SMEFT, for which full one-loop RG equations [8, 9, 10, 11, 130] are known.

* Full one-loop SMEFT-LEFT matching [13, 47].

* The San Diego basis [13] for the LEFT, for which full one-loop RG equations [20] are known.

All these results can be used in a visually accessible and operationally convenient way thanks to . In addition to running and matching numerical routines, it also includes several functions for analytical applications, as well as user-friendly SMEFT/LEFT dictionary tools. Since version 2.1, also admits input obtained with , thus extending its capabilities.

The simplest way to download and install is to run the following command in a Mathematica session:[It requires Mathematica version 9.0 (or newer).]

This will download and install , activate the documentation
and load the package. Alternatively, can also be installed
manually. Finally, can also be loaded (once installed) by
running the usual

§.§.§ What can do for you

For a full and updated list with all the tools provided by we
refer to the manual on the package website [131]. We will now
concentrate on some useful features that illustrate what can do
for you in practice. A demo notebook with these and other
examples of use is also provided at [132].

User-friendly SMEFT & LEFT information. contains several
routines and functions that allow one to use the tool as a SMEFT/LEFT
dictionary. For instance, one can load and execute the command

to print many details about the $C_{\varphi \ell}^{(1)}$ SMEFT WC. One
may learn the definition of the associated $Q_{\varphi \ell}^{(1)}$
operator, its dimensionality and type (2-fermion in this case). In
case of WCs carrying flavor indices, such as this one, this command
also prints information about the possible symmetries under exchange
of indices, the number of independent coefficients or the relations
(due to Hermiticity, for example) among them. This information is
displayed in a user-friendly way. Similarly, with

one would get the same information about the LEFT WC $L_G$. Finally,
with the functions

and the analogous ones in the LEFT, shows a visual grid or a
dropdown menu with all the WCs of the theory. The user can now click
on any of them to run the ObjectInfo function on the selected WC
and obtain all its properties.

Introducing and changing input values. There are two methods to
introduce input values in : with the NewInput routine or
from a file. In the latter case one can choose between a native format or the WCxf format [133]. Let us focus
on the former case. With the NewInput routine the user loads the
input values directly in the Mathematica notebook. Only the
non-zero WCs must be given. The rest will be assumed to vanish. For
instance, the command

NewInput[Clq1[1, 1, 1, 2] -> 1, Clq1[1, 1, 2, 1] -> 1,
CHBtilde -> -0.5];

sets $[C_{\ell q}^{(1)}]_{1112} = [C_{\ell q}^{(1)}]_{1121} = 1$
GeV$^{-2}$ and $C_{\varphi \widetilde B} = - 0.5$ GeV$^{-2}$. We note
that dimensionful quantities in are always given in GeV to the
proper power. In , the input values for the parameters of the
effective theory at work (SMEFT or LEFT) are stored as replacement
rules in a dispatch variable called Input Values. Then, after
defining an input, the user can easily read it as

Clq1[1, 1, 1, 2] /. InputValues

Once the input values have been set, the user can change them
individually at any moment in the notebook. This is done with the ChangeInput routine. For example, the line

ChangeInput[CHBtilde -> 0.6]

changes the value of $C_{\varphi \widetilde B}$ to $0.6$
GeV$^{-2}$. Finally, produces a warning message when the WCs
provided by the user lead to an invalid set of input values. There are
two possible reasons for this:

* Non-Hermiticity errors: Some WCs are related due to the Hermiticity of the Lagrangian. For instance, $[C_{\ell q}^{(1)}]_{1112} = [C_{\ell q}^{(1)}]^\ast_{1121}$ must necessarily hold.

* Antisymmetry errors: Some LEFT WCs are antisymmetric under the exchange of two flavor indices. For instance, $[L_{\nu \gamma}]_{11} = 0$ must necessarily hold.

When the user's input is not consistent with any of these
restrictions, a warning is issued and corrects the input by
replacing it by a new one that ensures a complete consistency of the
Lagrangian. The list of invalid input values can be seen by clicking
on the button Input errors. We note, however, that in some cases
other WCs, related to these by the two reasons given above, may be
modified too.

A simple program. Let us illustrate how easily one can
use with a simple but complete program, given by the following
three lines after opening Mathematica and loading :

NewInput[Clq1[2, 2, 3, 3]->1.0/HIGHSCALE^2, HIGHSCALE->10^4];
D6run[Clq1[2, 2, 3, 3]]/.
\[Mu]->EWSCALE
\end{lstlisting}
% \end{widetext}
Here we consider an example SMEFT input with $[C_{\ell
q}^{(1)}]_{2233} = 1/\Lambda_{\rm UV}^2$, given at $\Lambda_{\rm
UV} = 10$ TeV. The rest of the SMEFT WCs are assumed to vanish at
$\Lambda_{\rm UV}$. Notice that input for the energy scales must be
given too. However, $\Lambda_{\rm EW}$ and $\Lambda_{\rm IR}$ are
taken to be equal to $m_W$ and $5$ GeV by default, and then only
$\Lambda_{\rm UV}$ must be provided. In the first line of this
program, the {\tt NewInput} routine is used to introduce the SMEFT WCs
as well as the NP energy scale $\Lambda_{\rm UV}$. In the second line
we make use of {\tt RunDsixTools}, one of the most important routines
in \dsix. It runs the SMEFT RG equations, it matches the resulting SMEFT
Lagrangian at the electroweak scale onto the LEFT one and runs down to
$\Lambda_{\rm IR}$ with the LEFT RG equations. The results of this process can
be obtained by means of the {\tt D6run} function, which returns
interpolating functions that can be evaluated for any value of the
energy scale $\mu$. For instance, in this program we choose to print
$[C_{\ell q}^{(1)}]_{2233}$ at the electroweak scale. Last but not
least, we emphasize that \dsix not only provides numerical
routines. In fact, all the analytical information in the code can be
printed and used in {\tt Mathematica} sessions. There are plenty of
examples of this. For instance, with the command
\begin{lstlisting}[style=mathematica]
LeuVLL[2, 2, 1, 1] /. MatchAnalytical
\end{lstlisting}
the user can display the analytical expression for the WC
$[L_{eu}^{V,LL}]_{2211}$ of the LEFT after matching at one-loop to the
SMEFT WCs. Similarly, the SMEFT and LEFT $\beta$ functions can be
readily accessed as
\begin{lstlisting}[style=mathematica]
\[Beta][gs]
\[Beta][LeuVLL[2, 2, 1, 1]]
\end{lstlisting}
We refer to the demo notebook~[132] for examples of use of
other \dsix routines and functions.

\bigskip
{\bf Using \mmebf results.} The first step in the study of specific NP
models with the tools described here is the matching of the model to
an EFT. If the NP degrees of freedom lie at high energies, this EFT is
generally the SMEFT. Even though this theory is very well known
nowadays, the calculation might be hard, especially if done at
one-loop. Since version 2.1, \dsix admits input obtained with
\mme~[48], a fully automated {\tt Python} code to
compute the tree-level and one-loop matching of arbitrary models onto
arbitrary EFTs. Its use is very simple. Let us illustrate it with an
example NP model that extends the SM field inventory with a
right-handed neutrino $N \sim (\mathbf{1},\mathbf{1})_0$ and a scalar
leptoquark $S \sim (\mathbf{3},\mathbf{2})_{\frac{1}{6}}$, where we
denote their representations under $(\rm SU(3)_c, SU(2)_L)_{\rm
U(1)_Y}$. The NP Lagrangian contains the pieces
\begin{align}
\mathcal{L}_N &= i \overline N \, \gamma_\mu D^\mu N - \frac{1}{2} M_N \, \overline{N^c} \, N \, , \\
\mathcal{L}_S &= D_\mu S^\dagger \, D^\mu S - M_S^2 \, S^\dagger \, S \, , \\
\mathcal{L}_{SH} &= - \lambda_2 \, H^\dagger H \, S^\dagger S - \lambda_3 \, H^\dagger S \, S^\dagger H \, , \\
\mathcal{L}_{\rm Y} &= - Y_N^\alpha \, \overline N \, \ell_L^\alpha H - Y_S^\alpha \, \overline q_L^\alpha \, N S + \hc \, ,
\end{align}
where $\alpha = 1,2,3$ is a flavor index. This model can be easily
implemented and matched onto the SMEFT at the one-loop level with
\mme. The results are saved in text file called {\tt
MatchingResult.dat}, which can be loaded into \dsix with the command
\begin{lstlisting}[style=mathematica]
NewInput[{MMEfile -> "SN_MM/MatchingResult.dat", MN -> 1000, MS -> 1200, lam2 -> 0.1, lam3 -> 0.1, YN[a_] :> YNnum[[a]], YS[a_] :> YSnum[[a]]}, HIGHSCALE -> 10^4]
\end{lstlisting}
With this line, the user not only loads the analytical information in
{\tt MatchingResult.dat}, but also gives numerical values for the NP
parameters. After executing this command, the user can check some
input values for the SMEFT WCs at $\Lambda_{\rm UV} = 10$ TeV. Their
analytical expressions in terms of the parameters of the UV model can
also be printed thanks to the dispatch {\tt MatchAnalyticalUV}. For
instance, the analytical expression and numerical value of $C_\varphi$
can be printed with
\begin{lstlisting}[style=mathematica]
CH /. MatchAnalyticalUV
CH /. InputValues
\end{lstlisting}
With the \dsix SMEFT input fully generated, one can now proceed and
use the {\tt RunDsixTools} routine. Therefore, thanks to this novel
functionality, the user can easily combine \dsix and \mme to study NP
models using the full power of EFTs.

\subsubsection{Summary}
\label{sec:sum}

Some of the most common tasks in the SMEFT and in the LEFT require the
handling of a large number of WCs and/or the resolution of a huge set
of coupled RG equations. These can be automatized with the help of \dsix, a
{\tt Mathematica} package designed to provide a simple and
user-friendly experience. \dsix contains many routines and functions
to deal with the SMEFT or the LEFT, both at the algebraic and
numerical levels. Some examples of use that illustrate the capabilities
of \dsix are given here. We refer to the manual on the package
website~[131], as well as to the comprehensive reference and
documentation environment provided with \dsix, for further information
on the tool.

\contribution[{\includegraphics[width=0.4\textwidth]{Figures/CodexLogo.jpg}}]{\texttt{CoDEx:} Matching BSMs to SMEFT}{Supratim Das Bakshi and Sunando Kumar Patra}{}\label{sec:Codex}

\texttt{CoDEx}~[134] is a Mathematica package that computes WCs for SMEFT effective operators up to one-loop level and mass dimension six in terms of UV model parameters. The computation of WCs is based on the evaluation of effective action formulae derived using functional methods~[113, 114, 115, 116]. The package is applicable to  BSM scenarios containing single or multiple mass-degenerate heavy fields of spin 0, $\frac{1}{2}$, and 1.\footnote{The effective action formula used in \texttt{CoDEx} for 1-loop generation of Wilson coefficients assumes the degenerate masses for heavy fields. This utility will be extended to non-degenerate masses in subsequent versions.} It computes the effective operators in both Strong Interacting Light Higgs (SILH)~[135, 136] and Warsaw~[3, 4] bases. The code also provides an option to perform the RG evolution of these operators in the Warsaw basis, using the anomalous dimension matrix computed in [8, 9, 10]. Thus, one can get all effective operators at the EW scale, generated from any such BSM theory. To run the program, it requires very minimal input within a user-friendly format. The user needs to provide only the relevant part of the BSM Lagrangian that involves the heavy field(s) to be integrated-out. \texttt{CoDEx}, with its installation instructions, web documentation, and model examples, is available on GitHub \href{https://effexteam.github.io/CoDEx/}{\faGithub}.\footnote{Send bug reports and questions at \href{mailto:effex.package<EMAIL_ADDRESS>
\begin{figure}[ht]
\begin{center}
\vspace{-2em}%
\includegraphics[width=0.5\textwidth]{Figures/CoDEx_flowchart}%
\vspace{-2em}%
\end{center}
\caption{\texttt{CoDEx} Flowchart}
\label{fig:flowchart}       % Give a unique label
\end{figure}

\subsubsection{ User Inputs \& CoDEx Outputs}

\indent The input information for any BSM to implement in \texttt{CoDEx} is minimal. Here, we depict a step-by-step procedure to compute the effective operators and the internal computation that is carried out at each step in \texttt{CoDEx} (see also the flowchart in Fig.~\ref{fig:flowchart}):

\begin{itemize}\setlength\itemsep{1em}
\item The users need to provide the following information (quantum numbers) about the heavy field(s): Color, Isospin, Hypercharge, Mass, and Spin, based on which the representation(s) of the heavy field(s) are evaluated by the package internally. As mentioned, the SM gauge group quantum numbers of the BSM field are needed as input.  On top of that, the relevant part of the BSM Lagrangian that contains the heavy field(s) must be supplied by the user. The code automatically builds the heavy field kinetic (derivative and mass) terms, which are not required from the user. The SM Lagrangian is also appended by default.

Let us consider an example here: we have only one heavy field -- a real singlet scalar (\mmaInlineCell{Code}{color} $\rightarrow$ 1, \mmaInlineCell{Code}{isospin} $\rightarrow$ 1, \mmaInlineCell{Code}{hypercharge} $\rightarrow$ 0, \mmaInlineCell{Code}{spin} $\rightarrow$ 0). Let us denote \mmaInlineCell{Code}{fieldName} $\rightarrow$ `hf' and \mmaInlineCell{Code}{mass} $\rightarrow$ `m'.
This represents the field content of our model in the correct way:

\,

\noindent\begin{mmaCell}[index=1]{Code}
fields={{(*heavy field name *) hf,
(*color*) 1,
(*isospin*) 1,
(*hypercharge*)  0,
(*spin*) 0,
(*mass*) m}

\end{mmaCell}
\,

From this input, we construct the field representation that is needed to write the BSM Lagrangian and the \texttt{CoDEx} internal functions recognise this representation for further analysis. First, load the package:

\,

\begin{mmaCell}{Input}

\end{mmaCell}

\begin{mmaCell}{Code}

\end{mmaCell}
\begin{mmaCell}{Output}
\{\{\{hf[1,1]\}\}\}
\end{mmaCell}
\,

To write the Lagrangian in a compact form one can define the heavy field {\it ${\mathcal{S}}$} as:

\,

\begin{mmaCell}{Input}
\mmaUnd{\(\pmb{\mathcal{S}}\)} = \mmaDef{hfvecsewrss}[[1,1,1]]

\end{mmaCell}
\begin{mmaCell}{Output}

\end{mmaCell}

\,

Then we need to build the relevant part of the  Lagrangian (involving the heavy field only). Note that we do not need to construct the heavy field kinetic term (the covariant derivative and the mass terms) in the \texttt{CoDEx} Lagrangian. Thus, the only part of the Lagrangian we need here is:\footnote{If there is a tadpole term in the input BSM Lagrangian, the user has
to perform field redefinition before implementing the Lagrangian in CoDEx functions}

\,

\begin{mmaCell}{Input}
-\mmaFrac{\mmaUnd{\(\pmb{\kappa}\)}}{2}*\mmaSup{\mmaDef{abs}[\mmaDef{H}]}{2}*\mmaSup{\mmaDef{\(\pmb{\mathcal{S}}\)}}{2}-\mmaFrac{1}{3!} \mmaUnd{\(\pmb{\mu}\)}*\mmaSup{\mmaDef{\(\pmb{\mathcal{S}}\)}}{3}-\mmaFrac{1}{4!} \mmaUnd{\(\pmb{\lambda}\)}*\mmaSup{\mmaDef{\(\pmb{\mathcal{S}}\)}}{4}];

\end{mmaCell}

\,

\item Next, we need to load the symmetry generators for computing loop-level WCs:

\,

\begin{mmaCell}{Input}
\mmaDef{initializeLoop}["ewrss",\mmaDef{fieldewrss}]

\end{mmaCell}

\item Based on these inputs, one can generate the tree- and one-loop-level WCs. The \texttt{CoDEx}-functions for generating WCs are listed in Table\,\ref{tab:mainFuncs}.

\begin{table}[ht]
\begin{center}
\scriptsize
\renewcommand*{\arraystretch}{2}
\begin{tabular}{|cl|}
\rowcolor[gray]{.92}
\hline
Function &  Details \\
\hline
\rowcolor[gray]{.92}
\mmaInlineCell{Code}{treeOutput} & \text{Calculates tree-level WCs.} \\
\rowcolor[gray]{.92}
\mmaInlineCell{Code}{loopOutput} & \text{Calculates one-loop-level WCs.} \\
\rowcolor[gray]{.92}
\mmaInlineCell{Code}{codexOutput} & \text{Generic function for WCs calculation up to one loop.} \\
\hline
\end{tabular}
\caption{\texttt{CoDEx} functions for computing WCs.}\label{tab:mainFuncs}
\end{center}\vspace{-1em}%
\end{table}

\begin{mmaCell}{Input}
\mmaDef{initializeLoop}["ewrss",\mmaDef{fieldewrss}]

\end{mmaCell}
\begin{mmaCell}[label={\mmaShd{$ \gg $}}]{Output}
Isospin Symmetry Generators for
the field `hf' are isoewrss[1,a] = 0

\end{mmaCell}
\begin{mmaCell}[label={\mmaShd{$ \gg $}}]{Output}
Color Symmetry Generators for
the field `hf' are colewrss[1,a] = 0

\end{mmaCell}
(See the documentation of \mmaInlineCell{Input}{initializeLoop} for details.)

\,

\item The last step is the computation of effective operators and associated WCs:

\,

\begin{mmaCell}{Input}
\mmaDef{fieldewrss},model\(\pmb{\to}\)"ewrss",
\mmaDef{formPick}["Warsaw","Detailed2",\mmaDef{res1},
FontFamily\(\pmb{\to}\)"Times New Roman",

\end{mmaCell}

\,

\begin{table*}[ht]
\caption{\footnotesize Effective operators and WCs for Real Singlet Scalar model. These results are calculated in $\overline{\text{MS}}$ renormalization scheme. The one-loop result depends on the choice of renormalization scheme, e.g. in this particular case, we have noted  differences with results given in Ref.~[113] where different renormalization scheme has been considered. Here,  we have highlighted the extra terms obtained in our calculation in $\overline{\text{MS}}$ scheme in red color. We have further cross-checked these results in the other scheme, adopted in Ref.~[113]. Warsaw basis WCs are consistent with that reported in Refs.~[137, 138, 139].}
\label{tab:realSing}
\centering
\small
\renewcommand{\arraystretch}{1.6}
\subfloat[SILH  (Tree level)]{
\begin{tabular}{|*{2}{c|}}
\hline
$O_H$  &  $\frac{c_a^2}{m^4}$  \\
\hline
$O_6$  &  $\frac{\mu  c_a^3}{6 m^6}-\frac{\kappa  c_a^2}{2 m^4}$\\
\hline
\end{tabular}
\label{tab:realSingST}
\subfloat[SILH  (one-loop level)]{
\begin{tabular}{|*{2}{c|}}
\hline
$O_H$  & $ \frac{\kappa ^2}{192 \pi ^2 m^2}  \textcolor{red}{-\frac{11\mu ^2 c_a^2}{192 \pi ^2 m^6}+\frac{5\kappa  \mu  c_a}{96 \pi ^2 m^4}+\frac{\lambda  c_a^2}{16 \pi ^2 m^4}}$  \\
\hline
$O_6$  & $-\frac{\kappa ^3}{192 \pi ^2 m^2}  \textcolor{red}{-\frac{c_a^2 \kappa \lambda}{32 \pi^2 m^2}-\frac{c_a \kappa^2 \mu}{64 \pi^2 m^4} +\frac{c_a^3 \lambda \mu}{48 \pi^2 m^6}+\frac{c_a^2 \kappa \mu^2}{32 \pi^2 m^6}-\frac{c_a^3 \mu^3}{96 \pi^2 m^8}
}$  \\
\hline
\end{tabular}
\label{tab:realSingSL}
\subfloat[Warsaw (Tree level)]{
\begin{tabular}{|*{2}{c|}}
\hline
$Q_H$  &  $\frac{\mu  c_a^3}{6 m^6}-\frac{\kappa  c_a^2}{2 m^4}$  \\
\hline
$Q_{\text{H}\square}$  &  $-\frac{c_a^2}{2m^4}$  \\
\hline
\end{tabular}
\label{tab:realSingWT}
\subfloat[Warsaw  (one-loop level)]{
\begin{tabular}{|*{2}{c|}}
\hline
$Q_H$  &  $-\frac{\kappa ^3}{192 \pi ^2 m^2} -\frac{c_a^2 \kappa \lambda}{32 \pi^2 m^2}-\frac{c_a \kappa^2 \mu}{64 \pi^2 m^4} +\frac{c_a^3 \lambda \mu}{48 \pi^2 m^6}+\frac{c_a^2 \kappa \mu^2}{32 \pi^2 m^6}-\frac{c_a^3 \mu^3}{96 \pi^2 m^8}$  \\
\hline
$Q_{\text{H}\square}$  &  $-\frac{\kappa^2}{384 \pi^2 m^2} -\frac{c_a^2 \lambda}{32 \pi^2 m^4}-\frac{5 c_a \kappa \mu}{192 \pi^2 m^4}+\frac{11 c_a^2 \mu^2}{384 \pi^2 m^6}$  \\
\hline
\end{tabular}
\label{tab:realSingWL}
\end{table*}

\item The output is obtained in \mmaInlineCell{Code}{"Warsaw"} basis and is formatted as a detailed table in
\newline
\mmaInlineCell{Code}{ TraditionalForm .}
There is provision to export the result in LaTeX~ format. Table~\ref{tab:realSingWT} is actually obtained from the output of the code above.
We can compute the same in \mmaInlineCell{Code}{"SILH"} basis as well and for that we have to use:

\,

\begin{mmaCell}{Input}
\mmaDef{fieldewrss}model\(\pmb{\to}\)"ewrss",
\mmaDef{formPick}["SILH","Detailed2",
\mmaDef{res2},FontSize\(\pmb{\to}\)\mmaDef{Medium},
FontFamily\(\pmb{\to}\)"Times New Roman",

\end{mmaCell}

\,

Output of this can be found in Table~\ref{tab:realSingST}. Similarly, one-loop results can be obtained by changing the option value of `\mmaInlineCell{Input}{\mmaDef{outRange}}' to \mmaInlineCell{Code}{"Loop"}. The default value of \mmaInlineCell{Input}{\mmaDef{outRange}} is \mmaInlineCell{Code}{"All"}, which combines both tree and one-loop results. These resulting WCs can then be run down to the electro-weak scale, using \mmaInlineCell{Code}{RGFlow}. This function computes RG evolution for \texttt{Warsaw} basis effective operators (in leading log approximation) using anomalous dimension matrices available in Refs.~[9, 8, 10].

\item  Detail model building guide is available on the package web-documentation available here \href{https://effexteam.github.io/CoDEx/}{\faGithub} . Moreover, SMEFT matching results for multiple scalar extension are available in these articles [140, 141]. \vspace{2em}
\end{itemize}

\subsubsection{Developers' version: yet to be released}

\begin{itemize}\setlength\itemsep{1em}
\item {\bf Heavy-light mixed WCs and dimension-8:}

A module for incorporating effects from the mixed processes at one-loop including heavy fields and light fields is included. We generate these contributions by expanding the UV action around the light field classical solution obtained using the onshell relations of light fields. We implement the universal effective action formulae for the mixed heavy-light contributions and agree with that of Ref.~[116] (see Tables 1–5 in there). We evaluated this formula in \texttt{CoDEx} along with 16 BSM models to generate the mixed heavy-light WCs [141, 142, 140]. Modules for evaluation of one-loop processes involving fields with non-identical spins and incorporating SMEFT operators up to dimension-8 will be released shortly [123].

\item {\bf WCxF [133]:}

There are multiple packages available with different applications for the EFT matching and running of the WCs, and mapping these WCs to the observables [143]. It is desirable to have a data/result exchange format among these packages. WCxF is such a data exchange format widely used among EFT packages, see Ref.~[133]. \texttt{CoDEx} has two functions for exporting and importing data in WCxF. These functions are \mmaInlineCell{Input}{wcxfIn} and \mmaInlineCell{Input}{wcxfOut}. We briefly discuss the utilities of these functions below.

\begin{mmaCell}[moredefined={wcxfOut}]{Input}

\end{mmaCell}

\,

\begin{mmaCell}{Output}
This function prepares an output format
of WCs and effective
operators that can be exported to .json
file using Mathematica Export[] function.

\end{mmaCell}

\,

\begin{mmaCell}{Print}

\end{mmaCell}

\,

\begin{mmaCell}[moredefined={result,wcxfOut}]{Input}
(*A sample input --*)
wcxfOut[246 (*scale*),
result (* Numerical WCs*)]

\end{mmaCell}

\,

The output (which is suppressed here) is in WCxF template, and it can be interfaced with other available programs. In Ref.~[140], we have validated this by interfacing a .json file generated by \mmaInlineCell{Input}{\mmaDef{wcxfOut}} to DSixTools[107] package successfully.

\,

The function \mmaInlineCell{Input}{\mmaDef{wcxfIn}} takes WCxF files as input and provides output in \texttt{CoDEx} data format.

\,

\begin{mmaCell}[moredefined={wcxfIn}]{Input}

\end{mmaCell}

\begin{mmaCell}{Output}
This function takes the WCs and effective operators
imported from .json file
(using Mathematica Import function),
which is taken as input
and for that the output is
WCs and effective
operators in \mmaDef{CoDEx}
result conventions.

\end{mmaCell}

\begin{mmaCell}{Print}

\end{mmaCell}

\begin{mmaCell}{Input}

\end{mmaCell}

\begin{mmaCell}[moredefined={wcxfIn}]{Input}
wcxfIn[246 (*scale*),%(*wcxf data*)]

\end{mmaCell}

\begin{mmaCell}{Output}
\{\{q1Hl[1,1],-3.53103*10^-12\},...\}

\end{mmaCell}

\,

This output is in \texttt{CoDEx} readable format and the ellipses above represent other WCs in the list.

\item {\bf Identities:} The effective action evaluation for a BSM generates gauge-invariant structures, which do not directly map to the desired effective operator basis. We implement operator identities and equations of motion on the derived effective Lagrangian to cast the gauge-invariant terms to desired structures. These identities depends on the choice of the effective operator basis. The transformations like Fierz identities, SM field equations of motion, and SMEFT dimension-six operator identities are introduced in the developer version of \texttt{CoDEx}. In future developments, new modules will be available to capture the evanescent operator effects [144, 81, 145, 146], as well as these identities will be extended to incorporate effects from SMEFT dimension-8 operators [123].
\end{itemize}

\contribution[{\includegraphics[width=\textwidth]{Figures/matchete.pdf}}]{\texttt{Matchete:} Matching Effective Theories Efficiently}{Matthias König}{}\label{sec:matchete}

\matchete (MATCHing Effective Theories Efficiently) is a \texttt{Mathematica} package fully automating matching computations up to one-loop order, utilizing functional methods. The user supplies the UV theory by first defining the symmetry groups (both local and global), the fields and the coupling parameters with simple commands. With these definitions in place, the Lagrangian can be written in \texttt{Mathematica} language in a simple way and then passed to the matching function to integrate out fields that the user has defined as ``heavy". As a consequence of the functional matching procedure, no prior knowledge of the operators basis of the resulting effective theory is required. \matchete automatically generates the full set of effective operators and reduces it to a basis without any user input.

The \matchete package is free software under the terms of the GNU General Public License~v3.0 and is publicly available in the following GitLab repository:
\begin{center}
\href{https://gitlab.com/matchete/matchete}{\texttt{https://gitlab.com/matchete/matchete}}
\end{center}
This note only serves as a brief overview of the package; we refer the reader to Ref.~[49] for details.

\subsubsection{Matching Strategy}
\paragraph{Functional Methods and Expansion by Regions}
\matchete achieves the matching by directly computing the Wilsonian effective action, i.e. the contribution to the generating functional encoding only short-distance physics, corresponding to energy scales $E>\Lambda$, where $\Lambda$ is the matching scale (or in BSM contexts often called ``new-physics scale'')~[115, 147, 118, 117, 148]. To this end, one first splits the field content of the theory into Fourier modes with frequencies above (\emph{hard}) and below (\emph{soft}) the scale $\Lambda$:
\begin{align}
\phi = \phi_H+\phi_S\,.
\end{align}
Low-energy matrix elements are computed from the generating functional:
\begin{align}
Z[J_S] = \int \mathcal D \phi_S\,\mathcal D\phi_H\,
\exp\left\{ iS(\phi_S,\phi_H)+i\int d^4z \, J_s(z)\phi_S(z) \right\}\,,
\end{align}
from which the Wilsonian effective action $S_\Lambda$ is defined:
\begin{align}
\int\mathcal D \phi_H \,\exp\left\{iS(\phi_S,\phi_H) \right\}\equiv \exp\left\{ iS_\Lambda(\phi_S)\right\} \,.
\end{align}
This object can be calculated directly by means of a background field expansion, meaning each field is further split into classical fields~$\hat{\phi}_i$ and quantum fluctuations~$\eta_i$,
\begin{align}
\phi_i = \hat\phi_i + \eta_i\,,
\end{align}
and an expansion of $S(\hat\phi_S+\eta_S,\hat\phi_H+\eta_H)$ in the quantum fields is performed. Collecting hard and soft modes into a single multiplet, i.e. $\hat\phi$ and $\eta$ for the classical field and quantum fluctuation, this expansion reads:
\begin{align}
S(\hat\phi+\eta) = S(\hat\phi) + \eta_i \left[ \frac{\delta S}{\delta\eta_i} \right]\!(\hat\phi) + \frac{1}{2}\,\bar\eta_i \left[\frac{\delta^2 S}{\delta\eta_j\delta\bar\eta_i} \right]\!(\hat\phi)\;\eta_j + \mathcal{O}(\eta^3)\,.
\end{align}
The first term corresponds to the tree-level contributions, the second vanishes by virtue of the equations of motion and the third term encodes all the one-loop contributions. At tree level, the effective action is obtained by solving the equations of motions for the heavy fields, inserting them back into the full Lagrangian and expanding in the heavy mass. At one-loop level, the effective action is found by
\begin{align}
S_\Lambda^{(1)} = \pm\,\frac{i}{2}\int_h \frac{d^dk}{(2\pi)^d} \big\langle k \vert \mathrm{tr}\log Q \vert k \big\rangle \,,
\end{align}
where $Q_{ij} = \frac{\delta^2 S}{\delta\bar\eta_i\delta\eta_j}$ is the fluctuation operator. The subscript $_h$ on the integral denotes the fact that the integral is taken in the hard region, meaning the integration momentum $k$ is assumed to be of the order of the hard scale $\Lambda$. In practice, this is implemented by assigning a power-counting to the soft scales (masses and momenta of soft modes) and expanding the \emph{integrand} systematically to the desired order in the EFT counting. This \emph{expansion by regions}~[149, 150] simplifies the matching procedure as it computes directly the one-loop contributions to the matching coefficients without the need of having to evaluate matrix elements of the effective theory~[115].

The results obtained with the method outlined above yields an effective Lagrangian that is not manifestly gauge-invariant, as it contains open covariant derivatives, meaning expression of the form
\begin{align}
\mathcal L_\mathrm{eff} \supset X^{\mu\nu} D_\mu D_\nu\,,
\end{align}
which cannot be dropped since the covariant derivatives commute non-trivially. This is mitigated by the so-called \emph{covariant derivative expansion}, for details of which we refer the user to the literature~[151, 152, 153].

\paragraph{Basis Reduction}
After the matching procedure is performed, the obtained effective operators are not linearly independent. \matchete is able to handle the most common Lie algebras and performs simplifications of Dirac algebra using $d$-dimensional identities if they are available. To find a basis however, redundant operators still need to be eliminated. The first reduction technique is relating operators with covariant derivatives to each others by the means of integration-by-parts (IBP) identities, which can be derived by imposing total derivative operators to vanish, $D_\mu J^\mu = 0$. These IBP identities allow one to eliminate certain derivative operators in favor of others. As an example in a theory with charged Dirac fermions and a scalar, the following kind of reduction is achieved by this:
\begin{align}
\phi\,\bar\psi \gamma^\mu\gamma^\nu \{D_\mu, D_\nu\}\psi
=-2(D_\mu\phi)(\bar\psi \gamma_\mu \slashed D\psi)-2 \phi (\bar\psi\overleftarrow{\slashed D}\slashed D\psi)+\phi F^{\mu\nu} (\bar\psi i \Gamma_{\mu\nu}\psi)\,.
\end{align}
The choice of which operators are preferred is not unique, but it is advantageous to favor operators proportional to the equations of motions of the fields. In the above expression, the derivatives have been either traded for a field-strength tensor or act on the field operators in such a way, that the Dirac equation can be used to further simplify them.

Operators with derivatives acting on fields in the way they appear in their equations of motion\footnote{One colloquially uses the phrase ``proportional to the equations of motion" even though this is not technically correct.} can be further reduced by the means of appropriate field redefinitions. For scalars $\phi$, fermions $\psi$ and vector fields $A^\mu$ these operators are of the form $J D_\mu D^\mu \phi$, $J \slashed D\psi$ and $J_\nu D_\mu F^{\mu\nu}$ respectively. Redefining the fields by shifts proportional to the coefficient operator $J$ then eliminates these operators while introducing operators with fewer derivatives as well as operators at higher mass dimension. Applying the procedure iteratively, order by order in power-counting, then fully eliminates all operators proportional to the field equations of motion.

\matchete applies all reductions described above fully automatically without the user having to derive and specify any operator reduction identities. As of the time of writing, the list of possible reductions is not completely implemented yet. In particular, the current version of \matchete does not yet implement Fierz reductions, as these require the proper treatment of evanescent operators~[82]. This is left for a future release (see also Sec.~\ref{sec:matchete_outlook}).

\subsubsection{Usage Example}
In this section, we briefly outline a simple usage example. Once again, the reader is referred to Ref.~[49] for a more detailed user manual of the package including an installation guide. To demonstrate the features of \matchete, we match a simple model in which we supplement the SM with a singlet real scalar field $\phi$, as has been discussed in Refs.~[138, 139].
The Lagrangian of this model reads:\footnote{\matchete also allows for the inclusion of tadpoles as long as they are suppressed in the EFT counting compared to heavy-mass scales. Otherwise, the user will have to redefine the fields and manually remove the tadpole before using \matchete.}
\begin{align}
\mathcal L_\mathrm{UV} =
\mathcal{L}_\mathrm{SM}
+ \frac{1}{2}(\partial_\mu\phi)^2
- \frac{1}{2}M^2\phi^2
- \frac{\mu}{3!}\phi^3
- \frac{\lambda_\phi}{4!}\phi^4
- A\phi |H|^2- \frac{\kappa}{2}\phi^2 |H|^2\,. \label{eq:matchete_Lagrangian}
\end{align}
\matchete provides the full definitions of the SM and its Lagrangian as a simple macro.
After installing the package, it can be loaded via:
\begin{mmaCell}{Input}
<< \mmaDef{Matchete\(\,\grave\,\)}
\end{mmaCell}
Next, we load the SM Lagrangian from the predefined model file included with \matchete:
\begin{mmaCell}{Input}
LSM = LoadModel["SM", ModelParameters -> \{"\(\mu\)" -> mH, "\(\lambda\)" -> \mmaUnd{\(\lambda\)h}\}];
\end{mmaCell}
where we rename the Higgs mass parameter to \mmaInlineCell[]{Input}{mH} and the quartic Higgs coupling to \mmaInlineCell[]{Input}{\mmaUnd{\(\lambda\)h}}. We then define the heavy scalar using the command:
\begin{mmaCell}{Input}
DefineField[\mmaUnd{\(\phi\)}, Scalar, SelfConjugate -> True, Mass -> \{Heavy, \mmaUnd{M}\}]
\end{mmaCell}
The arguments supplied to the function indicate the spin of the field, the fact that it is real, the definition of the mass parameter and that it should be considered heavy. The remaining couplings in the Lagrangian~\eqref{eq:matchete_Lagrangian} are defined with:
\begin{mmaCell}{Input}
DefineCoupling[\mmaUnd{A}, SelfConjugate -> True]\\DefineCoupling[\mmaUnd{\(\kappa\)}, SelfConjugate -> True]\\DefineCoupling[\mmaUnd{\(\mu\)}, SelfConjugate -> True]\\DefineCoupling[\mmaUnd{\(\lambda\phi\)}, SelfConjugate -> True]
\end{mmaCell}
\matchete defines simple shortcuts for the fields and couplings when these commands are evaluated. Even though the full objects are more complicated, the user can input them in a simple form:
\begin{mmaCell}{Input}
LUV = \mmaDef{LSM} + FreeLag[\(\phi\)] - \mmaFrac{1}{3!}\(\mu\)[]\,\mmaSup{\(\phi\)[]}{3} - \mmaFrac{1}{4!}\(\lambda\phi\)[]\,\mmaSup{\(\phi\)[]}{4} \\- \mmaDef{A}[]\,Bar[H[i]]H[i]\(\phi\)[] - \mmaFrac{1}{2}\(\kappa\)[]\,Bar[H[i]]H[i]\mmaSup{\(\phi\)[]}{2};
\end{mmaCell}
Note that the command \mmaInlineCell[]{Input}{FreeLag[\(\phi\)]} automatically generates the kinetic and mass terms for the new field and only interaction terms have to be written out. We are now ready to integrate out the scalar at one-loop order. This is achieved by running the \mmaInlineCell[]{Input}{Match} command with appropriate arguments:
\begin{mmaCell}{Input}
LEFT = Match[\mmaDef{LUV}, LoopOrder -> 1, EFTOrder -> 6];
\end{mmaCell}
Here the first option defines the order at which the matching procedure is carried out while the second option denotes the fact that we want to obtain the effective Lagrangian up to dimension six. After this line is successfully evaluated, the object \mmaInlineCell[]{Input}{\mmaDef{LEFT}} contains redundant operators, as described earlier. Reductions using IBP identities and field redefinitions are then performed by running:
\begin{mmaCell}{Input}
LEFTOnShell = \mmaDef{LEFT} //EOMSimplify;
\end{mmaCell}
The user can choose to only perform IBP identities without field redefinitions to obtain the Green's basis by using the \mmaInlineCell[]{Input}{GreensSimplify} command. The object \mmaInlineCell[]{Input}{\mmaDef{LEFTOnShell}} then contains the operators together with their matching coefficients. The full output is cumbersome, but individual contributions can be isolated using the \mmaInlineCell[]{Input}{SelectOperatorClass} command. As an example, to show only the leptonic four-fermion operator, one uses:
\begin{mmaCell}{Input}
SelectOperatorClass[\mmaDef{LEFTOnShell},\{Bar[\mmaDef{l}],\mmaDef{e},Bar[\mmaDef{e}],l\},0] //NiceForm
\end{mmaCell}
\begin{mmaCell}{Output}
\mmaFrac{1}{6} \!\!\(\hbar\)\,\mmaSup{\(\overline{Ye}\)}{rs}\mmaSub{Ye}{tp}\,\mmaSup{A}{2}\mmaFrac{1}{\mmaSup{M}{4}}\big(\mmaSup{\(\overline{e}\)}{s}\,\(\cdot\)\,\mmaSub{P}{L}\,\(\cdot\)\,\mmaSup{l}{ir}\big)\big(\mmaSubSup{\(\overline{l}\)}{i}{t}\,\(\cdot\)\,\mmaSub{P}{R}\,\(\cdot\)\,\mmaSup{e}{p}\big)
\end{mmaCell}
where the second argument specifies the field content of the operator(s) to be extracted, and the last argument gives the number of derivatives. Here $\hbar$ should be understood as a loop counting factor that is equal to $1/(16\pi^2)$. The matching example with more details is included with the \matchete package in the example notebook \texttt{Examples/Singlet\_Scalar\_Extension.nb}.

\subsubsection{Outlook}\label{sec:matchete_outlook}
We conclude this note with a roadmap for features intended for future releases:
\begin{itemize}
\item The matching is currently done in strictly $d=4-2\epsilon$ dimensions. This prevents reductions of Dirac structures including Fierz rearrangements, because these hold only in four dimensions. When applied to $d$-dimensional operators, one has to account for evanescent contributions.
\item After evanescent contributions can be handled automatically, \matchete will be able to produce output that, in the case of SMEFT computations, can be directly compared to the Warsaw basis. In the future, \matchete will be able to automatically perform this identification as well as output the result in the \texttt{WCxf}~[133] format. An interface with other phenomenology codes and/or commonly used formats, such as \texttt{UFO}~[154], would be desirable as well.
\item At this time, \matchete does not allow integrating out heavy vector fields at the loop level. The reason for this is that these cannot be generally written down in a renormalizable fashion. In weakly-coupled theories, heavy vectors must arise from spontaneous symmetry breaking. This results in a complicated interplay between vectors, ghosts, and Goldstone bosons, especially in the background field gauge. So as to avoid having to derive and input all interactions manually, we wish to provide (semi-)automated methods to determine the broken phase Lagrangian.
\item With small changes to the matching procedure, it is possible to determine the EFT counterterms and, thereby, the RG functions. Implementing this functionality in \matchete will allow for finding the RG functions for intermediate-scale EFTs and vastly simplify sequential matching scenarios.
\end{itemize}
After the above list of features is included in the package, \matchete can be an integral part in a fully automated pipeline from a UV model down to phenomenology, and as such be a powerful tool for BSM phenomenology by taking away the laborious task of one-loop matching.

\contribution[{\includegraphics[width=0.35\textwidth]{Figures/logoMM.png}}]{\texttt{Matchmakereft}: a tool for tree-level and one-loop matching}{José Santiago}{}\label{sec:MME}

\texttt{Matchmakereft} is a computer tool that automates the tree-level and one-loop matching of arbitrary weakly-coupled UV models onto their EFT. Due to lack of space, we refer the reader to the original publication~[48] and the manual that comes with the installation and summarize here its main features and newest developments, and provide a simple but illustrative example.

\texttt{Matchmakereft} is written in \texttt{python}, making it very easy to install in different platforms, and it uses well-tested tools that include \texttt{Feynrules}~[155], \texttt{QGRAF}~[156], \texttt{Form}~[157] and \texttt{Mathematica} to perform an off-shell matching using diagrammatic methods in the background field gauge.

\texttt{Matchmakereft} takes advantage of the large degree of gauge and kinematic redundancy in off-shell matching to perform a significant number of non-trivial cross-checks, ensuring the validity of the resulting computation. It is also equipped to compute the RG equations of arbitrary EFTs and the off-shell (in)dependence of a set of local operators. \texttt{Matchmakereft} treats the kinematic and gauge dependence independently, leaving the latter arbitrary until the very end of the calculation. This increases its efficiency but it also makes \texttt{matchmakereft} an ideal tool to compute IR/UV dictionaries or to perform calculations in theories with arbitrary gauge structures.

Among the latest developments of \texttt{matchmakereft}, the calculation of amplitudes in chunks of a fixed number of diagrams and the ability to compute amplitudes in parallel, have significantly increased its efficiency (see the manual for details).

Let us now demonstrate many of the features of {\tt matchmakereft} with a concrete example involving two scalar fields, a light, but not massless, field $\phi$ and a heavy field $\Phi$. Our model is described by the Lagrangian:
\begin{equation}
\mathcal{L} = \frac{1}{2}(\partial_\mu \phi)^2 -\frac{1}{2}m_L^2 \phi^2 + \frac{1}{2} (\partial_\mu \Phi)^2 - \frac{1}{2} M_H^2 \Phi^2 - \frac{\lambda_0}{4!}\phi^4 - \frac{\lambda_2}{4}\phi^2 \Phi^2 - \frac{\kappa}{2}\phi^2 \Phi,
\label{lagrangian:uv}
\end{equation}
which we want to match to the EFT Lagrangian without the heavy scalar,
\begin{equation}
\mathcal{L}_{\rm EFT} = \frac{\alpha_{4k}}{2}(\partial_\mu \phi)^2
-\frac{\alpha_2}{2} \phi^2
- \frac{\alpha_4}{4!}\phi^4
- \frac{\alpha_6}{6!}\phi^6
- \frac{\tilde{\alpha}_6}{4!}\phi^3 \partial^2\phi
-\frac{\hat{\alpha}_6}{2}\left(\partial^2 \phi \right)^2.
\end{equation}
We will use this Lagrangian during off-shell matching. Subsequently, the kinetic term can be canonically normalized, and the redundant operators can be eliminated. Two of the three operators of dimension six are redundant. We choose $\phi^6$ as the independent operator. Using equations of motion we can readily find that:
\begin{align}
\phi^3 \partial^2\phi &\to -\alpha_2\phi^4 - \frac{1}{3!}\alpha_4\phi^6, \\
\left(\partial^2 \phi \right)^2 &\to  \alpha_2^2 \phi^2  + \frac{\alpha_2\alpha_4}{3}\phi^4 + \frac{\alpha_4^2}{36}\phi^6.
\end{align}
Eliminating these operators from the Lagrangian would induce the shifts
\begin{eqnarray}
\alpha_2 & \to & \alpha_2 + \alpha_2^2 \hat{\alpha}_6\\
\alpha_4 & \to & \alpha_4 - \tilde{\alpha}_6 \alpha_2 +4 \alpha_2\alpha_4\hat{\alpha}_6 \\
\alpha_6 & \to & \alpha_6 - 5\tilde{\alpha}_6\alpha_4 +10 \hat{\alpha}_6\alpha_4^2
\label{reductiontogreeneqs}
\end{eqnarray}
The coupling $\kappa$ of this model is a dimensionful coupling, and is expected to be parametrically of the order of the heavy mass scale $M_H$. Thus,  $\frac{\kappa}{M_H}$ is of $\mathcal{O}(1)$ and is kept throughout the matching procedure consistently.

The \feynrules file for the UV model, saved at {\tt two\_scalars.fr}, is shown below.
\begin{lstlisting}[language=Mathematica]
(* --- Contents of Feynrules file two_scalars.fr --- *)
M$ModelName = "two_scalars";
(* **** Particle classes **** *)
M$ClassesDescription = {
S[1] == {ClassName -> phiH, SelfConjugate -> True, Mass -> MH,
FullName -> "heavy"},
S[2] == {ClassName -> phi, SelfConjugate -> True, Mass -> mL,
FullName -> "light"}
(* *****   Parameters   ***** *)
M$Parameters = {
MH == {ParameterType -> Internal, ComplexParameter -> False},
mL == {ParameterType -> Internal, ComplexParameter -> False},
V == {ParameterType -> Internal, ComplexParameter -> False},
lambda0 == {ParameterType -> Internal, ComplexParameter -> False},
kappa == {ParameterType -> Internal, ComplexParameter -> False},
lambda2 == {ParameterType -> Internal, ComplexParameter -> False}
(* *****   Lagrangian   ***** *)
Ltot := Block[{mu},
+ 1/2 * del[phi,mu] *  del[phi,mu]  + 1/2 *del[phiH,mu] * del[phiH,mu]
- 1/2 * MH^2 * phiH^2 - 1/2 * mL^2 * phi^2
- lambda0 / 24 * phi^4 - kappa / 2  * phi^2 * phiH
- lambda2 / 4 * phi^2 * phiH^2
\end{lstlisting}

Note that we use the keyword {\tt FullName} to characterize each field as {\tt "heavy"} or {\tt "light"}. This is mandatory: {\tt matchmaker} uses this keyword to distinguish between fields that are integrated out and those that are light and are also present in the EFT. Also note that all the parameters that are used in the Lagrangian, masses as well as couplings, must be declared. In this example all parameters are real.

The \feynrules file for the EFT model, saved at {\tt one\_scalar.fr}, is:
\begin{lstlisting}[language=Mathematica]
(* --- Contents of Feynrules file for the EFT model  one_scalar.fr --- *)
M$ModelName = "one_scalar";
(* **** Particle classes **** *)
M$ClassesDescription = {
S[2] == {ClassName -> phi, SelfConjugate -> True, Mass -> 0,
FullName -> "light"}
(* *****   Parameters   ***** *)
M$Parameters = {
alpha4kin == {ParameterType -> Internal, ComplexParameter -> False},
alpha2mass == {ParameterType -> Internal, ComplexParameter -> False},
alpha4 == {ParameterType -> Internal, ComplexParameter -> False},
alpha6 == {ParameterType -> Internal, ComplexParameter -> False},
alpha6Rtilde == {ParameterType -> Internal, ComplexParameter -> False},
alpha6Rhat == {ParameterType -> Internal, ComplexParameter -> False}
(* *****   Lagrangian   ***** *)
Ltot := Block[{mu,mu2},
1/2 * alpha4kin * del[phi,mu] * del[phi,mu]
- 1/2 * alpha2mass * phi^2
- alpha4/24 * phi^4
- alpha6 * phi^6/720
- alpha6Rtilde/24 * phi^3 * del[del[phi,mu],mu]
- alpha6Rhat/2 * del[del[phi,mu],mu]  *  del[del[phi,mu2],mu2]
\end{lstlisting}

Note that we have included WCs (denoted by {\tt alpha}) also for the kinetic and mass terms (squared), as well as for all operators that are redundant solely due to the equations of motion.

In order for {\tt matchmakereft} to perform the reduction to the physical basis, we need to provide a set of relations that express the redundant WCs in terms of the irreducible ones, see Eq.~(\ref{reductiontogreeneqs}).  This is done at {\tt one\_scalar.red}:
\begin{lstlisting}[language=Mathematica]
(* --- Contents of one_scalar.red --- *)
finalruleordered = {
alpha6 -> - alpha6Rtilde * alpha4 *5 + alpha6Rhat * alpha4^2 * 10 + alpha6 ,
alpha4 -> alpha4 - alpha6Rtilde * alpha2mass + 4 * alpha6Rhat * alpha2mass * alpha4 ,
alpha4kin -> alpha4kin ,
alpha2mass -> alpha2mass +  alpha6Rhat * alpha2mass^2
\end{lstlisting}

Note that {\bf only} the  WCs corresponding to physical operators, among those appearing in the EFT Lagrangian and defined in the file \verb+one_scalar.fr+, must be present on the left hand side of the replacement rules in this file. The WCs corresponding to redundant operators appear only on the right hand side. When these rules are used, both redundant and non-redundant WCs have been matched and are known as functions of the parameters of the UV theory. The rules are therefore instructions on how to update the non-redundant WCs, to include the effect of the redundant ones.

With these files prepared we are ready to proceed with matching. In the matching directory, where {\tt two\_scalars.fr},{\tt one\_scalar.fr},{\tt one\_scalar.red} are present, we can run {\tt matchmakereft}:
\begin{lstlisting}[numbers=none,backgroundcolor=\color{codegris}]
\end{lstlisting}
upon which we enter the python interface
\begin{lstlisting}[numbers=none,backgroundcolor=\color{codegris}]
Checking for updates.
matchmakereft is up-to-date.

Welcome to matchmakereft v1.1.3
Please refer to SciPost Phys. 12, 198 (2022) arXiv:2112.10787 when using this code.
For documentation please check the manual in /installationdirectory/docs/manual.pdf

\end{lstlisting}
We first need to create the matchmaker models, i.e. the directories with all the necessary information for the UV and the EFT models. We do this by
\begin{lstlisting}[numbers=none,backgroundcolor=\color{codegris}]
matchmakereft> create_model two_scalars.fr
\end{lstlisting}
which has the response
\begin{lstlisting}[numbers=none,backgroundcolor=\color{codegris}]
Creating model two_scalars_MM. This might take some time depending on the complexity of the model
Model two_scalars_MM created
It took 7 seconds to create it.
\end{lstlisting}
We can now observe that the directory {\tt two\_scalars\_MM} is created. We proceed with creating the EFT model
\begin{lstlisting}[numbers=none,backgroundcolor=\color{codegris}]
matchmakereft> create_model one_scalar.fr
Creating model one_scalar_MM. This might take some time depending on the complexity of the model
Model one_scalar_MM created
It took 7 seconds to create it.
\end{lstlisting}
The {\tt one\_scalar\_MM} directory is now created as well, and we are ready for the matching calculation. This is performed by the {\tt match\_model\_to\_eft} command:
\begin{lstlisting}[numbers=none,backgroundcolor=\color{codegris}]
matchmakereft> match_model_to_eft two_scalars_MM one_scalar_MM
\end{lstlisting}
Upon completion, the results of the matching are stored in the UV model directory, in this case {\tt two\_scalars\_MM}. The file {\tt two\_scalars\_MM/MatchingProblems.dat} contains troubleshooting information in case the matching procedure failed. In our case it is an empty list, indicating no problems:
\begin{lstlisting}
problist = {}
\end{lstlisting}

The result of the matching procedure is stored in {\tt two\_scalars\_MM/MatchingResults.dat}, a Mathematica file with a list of lists of replacement rules. These matching results can also be seen in printed form in Appendix C of the original \mme publication~[48]. In this example, the kinetic operator receives a one-loop matching correction and, therefore, $\phi$ is no longer canonically normalized. A field redefinition is needed to obtain a canonically normalized theory on which we can apply the corresponding redundancies to go to the physical basis. \Mme does these two processes (canonical normalization and going to the physical basis) automatically. The resulting WCs in the physical basis, up to one loop order and $O\left(\frac{\kappa^{2n}}{M_H^{2n}}\frac{m_L^2}{M_H^2}\right)$ can also be seen in printed form in Appendix C of Ref.~[48].

As mentioned above, \mme can do many more things than just finite matching. One can for instance compute the RG equations for both models and check the consistency of the logarithmic terms from the RG equations and the finite matching. We refer to the manual for a detailed explanation.

We would like to finish this overview of \mme by mentioning two projects we are currently working on in the Granada group, that will either end up being part of \mme or strongly use it for their development. Current matching programs perform the matching off-shell, producing the effective Lagrangian in a so-called Green's basis, in which some redundant operators are not required to describe physical, on-shell amplitudes. The usual process is to reduce this Green's basis to a physical basis, either manually (as it is currently done in \texttt{matchmakereft}) or in an automated way, as currently done by \texttt{matchete}~[49]. We are looking into side-stepping this reduction step by performing an on-shell matching. This has a number of technical complications that have been essentially solved for the tree-level matching. We are working on extending the on-shell matching to the one-loop level. More details can be found in Section~\ref{section:chala}.

Another project we are currently working on was mentioned by R. Fonseca in his talk but is not covered elsewhere in this document (it has a significant overlap with the content of Section~\ref{section:misiak} by other authors). Even with current codes that automate the process of one-loop matching, repeating the calculation for different models is re-iterative and, in the case of many fields, can be computationally very expensive. Our idea is to define a generic model, in which the gauge structure is not fixed a priori and the field multiplicity simply appears as a dummy flavor index. This general EFT can be built with a single multiplet of real scalars, Weyl fermions and gauge bosons. We have defined the most general EFT with this generic field content up to mass dimension six and we are computing its RG equations. All the loop integrals, tensor reduction and kinematic projections are performed in this generic EFT in such a way that the calculation of the RG equations for any specific EFT can be obtained by means of a straight-forward group-theoretic calculation. The next step will be to define a generic theory with light and heavy fields and perform the finite one-loop matching for it.

\contribution{\texttt{Sym2Int}: Automatic generation of EFT operators}{Renato M. Fonseca}{}\label{sec:Sym2Int}

EFTs are a powerful tool for probing potential new physics in a model-independent way. At a time when there is a lack of clarity on how to extend the SM, its related EFTs have been receiving an increasing amount of attention. For example, the number of SMEFT operators have been counted with several techniques in the last few years, up to high mass dimensions. Building an explicit basis of operators is more complicated, but here too there has been notable progress. I will go through my recent work on using the software packages \texttt{GroupMath} and \texttt{Sym2Int} to automatically build explicit bases of operators for EFTs, given their fields and symmetries.

\subsubsection{Using computers to generate Lagrangians}

With EFTs one can study the low energy consequences of a model without
having to handle or even know all of its intricacies; by integrating
out the heavy fields one can obtain a Lagrangian which describes well
the large distance behavior of the original theory. However, the reduction
in the number of fields comes at the cost of introducing a potentially
large set of local operators of high dimension. As such, the very
first step in the study of an effective field theory is to establish
a basis of operators which encodes all possible interactions between
the light fields. Put simply, one needs a Lagrangian. As the reader
is certainly aware, most theories are invariant under some group of
transformations --- for example the Lorentz group and/or a gauge
group --- therefore the task of finding all interactions is inseparable
from the problem of finding invariant combinations of products of
representations of some group.

There is a long history of using computers in particle physics, given
the complexity of the calculations one needs to perform. Indeed, there
are many codes specialized in various tasks, from calculating Feynman
rules all the way to generating events at colliders. However, at the
very beginning of such a stack of programs, it would be useful to
have one more code which, to some degree, alleviates the heavy burden
on the user of having to provide the full Lagrangian of the model.
To the best of my knowledge, \texttt{SARAH} [158]\texttt{
}and \texttt{Susyno} [159] were the first codes to
build symmetry-invariant Lagrangians (superpotentials, to be more
specific) with the user having only to specify the representation
of the (super)fields under some gauge group.

In the case of \texttt{Susyno}, it builds the most general renormalizable
supersymmetric (SUSY) Lagrangian allowed by the gauge symmetry, as
well as the soft SUSY breaking terms, and then applies known formulas
in order to derive the two-loop renormalization group equations for
all the free parameters (such as the gauge and Yukawa couplings).
The group theory code used to perform the first step grew over time
and was eventually released as the standalone \texttt{GroupMath} program
[160]. It is also used in other packages, such as
\texttt{SARAH 4} [161], \texttt{Pyr@te 2+} [162],
\texttt{DRalgo} [163] and \texttt{Sym2Int} [164].
The aim of this last program, which will be the main topic from now
on, is to go from \uline{sym}metries \uline{to} \uline{int}eractions:
given some input fields (that is, representations of the Lorentz and
gauge groups) it computes all operators up to some mass dimension.
\texttt{Sym2Int} is currently being extended in order to be able to
provide explicit expressions for the operators.\footnote{See also the \texttt{AutoEFT} code mentioned in~[165].}

\subsubsection{The current \texttt{Sym2Int} program}

Details on how to use the program can be found in [164],
as well as on the program's webpage. For illustrative purposes, with
the following input one can obtain the list of SMEFT interactions
up to dimension 8:\\

\texttt{gaugeGroup{[}SM{]} \textasciicircum = \{SU3, SU2, U1\};}

\texttt{fld1 = \{\textquotedbl u\textquotedbl , \{3, 1, 2/3\}, \textquotedbl R\textquotedbl ,
\textquotedbl C\textquotedbl , 3\};}

\texttt{fld2 = \{\textquotedbl d\textquotedbl , \{3, 1, -1/3\},
\textquotedbl R\textquotedbl , \textquotedbl C\textquotedbl ,

\texttt{fld3 = \{\textquotedbl Q\textquotedbl , \{3, 2, 1/6\}, \textquotedbl L\textquotedbl ,
\textquotedbl C\textquotedbl , 3\};}

\texttt{fld4 = \{\textquotedbl e\textquotedbl , \{1, 1, -1\}, \textquotedbl R\textquotedbl ,
\textquotedbl C\textquotedbl , 3\};}

\texttt{fld5 = \{\textquotedbl L\textquotedbl , \{1, 2, -1/2\},
\textquotedbl L\textquotedbl , \textquotedbl C\textquotedbl ,

\texttt{fld6 = \{\textquotedbl H\textquotedbl , \{1, 2, 1/2\}, \textquotedbl S\textquotedbl ,
\textquotedbl C\textquotedbl , 1\};}

\texttt{fields{[}SM{]} \textasciicircum = \{fld1, fld2, fld3, fld4,
fld5, fld6\};}

\texttt{GenerateListOfCouplings{[}SM, MaxOrder -> 8{]};}

The number of interactions in this particular EFT --- up to dimension
15 and for an arbitrary number of flavors (which is set to 3 in the
code above) --- can be found in a couple of hours. As far as I know,
this is the only cross-check of the numbers provided for the first
time in [89] using the the Hilbert series.

It is worth noting that \texttt{Sym2Int} also computes some important
information on the symmetry of flavor indices. For example, $L_{i}L_{j}HH$
is found to be symmetric under the exchange of $i\leftrightarrow j$,
while $Q_{i}Q_{j}Q_{l}L_{k}$ has a more complicated symmetry. Let
us distinguish an \textit{operator}, where we expand flavor indices
(for $n$ flavors there are $n\left(n+1\right)/2$ operators of the
form $LLHH$) from a\textit{ Lagrangian term} which are tensors in
flavor space (there is just one term of the form $LLHH$). Then, the
information mentioned earlier can be used to infer the minimum number
of terms needed to write a model's Lagrangian. In the case of three
$Q$'s and one $L$, even though there are four ways of contracting
the various spinor and $SU(2)_{L}$ indices, it is possible to write
all of them as a single Lagrangian term $\omega_{ijkl}Q_{i}Q_{j}Q_{l}L_{k}$
(see [166] for a more thorough discussion of this

\subsubsection{An upgrade: building operators and terms explicitly}

Counting operators and terms is not the same as building a Lagrangian.
For the latter one needs to know the explicit form of each interaction,
which implies knowing how the various field indices are contracted.
It is also worth highlighting that neither the current version of
\texttt{Sym2Int} nor the Hilbert series method can be used to determine
how the derivatives --- if there is any --- are applied to the fields.

We desire a model's Lagrangian, but I would like to point out that
the Lagrangian often consists of a complicated function of the field
components with a very low information density. Consider for example
the interactions between a fermion transforming under the fundamental
representation of $SU(n)$ and the gauge bosons of this group. The
relevant Clebsch-Gordan factors coincide with the entries $T_{ij}^{A}$
of the matrices of the fundamental representation of $SU(n)$, containing
a total of $n^{2}\left(n^{2}-1\right)$ of entries. Given that fields
can be redefined, one has to wonder what is the information contained
in all these numbers: in principle, observable quantities should depend
on these Clebsch-Gordan factors through combinations of the tensor
$T$ with no open indices, such as $T_{ij}^{A}T_{ji}^{A}$ (see for
instance [167]).

It is therefore conceivable that in the future we might find it unnecessary
to know a model's Lagrangian in full detail. With this cautionary
remark, the fact remains that at present we do need these complicated
expressions for the study of models in general, and EFTs in particular.
For this reason, the \texttt{Sym2Int} code is in the process of being
upgraded such that it not only counts but also computes explicitly
operators and terms. In the following I will make a few remarks concerning
this upgrade.

\paragraph{Output for humans vs output for other codes}

While designing a program which automatically generates lists of operators,
one must take into account whether the results are to be used directly
by a person, or fed into some other software package -- such as \texttt{FeynRules}
[155] or \texttt{Matchmakereft} [48].
In the second case, the readability of the result is not so important.
For example, the two possible ways of contracting three color octets
can be described by a $2\times8\times8\times8$-dimensional tensor
$c_{aijk}$ containing the relevant Clebsch-Gordan factors. But even
in this rather modest example, a human might find it hard to read
such data format.

A related problem is that these Clebsch-Gordan factors are not unique.
In the previous case, we are free to take any invertible combination
of the two contractions, $c_{aijk}\rightarrow X_{aa^{\prime}}c_{a^{\prime}ijk}$
with $\textrm{det}\left(X\right)\neq0$, and one can also make a rotation
in the eight-dimensional space of the octet, leading to the change
$c_{aijk}\rightarrow U_{ii^{\prime}}U_{jj^{\prime}}U_{kk^{\prime}}c_{ai^{\prime}j^{\prime}k^{\prime}}$
for some unitary matrix $U$.

Currently, the package \texttt{GroupMath} contains a function \texttt{Invariants}
which, subject to time and memory constraints, can compute the above
group theory data for any product of representations of a semi-simple
Lie algebra. However, due to the two issues discussed above, there
is room for improvement. Conveniently, the gauge symmetry of many
models is completely described by $SU(n)$ groups (and perhaps $U(1)$'s
which are easy to handle). Motivated by this, a future version of
\texttt{GroupMath }will include $SU(n)$-specific code capable of
providing the same information as \texttt{Invariants} but using instead
the tensor method which is familiar to physicists (see chapter 4 in
[168]). The numerical output will still consist of
large tensors with Clebsch-Gordan factors, but now it is also possible
to include a human readable string which identifies each of them.
For the product of three octets, writing them as $3\times3$ traceless
matrices $\Omega_{\;j}^{i}$, $\Omega_{\;j}^{\prime i}$ and $\Omega_{\;j}^{\prime\prime i}$,
the two invariant combinations alluded above would be $\Omega_{\;j}^{i}\Omega_{\;k}^{\prime j}\Omega_{\;i}^{\prime\prime k}$
and $\Omega_{\;j}^{i}\Omega_{\;k}^{\prime\prime j}\Omega_{\;i}^{\prime k}$;
the \texttt{GroupMath} program will be able to provide the value of
these two expressions as well as the corresponding formulas/strings.

The approach to Lorentz indices is similar: for each invariant expression
the program keeps track of a tensor (with the $SO(1,3)$ Clebsch-Gordan
factors) as well as a human readable string involving the familiar
scalars, spinors, gamma matrices, derivatives and field strength tensors.
If there are fermions in the interaction, with the $\gamma^{\mu}$
and $C$ matrices one can replace open spinor indices with vector
indices. Then, from an expression containing a set of open vector
indices only, one can construct all Lorentz invariants by contracting
it in all possible ways with the metric and Levi-Civita tensors, $\eta_{ab}$
and $\epsilon_{abcd}$. As for derivatives, they should be distributed
in all possible ways by the different fields in the operator. This
approach of contracting indices and applying derivatives in every
conceivable way leads to a highly redundant list of Lorentz invariant
expressions; such a list can easily be pruned by looking for linear
relations among the various polynomials.

\paragraph{Dealing with gauge indices and Lorentz indices separately}

Building operators explicitly implies handling potentially very large
polynomials of the numerous field components, thus calculations are
time consuming even for low dimensional interactions. In each step
of the design of a code that handles explicit operators, one must
therefore be aware of this problem and try to mitigate its impact.

In my opinion, an important step in reducing the computational and
memory requirements of handling operators is to segregate gauge indices
from the space-time indices of spinor and vector fields. If $c_{g_{1}g_{2}\cdots}$
and $\kappa_{l_{1}l_{2}\cdots}$ are the Clebsch-Gordan factors for
the two type of indices, instead of working with the full operator
$\mathcal{O}\equiv c_{g_{1}g_{2}\cdots}\kappa_{l_{1}l_{2}\cdots}\Phi_{g_{1},l_{1}}\Phi_{g_{2},l_{2}}\cdots$,
it is preferable to manipulate --- somehow --- the simpler polynomials
$\mathcal{O}_{G}\equiv c_{g_{1}g_{2}\cdots}\Phi_{g_{1}}\Phi_{g_{2}}\cdots$
and $\mathcal{O}_{L}\equiv c_{l_{1}l_{2}\cdots}\Phi_{l_{1}}\Phi_{l_{2}}\cdots$
involving only one type of indices.

Some may consider this to be an elementary observation but, as the
following example will show, it is not trivial to implement it. Consider
that both the gauge and the Lorentz groups are described by the $SU(2)$
group, and ignore for simplicity that some fields (fermions) anti-commute.
Now take some field $\Phi$ which is a doublet under both groups:
both $\mathcal{O}_{G}=\epsilon_{g_{1}g_{2}}\Phi_{g_{1}}\Phi_{g_{2}}$
and $\mathcal{O}_{L}=\epsilon_{l_{1}l_{2}}\Phi_{l_{1}}\Phi_{l_{2}}$
are identically zero, so whatever is our algorithm to handle these
two polynomials we would conclude that there is no $\Phi^{2}$ operator.
And yet, by considering the two indices together, we readily find
that $\mathcal{O}\equiv\epsilon_{g_{1}g_{2}}\epsilon_{l_{1}l_{2}}\Phi_{g_{1},l_{1}}\Phi_{g_{2},l_{2}}$
is not null. What is happening here is that both the Lorentz indices
$l_{i}$ and the gauge indices $g_{i}$ are contracted anti-symmetrically,
so by considering each set of indices separately, we get vanishing
polynomials, while the operator $\mathcal{O}$ is symmetric --- not
anti-symmetric --- under the change $\left(g_{1},l_{1}\right)\leftrightarrow\left(g_{2},l_{2}\right)$.

A possible solution is to distinguish equal fields in the simpler
polynomials $\mathcal{O}_{G}$ and $\mathcal{O}_{L}$; in the previous
example, $\mathcal{O}_{G}=\epsilon_{g_{1}g_{2}}\Phi_{g_{1}}\Phi_{g_{2}}^{\prime}$
and $\mathcal{O}_{L}=\epsilon_{l_{1}l_{2}}\Phi_{l_{1}}\Phi_{l_{2}}^{\prime}$
are no longer null, as long as we keep $\Phi^{\prime}\neq\Phi$. A
solution along this lines is viable, and indeed it has been successfully
tested in \texttt{Sym2Int}. Without going into details, I will simply
note that one must still account, in the end, for the fact that $\Phi^{\prime}$
is the same as as $\Phi$.\footnote{Setting back $\Phi=\Phi^{\prime}=\cdots$ at the end of the calculation
can have non-trivial consequences. To see this, using the same quantum
numbers as before, let us consider the quartic operators $\Phi^{4}$.
We start by differentiating the fields, thus considering instead interactions
of the type $\Phi\Phi^{\prime}\Phi^{\prime\prime}\Phi^{\prime\prime\prime}$.
In that case, there are two independent polynomials $\mathcal{O}_{G}$,
and well as two independent polynomials $\mathcal{O}_{L}$ (after all
the product $\boldsymbol{2}\times\boldsymbol{2}\times\boldsymbol{2}\times\boldsymbol{2}$
contains two singlets). There is therefore a total of four operators
but once we require that $\Phi^{\prime\prime\prime}=\Phi^{\prime\prime}=\Phi^{\prime}=\Phi$
they all become proportional to a single expression.} Things become even more complicated when fields have flavor.

\paragraph{Flavor}

It turns out that in some models (for example in SMEFT), some representations
of the symmetry group are present more than once. We tend to account
for this mysterious multiplicity by adding a flavor index to the relevant
fields, $\Phi\rightarrow\Phi_{i}$, and write Lagrangians with flavored
tensors, such as the Yukawa matrices. Each of them is associated with
what I previously called a Lagrangian term, which may correspond to
many operators once the indices are expanded.

Flavor constitutes a significant complication. If all the fields in
an interaction are distinct, such as in $L_{i}^{*}L_{j}Q_{k}^{*}Q_{l}$,\footnote{The precise form of the spinor indices is irrelevant for the discussion.}
accounting for multiple flavors is trivial. The problem are those
cases containing repeated fields, such as $L_{i}^{*}L_{j}L_{k}^{*}L_{l}$,
as they will have some underlying symmetry under permutations of the
flavor indices. One approach to these troublesome cases might be to
consider each flavor combination at a time, effectively expanding
the flavor indices. Not only is such an approach very taxing computationally,
but it is also not clear how the results are to be presented ---
ideally one would like to undo the expansion of the indices and write
as few terms in the Lagrangian as possible.

As the operator dimension increases, so does the number of intervening
fields. At some point we are bound to find cases such as $Q_{i}Q_{j}Q_{k}L_{l}$
in SMEFT, where the same field appears three or more times. The relevant
permutation group is then no longer abelian, and we may have to consider
mixed (or multi-term) symmetries in the flavor indices (see [166]).

This problem is most acute in a model where only one index distinguishes
all scalars and all fermions; such model is therefore a good test-bed
for \texttt{Sym2Int}'s new code. Indeed, we may represent a generic
EFT as a theory with an arbitrary number of real scalars $\phi_{i}$
and Weyl fermions $\psi_{i}$ with covariant derivatives
\begin{equation}
D_{\mu}\psi_{i}=\partial_{\mu}\psi_{i}-\mathrm{i}gt_{ij}^{A}V_{\mu}^{A}\psi_{j}\textrm{ and }D_{\mu}\phi_{a}=\partial_{\mu}\phi_{a}-\mathrm{i}g\theta_{ab}^{A}V_{\mu}^{A}\phi_{b}
\end{equation}
where $t^{A}$ and $\theta^{A}$ are generic hermitian matrices (the
$\theta^{A}$ must also be anti-symmetric). It was precisely in this
general framework that the two-loop RG equations for dimension 4 operators were derived in [169, 170, 171].
We may however extend it to non-renormalizable operators, not just
to study complicated flavor symmetries, but also to derive important
results for a general EFT. Indeed we are currently in the process
of deriving the one-loop RG equations for this EFT (up to dimension-six interactions),
as well as the matching relations between it and a general renormalizable
UV model [172]. Once these are known, it
becomes unnecessary to go back to the computation of loops and amplitudes
for every single model; the task of computing RG equations and matching conditions
for a particular model is reduced to writing a Lagrangian, which involves
only some algebra and group theory.

\subsubsection{Outlook}

The \texttt{Sym2Int} code, as it exists now, lists and counts all
the possible operators in an effective field theory, up to some cutoff.
It is currently being extended to also build them explicitly, while
handling in a satisfactory way the fact that some fields have flavor.
With the approach being pursued, the presence of flavor does not significantly
affect the computational time, but it does pose some complicated problems
of a conceptual nature which still have to be addressed. Side-stepping
these for now, the code was already used to compute all Green operators
in SMEFT up to dimension 10, for an arbitrary number of fermion flavors,
with their counting matching the correct result.

\contribution[{\includegraphics[width=0.35\textwidth]{Figures/logo_SOLD.png}}]{\texttt{SOLD}: Towards the one-loop matching dictionary in the SMEFT}{José Santiago}{}\label{sec:SOLD}

The benefit of using EFTs to compute experimental observables for different UV models is undeniable, but EFTs are much more powerful than that. They really shine when the top-down approach is combined with power-counting arguments, which allow for a complete classification of observable UV models in the form of IR/UV dictionaries. The EFT is a double expansion in the mass dimension of the operators and the loop order of the WCs, with operators of higher dimension being less relevant at low energies and WCs of higher loop order being smaller than lower loop ones. Eventually, contributions of high enough mass dimension and/or loop order are smaller than the experimental precision and can be disregarded as unobservable.

Given a finite order in mass dimension and loop order, the complete set of UV models that contribute to and EFT up to these orders can be exhaustively classified. Once the complete classification is achieved one can go one step further and compute the resulting WCs for all the UV models in the list. This way we obtain true IR/UV dictionaries that relate the WCs of the EFT (and therefore to experimental observables via the bottom-up approach) to all UV models that contribute to the EFT at the particular order the dictionary has been computed. These dictionaries can be used in an iterative way to obtain a complete map of the implications of experimental data on models of new physics. Indeed, given a particular experimental constraint or anomaly, one can list all models that are restricted by (or explain in the case of anomalies) that particular measurement. With this list, we can then obtain all other experimental implications of these models, that can be tested in a correlated way with different experimental data.

The tree-level, dimension-six dictionary for the SMEFT was computed a few years back~[137], building on previous efforts~[173, 174, 175, 176]. This includes the most general extension of the SM with new scalars, fermions or vectors that contribute at tree level to the SMEFT operators up to mass-dimension six. While essential for the classification of large effects, this leading dictionary falls short when compared with the current precision of many experimental measurements, even more taking into account that certain WCs are only generated in weakly coupled extensions of the SM at the one-loop order. The first step towards the calculation of the one-loop, dimension-six IR/UV dictionary for the SMEFT has been recently published in~[177].

\subsection*{Towards the one-loop, dimension-six IR/UV dictionary in the SMEFT}

Contrary to the tree-level dictionary, in which the list of new fields is finite (a total of 48 new scalars, fermions or vectors appear in the dictionary), at one-loop order the list is infinite, due to the fact that some contributions only constrain the quantum numbers of the product of multiples fields rather than each of them independently. Despite this infinite number of models, it is still possible to classify them in the form of a finite number of conditions on these models. Still, the calculation of the complete one-loop dictionary for the SMEFT at dimension six is a formidable task and, with the help of the computer tool \texttt{matchmakereft}~[48], we have just finished the first step towards it~[177]. In particular, we have considered the most general extension of the SM with an arbitrary number of scalar and fermionic fields\footnote{The best strategy to perform the matching in models with heavy gauge bosons is currently under study in collaboration with J. Fuentes-Martín, P. Olgoso and A.E. Thomsen.} that contribute at one-loop order to those operators in the Warsaw basis~[4] which cannot be generated at tree level in any weakly-coupled extension of the SM. This includes all operators in the basis that contain at least one field-strength gauge tensor. Our results, that include the full classification of models, a partial list of the specific representations (up to a certain representation dimension, to be chosen by the user) and the actual value of the corresponding WCs are too long to be reported in print form, and we have published them in electronic form as a \texttt{Mathematica} package called \texttt{SOLD} (for Smeft One Loop Dictionary), available via its  \href{https://gitlab.com/jsantiago_ugr/sold}{\texttt{Gitlab} repository} (it can also trivially installed directly from a \texttt{Mathematica} notebook). Tools to create models suitable for the full one-loop matching using \texttt{matchmakereft} are also available within \texttt{SOLD} (see~[177] for details). The fact that \texttt{matchmakereft} performs the matching calculation in a gauge-blind fashion for most of the computation has significantly helped the development of the dictionary.

\contribution{MatchingDB: A format for matching dictionaries}{Juan Carlos Criado}{}\label{sec:MatchingDB}

MatchingDB is a format for the storage, exchange and exploration of EFT matching results up to one-loop order.
Its specification, both in human- and machine-readable forms, together with a Python interface, is located at the MatchingDB GitLab repository:
\begin{center}
\href{https://gitlab.com/jccriado/matchingdb/}{gitlab.com/jccriado/matchingdb}
\end{center}
It aims to provide:
\begin{itemize}
\item A unified language/tool-independent format for the communication of EFT matching results.
\item An efficient workflow for the practical use of matching dictionaries.
\end{itemize}
The format is particularly useful to store and publish large matching dictionaries, whose size might make it impractical to provide them in the form of human-readable equations and tables.
The Python interface makes it easy to interact with them, and quickly obtain the relevant information for specific applications.
An example of such a dictionary is the complete tree-level dictionary~[137] between the dimension-six SMEFT and any of its UV completions, which is provided in MatchingDB format under the \href{https://gitlab.com/jccriado/matchingdb/-/tree/main/dictionaries}{dictionaries} directory in the MatchingDB repository.
Other matching databases will be made available at the same place.

MatchingDB can also be employed as a data exchange format between tools, allowing to compare results from different matching codes, and providing an interface to connect them to packages for RG running and observable calculations.
It will be implemented as an output format in \texttt{MatchingTools}~[112] and \texttt{Matchmakereft}~[48].

Some of the features currently offered by the combination of the MatchingDB format and the accompanying Python package are: listing the heavy fields and UV couplings that generate a given WC; listing the EFT contributions of a given set of heavy fields; providing LaTeX output, both for the UV Lagrangian and for matching corrections; and providing numerical output that matches WCxf~[133] for the SMEFT.

\begin{figure*}
\centering
\includegraphics[width=\textwidth]{Figures/matchingdb-schema}
\caption{Diagram summarizing the MatchingDB JSON schema. Rectangles represent json objects, with the property names on the left column and the corresponding value types on the right. Capsule-shaped items represent a tuple, with the type of each of its items given in a larger font, and an short explanation of their meaning on a smaller one directly below. }
\label{fig:matchingdb-schema}
\end{figure*}

\subsubsection{Format definition}

MatchingDB data can be stored either as a plain-text JSON~[178] file or as an SQLite~[179] database.
The format is defined by its JSON schema, which is given in the
\href{https://gitlab.com/jccriado/matchingdb/-/raw/main/matchingdb.json}{matchingdb.json}
file at the root of the MatchingDB repository, using the JSON Schema language~[180].
A MatchingDB JSON file must comply with this schema, which can be checked using any of the standard tools for this purpose, such as the \texttt{jsonschema} Python package~[181].
Alternatively, MatchingDB data can be stored as an SQLite database, with a structure based on the JSON schema.
The SQLite representation may provide faster access to the information in larger databases.
Below, I describe the format informally, starting with the JSON representation.
A diagram summarizing it is provided in Fig.~\ref{fig:matchingdb-schema}.

The root value of the data must be an object with 4 name/value pairs, with names \texttt{"fields"}, \texttt{"couplings"}, \texttt{"constants"} and \texttt{"terms"}. The corresponding values should be arrays whose values are objects with the following structures:
\begin{description}
\item[\texttt{field}] Represents a heavy field in the UV theory that has been integrated out. It contains the following key/value pairs:
\begin{itemize}
\item \texttt{"name"} \emph{(string)}: a name identifying the field.
\item \texttt{"real"} \emph{(boolean)}: determines whether the field is real or complex.
\item \texttt{"representation"} \emph{(string)}: the group theory representation. The format for this is free in principle, but intended to be self-consistent in each database.
\item \texttt{"latex"} \emph{(string)}: math-mode LaTeX code representing the field.
\end{itemize}

\item[\texttt{coupling}] Represents a coupling present in the UV theory. Its name/value pairs are:
\begin{itemize}
\item \texttt{"name"} \emph{(string)}: a name identifying the coupling constant.
\item \texttt{"fields"} \emph{(array of string)}: a \textbf{sorted} list of the heavy fields that appear in the interaction.
\item \texttt{"real"} \emph{(boolean)}: determines whether the coupling constant is real or complex.
\item \texttt{"latex"} \emph{(string)}: math-mode LaTeX code representing the coupling constant.
\item \texttt{"latex\_interaction"} \emph{(string)}: math-mode LaTeX code representing the full interaction term in the UV theory, including the coupling constant.
\end{itemize}

\item[\texttt{constant}] Represents a scalar constant such as $\pi$ or a constant tensor such as the Kronecker delta, which appears in the matching results. Its name/value pairs are
\begin{itemize}
\item \texttt{"name"} \emph{(string)}: a name identifying the constant.
\item \texttt{"value"} \emph{(nested array of numbers or object)}: the numerical value of the constant. If the constant is a scalar, it should be a number. If it is a tensor, it should be provided as a nested array of numbers. Finally, if the constant is complex, it should be given as an object of the form: \texttt{\{"Re": ..., "Im": ...\}}, with the values having the real scalar o tensor type.
\item \texttt{"latex"} \emph{(string)}: math-mode LaTeX code representing the constant.
\end{itemize}
\item[\texttt{term}] Represents a term appearing in the matching corrections to some WCs in the EFT:
\begin{itemize}
\item \texttt{"coefficient"} \emph{(string)}: a name identifying the WC in which the term appears.
\item \texttt{"fields"} \emph{(array of string)}: a \textbf{sorted} list of the heavy fields that contribute to the term.
\item \texttt{"factors"} \emph{(array of *\_factor)}: a list of the factors that appear in the term, as described below.
\item \texttt{"free\_indices"} \emph{(array of string)}: a list of the free indices of the term, which must coincide with the ones of the corresponding coefficient, and appear at least once in the \texttt{"factors"} list.
\end{itemize}
\end{description}
The \texttt{"fields"} array in both couplings and terms should be sorted with the lexicographic order.
This allows to compare them efficiently to a set of heavy fields when querying the database.

The full analytical formulas for the matching corrections to the WCs in the EFT are stored in the \texttt{"factors"} property of the \texttt{term} objects.
The matching correction to any WC $\mathcal{C}$ is a sum of terms $\mathcal{T}^{(N)}$, with each term being a product of factors $\mathcal{F}^{(N)}_A$:
\begin{equation}
\mathcal{C} = \sum_N \mathcal{T^{(N)}}, \qquad
\mathcal{T}^{(N)} = \prod_A \mathcal{F}^{(N)}_A.
\end{equation}
Each factor is assumed to be of one of 7 possible forms.
Every form has an associated JSON type, all of them being tuples, that is, inhomogeneous arrays with a fixed type for each of its items:
\begin{description}
\item[$\mathcal{F} = b^n$] (\texttt{numerical\_factor}): a number $b$ to some power $n$. Represented as a tuple $[b, n]$ of type:\\ \texttt{[number, number]}.

\item[$\mathcal{F} = k^n_{ij\dots}$] (\texttt{constant\_factor}): a constant $k$, to some power $n$, with some flavor indices $i$, $j$, \ldots Represented as a tuple $[g, n,\allowbreak [i, j, \ldots]]$ of type:\\ \texttt{[string, number, array of string]}.

\item[$\mathcal{F} = g^{n(*)}_{ij\dots}$] (\texttt{coupling\_factor}): a coupling constant $g$, to some power $n$, possibly complex conjugated ($c = \rm True/False$), with some flavor indices $i$, $j$, \ldots \\ Represented as a tuple $[g, n, c,\allowbreak [i, j, \ldots]]$ of type:\\ \texttt{[string, number, boolean, array of string]}.

\item[$\mathcal{F} = M^n_{F,i}$] (\texttt{mass\_factor}): the mass of a field $F$, to some power $n$, with a flavor index $i$. Represented as a tuple $[F, i, n]$ of type:\\ \texttt{[string, string, number]}.

\item[$\mathcal{F} = (M^2_{F,i} - M^2_{G,j})^n$] (\texttt{mass\_difference\_factor}): the difference between the masses of two fields. Represented as a tuple $[F, i, G, j, n]$ of type:\\ \texttt{[string, string, string, string, number]}.

\item[$\mathcal{F} = \log(M^n_{F,i}/\mu^n)$] (\texttt{log\_mass\_factor}): the log of the mass of a field $F$, to some power $n$, with a flavor index $i$. Represented as a tuple $[F, i, n]$ of type:\\ \texttt{[string, string, number]}.

\item[$\mathcal{F} = \log(M^n_{F,i}/M^n_{G,j})$] (\texttt{log\_mass\_difference\_factor}):\\ the log of the ratio between the masses of two fields. Represented as a tuple $[F, i, G, j, n]$ of type:\\ \texttt{[string, string, string, string, number]}.
\end{description}
This completes the specification of the MatchingDB format in JSON form.

MatchingDB data can also be stored as an SQLite database.
The SQLite representation consists of 4 tables, named \texttt{fields}, \texttt{couplings}, \texttt{constants} and \texttt{terms}.
Their columns take their names from the keys of the associated objects.
Every object is stored as a row, with each of its values encoded as a string containing the corresponding JSON code.

\subsubsection{Python interface}

The \texttt{matchingdb} Python package is provided under the \href{https://gitlab.com/jccriado/matchingdb/-/tree/main/python}{\texttt{python}} directory of the MatchingDB repository.
It can be installed by cloning the repository, moving into the \texttt{python} directory and running
\begin{verbatim}
> pip install .
\end{verbatim}
The package exposes two classes: \texttt{JsonDB} and \texttt{SQLiteDB}, for creating and querying MatchingDB dictionaries, in the JSON and the SQLite representations, respectively.
Both classes have the same methods, with the same arguments and the same behaviour.
An existing database can be loaded as:
\begin{lstlisting}[language=ppython]
db = JsonDB.load("db.json")
# or SQLiteDB.load("db.sqlite")
\end{lstlisting}
A new one can be created through:
\begin{lstlisting}[language=ppython]
db = JsonDB.new("db.json", data=my_data)
# or SQLiteDB.new("db.sqlite", data=my_data)
\end{lstlisting}
where \texttt{my\_data} is the data to be included, as a JSON value that validates against the MatchingDB schema, represented as a Python object through the mapping displayed in Table~\ref{tab:matchingdb-json-python-mapping}.

\begin{table}
\centering
\begin{tabular}{ll}
\hline\noalign{\smallskip}
JSON & Python \\
\noalign{\smallskip}\hline\noalign{\smallskip}
object & dict \\
array & list or tuple \\
string & str \\
number & int or float \\
boolean & bool \\
\noalign{\smallskip}\hline
\end{tabular}
\caption{Mapping between JSON and Python types.}
\label{tab:matchingdb-json-python-mapping}
\end{table}

New items can be inserted into a database through:
\begin{lstlisting}[language=ppython]
db.insert(item, table)
\end{lstlisting}
where table is one of \texttt{"fields"}, \texttt{"couplings"}, \texttt{"const\\ants"}, or \texttt{"terms"}, and item is a dict complying with the corresponding sub-schema, which can be found at \texttt{\$defs/<table>/items} in the full schema.
Any changes made to a database must be saved with
\begin{lstlisting}[language=ppython]
\end{lstlisting}
in order for them to persist.

There are 4 methods to query a database:
\begin{itemize}
\item \texttt{select\_fields()}
\item \texttt{select\_couplings()}
\item \texttt{select\_constants()}
\item \texttt{select\_terms()}
\end{itemize}
They filter the items of each of the corresponding arrays according to certain conditions, and prepare the selected items in the desired output state.
A summary of their arguments is provided in Table~\ref{tab:matchingdb-python}.
All of them are optional.
If provided, the \texttt{name}, \texttt{fields} and \texttt{coeffi\\cients} arguments select only those items for which the corresponding property coincides with the given one.
\texttt{fields\_criterion} further configures the behaviour of the \texttt{fields} argument, following Table~\ref{tab:matchingdb-fields-criterion}.

\begin{table*}
\footnotesize
\hspace{-25pt}
\begin{tabular}{lll}
\hline\noalign{\smallskip}
& Arguments
& Description
\\
\noalign{\smallskip}\hline\noalign{\smallskip}
\multirow{2}{*}{\texttt{select\_fields()}}
& \texttt{name: str}
& If provided, select the field with the given name \\
& \texttt{output\_format: str}
& One of \{\texttt{"raw"} (default), \texttt{"pandas"}\}
\\
\noalign{\smallskip}\hline\noalign{\smallskip}
\multirow{4}{*}{\texttt{select\_couplings()}}
& \texttt{name: str} & If provided, select the coupling with the given name \\
& \texttt{fields: [str]} & If provided, select the couplings with the given set of fields \\
& \texttt{fields\_criterion: str} & One of \{\texttt{"equals"} (default), \texttt{"subset"}, \texttt{"supset"}\} \\
& \texttt{output\_format: str} & One of \{\texttt{"raw"} (default), \texttt{"pandas"}, \texttt{"latex"}\} \\
\noalign{\smallskip}\hline\noalign{\smallskip}
\multirow{2}{*}{\texttt{select\_constants()}}
& \texttt{name: str} & If provided, select the constant with the given name \\
& \texttt{output\_format: str} & One of \{\texttt{"raw"} (default), \texttt{"pandas"}\}
\\
\noalign{\smallskip}\hline\noalign{\smallskip}
\multirow{5}{*}{\texttt{select\_terms()}}
& \texttt{coefficient: str} & If provided, select the terms contributing to a given coefficient \\
& \texttt{fields: [str]} & If provided, select the terms with the given set of fields \\
& \texttt{fields\_criterion: str} & One of \{\texttt{"equals"} (default), \texttt{"subset"}, \texttt{"supset"}\} \\
& \texttt{output\_format: str} & One of \{\texttt{"raw"} (default), \texttt{"pandas"}, \texttt{"latex"}, \texttt{"numeric"}\} \\
& \texttt{parameters: Iterable} & The non-vanishing parameters for numerical output \\
\noalign{\smallskip}\hline
\end{tabular}
\caption{Summary of the querying methods of the \texttt{JsonDB} and \texttt{SQLiteDB} classes of the \texttt{matchingdb} Python package.}
\label{tab:matchingdb-python}
\end{table*}

\begin{table}
\centering
\begin{tabular}{ll}
\hline\noalign{\smallskip}
Value & Select an \texttt{item} if: \\
\noalign{\smallskip}\hline\noalign{\smallskip}
\texttt{"equals"} & \texttt{item["fields"] == sorted(fields)} \\
\texttt{"subset"} & \texttt{set(item["fields"]) <= set(fields)} \\
\texttt{"supset"} & \texttt{set(item["fields"]) >= set(fields)} \\
\noalign{\smallskip}\hline
\end{tabular}
\caption{Possible values and behavior of the \texttt{fields\_criterion} argument to the \texttt{select\_couplings()} and \texttt{select\_terms()} methods of the \texttt{JsonDB}, and \texttt{SQLiteDB} classes. In the right column, \texttt{fields} refers to the argument of these methods with the same name.}
\label{tab:matchingdb-fields-criterion}
\end{table}

The \texttt{output\_format} argument must be one of the following strings:
\begin{description}
\item[\texttt{"raw"} (default).] The method returns a list of the selected items, represented as Python values, following Table~\ref{tab:matchingdb-json-python-mapping}.
\item[\texttt{"pandas"}.] The method returns a Pandas~[182] dataframe with a simplified version of the output. Provides an easy way to visually explore the data.
\item[\texttt{"latex"}.] Returns math-mode LaTeX code representing the output. \texttt{select\_couplings()} returns a single string with the formula for the selected sector of the UV Lagrangian. \texttt{select\_terms()} returns a dict with coefficient names as keys and strings with their selected terms as values. The other 2 methods do not accept this option.
\item[\texttt{"numeric"}.] Available in \texttt{select\_terms()} only. Returns a function for the numerical evaluation of WCs. The additional \texttt{parameters} argument of \texttt{select\_terms()} must be set to an iterable containing all the names of all the parameters that will be set to non-vanishing values. This allows to prepare the output function to be efficiently evaluated many times.
\end{description}
The function returned by \texttt{select\_terms()} when \texttt{output\\\_format="numeric"} takes two arguments:
\begin{description}
\item[\texttt{parameters: dict}.] A dict whose keys are the UV parameters (couplings, masses and matching scale), and whose values are NumPy~[183] arrays with one axis for each of the indices of the corresponding parameter.
Masses are named \texttt{"M\_<field>"} where \texttt{"<field>"} is the name of the field. The matching scale is \texttt{"mu"}. The values of constants in the \texttt{"constants"} array of the database are included automatically.

\item[\texttt{expand\_flavor: bool} (optional).]\phantom{.}
\begin{itemize}
\item If \texttt{False} (default), the output of the function is a dictionary with WC names as keys, and NumPy arrays as values, with one axis per EFT flavor index of the coefficient.
\item If \texttt{True}, flavor indices are expanded, and the output becomes a dictionary with keys of the form \texttt{"<coeff>\_<flavor\_indices>"}, and values being either float (if real) or dictionaries with keys  \texttt{"Re"}, \texttt{"Im"} and floats as values (if complex). If the names given to the coefficients in the database follow the conventions of WCxf, the output will be compatible with the \texttt{values} section of a WCxf WC file.
\end{itemize}
\end{description}

\subsubsection{Example}

The \href{https://gitlab.com/jccriado/matchingdb/-/tree/main/python/examples}{python/examples} directory contains examples showcasing several features of the \texttt{matchingdb} package.
Here, I will present a brief example on how to extract different types of information from the tree-level dimension-six SMEFT matching dictionary~[137] (given in MatchingDB format at \href{https://gitlab.com/jccriado/matchingdb/-/raw/main/dictionaries/smeft_dim6_tree.json}{dictionaries/smeft\_dim6\_tree\\.json}). To load this dictionary, one can do:
\begin{lstlisting}[language=ppython]
from matchingdb import JsonDB
db = JsonDB.load("smeft_dim6_tree.json")
\end{lstlisting}
One can then get a summary view of all terms that appear in the WC for the $\mathcal{O}_{ll}$ Warsaw operator through:
\begin{lstlisting}[language=ppython]
coefficient="ll", output_format="pandas"
\end{lstlisting}
\begin{lstlisting}[language=poutput]
coefficient fields     couplings
0          ll   [S1]    [yS1, yS1]
1          ll  [Xi1]  [yXi1, yXi1]
2          ll    [B]    [glB, glB]
3          ll    [W]    [glW, glW]
4          ll    [W]    [glW, glW]
\end{lstlisting}
From this table, one can see which UV fields and couplings generate this operator at tree level.
Information on these fields can be obtained as:
\begin{lstlisting}[language=ppython]
name="S1", output_format="pandas"
\end{lstlisting}
\begin{lstlisting}[language=poutput]
name   real representation
0   S1    False       S(1,1,1)
\end{lstlisting}
All the matching corrections to any WC induced by the $\mathcal{S}_1$ field can be found via:
\begin{lstlisting}[language=ppython]
fields=["Xi"], output_format="pandas"
\end{lstlisting}
\begin{lstlisting}[language=poutput]
coefficient fields   couplings
0          ll   [S1]  [yS1, yS1]
\end{lstlisting}
This implies that $\mathcal{S}_1$ only contributes to $\mathcal{O}_{ll}$.
The formula for this contribution in LaTeX code can be obtained through:
\begin{lstlisting}[language=ppython]
fields=["Xi"], output_format="latex"
\end{lstlisting}
\begin{lstlisting}[language=poutput]
{'ll': ' + \\frac{  \\left(y_{\\mathcal...
\end{lstlisting}
which renders as:
+ \frac{  \left(y_{\mathcal{S}_1}\right)_{ajl}^{*} \left(y_{\mathcal{S}_1}\right)_{aik}}{  M_{\mathcal{S}_1,a}^{2}}

This formula can also be numerically evaluated given the values of the UV parameters: the coupling $y_{\mathcal{S}_1}$ and the mass $M_{\mathcal{S}_1}$. This is done as:
\begin{lstlisting}[language=ppython]
evaluator = db.select_terms(
parameters={"yS1", "M_S1"},

import numpy as np
n = 2  # number of S1 flavors
parameters = {
"yS1": np.random.random(size=(n, 3, 3)),
"M_S1": np.random.random(size=(n,)),

evaluator(parameters, expand_flavor=True)
\end{lstlisting}
\begin{lstlisting}[language=poutput]
{'ll_0000': ..., 'll_0001': ...,
'll_0002': ...,  ...}
\end{lstlisting}
The final output here has the format of the \texttt{values} field of the WCxf format, and is thus suitable for interfacing with numerical tools for running and the calculation of observables.
The \texttt{evaluator()} function is optimized for multiple evaluations, with the corresponding database lookup being performed once, in the \texttt{select\_terms()} call.

\contribution{RG equations in generic EFTs\label{section:misiak}}{Miko{\l}aj Misiak and Ignacy Na{\l\c{e}}cz}{}

The SMEFT RG equations at one loop were determined in
Refs.~[8, 9, 10], and the RG equations for the LEFT WCs have been determined in the past, dependently on phenomenological needs, sometimes up to the four-loop level~[29]. However, the two-loop SMEFT RG equations remain unknown. Instead of deriving the RG equations separately in various Effective Field
Theories (EFTs), one can consider a generic case, as done for
renormalizable models (see below).  Particular results are then found
by substitutions. Our goal in the current (ongoing) project is to
evaluate one-loop RG equations for all the dimension-six operators in the generic case.

\subsubsection{Operator classification}\label{class}

We shall consider EFTs of the LEFT and SMEFT type, where the gauge
group is an arbitrary finite product of finite-dimensional Lie
groups. Real scalars $\phi_a$ and left-handed spin-$\frac12$ fermions
$\psi_k$ are going to be the matter fields. Obviously, any complex
scalar can always be written in terms of two real ones, while
right-handed spin-$\frac12$ fermions can always be described as
charge-conjugated left-handed ones.

To simplify our calculation in its initial steps, we assume a discrete
symmetry $\{\phi \to -\phi, ~\psi \to i\psi\}$. It turns out to forbid
all odd-dimensional operators. However, it gives no restriction on
even-dimensional ones when they have already been required to
be Lorentz-invariant. In more generic EFTs, where no such discrete
symmetry is imposed, RG equations for odd-dimensional operators can be
obtained from the even-dimensional case by treating one of the scalar
fields as an auxiliary gauge-singlet that takes a fixed vacuum
expectation value.

The generic EFT Lagrangian we are going to consider reads
\begin{align}
{\mathcal L} &= -\frac14 F^A_{\mu\nu} F^{A\,\mu\nu} + \frac12 (D_\mu\phi)_a (D^\mu\phi)_a + i \bar\psi_j (\not\!\!D \psi)_j- \frac12 m^2_{ab} \phi_a\phi_b -\frac{1}{4!} \lambda_{abcd} \phi_a \phi_b \phi_c \phi_d\nonumber\\
&\quad-\frac12 \left(Y^a_{jk} \phi_a \psi^T_j C \psi_k + {\rm h.c.}\right) + {\mathcal L}_{\rm g.f.} + {\mathcal L}_{\rm FP}+ \frac{1}{\Lambda^2} \sum Q_N + {\mathcal O}\left(\frac{1}{\Lambda^4}\right), \label{Leff}
\end{align}
where $Q_N$ stand for linear combinations of dimension-six operators
multiplied by their WCs.

Let us absorb the gauge couplings into the structure constants and generators. Then
$F^A_{\mu\nu}  = \partial_\mu V^A_\nu - \partial_\nu V^A_\mu - f^{ABC} V^B_\mu V^C_\nu$,
$(D_\rho F_{\mu\nu})^A  = \partial_\rho F^A_{\mu\nu} - f^{ABC} V_\rho^B F^C_{\mu\nu}$,
$(D_\mu\phi)_a = \left(\delta_{ab}\partial_\mu + i\theta^A_{ab} V^A_\mu\right) \phi_b$, and
$(D_\mu\psi)_j = \left(\delta_{jk}\partial_\mu + i t^A_{jk} V^A_\mu\right) \psi_k$.

RG equations for couplings at the dimension-four interactions in
Eq.~\eqref{Leff} were calculated up to two loops in a series of papers
by Machacek and Vaughn almost 40 years
ago~[169, 170, 171]. Some
corrections to their results were found more recently in
Refs.~[184, 185]. Even at the one-loop
level, it is only the latter paper~[185] that we
fully agree with. Generic RG equations for the gauge and Yukawa couplings at
the four- and three-loop levels, respectively, were recently determined
in Ref.~[186, 187] by combining information on results in various specific
models. Earlier three-loop results for the gauge coupling beta functions
can be found in Refs.~[188, 189].

We perform our one-loop calculation off shell, using the
background-field gauge method. Therefore, we need to begin with
classifying all the dimension-six operators in the off-shell
basis. Such operators are gauge invariant but many linear combinations
of them vanish by the Equations of Motion (EOM). Once the RG equations in the
off-shell basis are found, one needs to pass to the on-shell basis
where no linear combination of operators vanishes by the EOM. Only in
the latter case are the RG equations gauge-parameter independent.

The off-shell basis we use consists of the following 22 terms\footnote{
Very similar off-shell and on-shell bases of dimension-six operators
were presented by R.~Fonseca and J.~Santiago at the SMEFT-Tools workshop. We
have verified that all the differences between our setups are due to
convention choices only.}
\begin{align}
Q_1    &= \frac{1}{6!} W^{( 1)}_{abcdef}\, \phi_a \phi_b \phi_c \phi_d \phi_e \phi_f,&
Q_2    &= \frac{1}{4} W^{( 2)}_{abcd}\, (D_\mu\phi)_a (D^\mu\phi)_b \phi_c \phi_d,\nonumber\\
Q_3    &= \frac12 W^{( 3)}_{ab}\, (D^\mu D_\mu\phi)_a (D^\nu D_\nu\phi)_b,&
Q_4    &= \frac12 W^{( 4)A}_{ab}\, (D^\mu\phi)_a (D^\nu\phi)_b F^A_{\mu\nu},\nonumber\\
Q_5    &= \frac14 W^{( 5)AB}_{ab}\, \phi_a \phi_b F^A_{\mu\nu}F^{B\,\mu\nu},&
Q_6    &= \frac14 W^{( 6)AB}_{ab}\, \phi_a \phi_b F^A_{\mu\nu}\widetilde F^{B\,\mu\nu},\nonumber\\
Q_7    &= \frac12 W^{( 7)AB}\, \left(D^\mu F_{\mu\nu}\right)^A \left( D_\rho F^{\rho\nu}\right)^B,&
Q_8    &= \frac{1}{3!} W^{( 8)ABC}\, F^{A\,\mu}_{~~~\;\nu}F^{B\,\nu}_{~~~\;\rho}F^{C\,\rho}_{~~~\;\mu},\nonumber\\
Q_9    &= \frac{1}{3!} W^{( 9)ABC}\, F^{A\,\mu}_{~~~\;\nu}F^{B\,\nu}_{~~~\;\rho}\widetilde F^{C\,\rho}_{~~~\;\mu},&
Q_{10} &= \frac18 W^{(10)}_{jkln}\, (\psi_j^T C \psi_k)(\psi_l^T C \psi_n) + {\rm h.c.},\nonumber\\
Q_{11} &= \frac14 W^{(11)}_{jkln}\, (\bar\psi_j \gamma_\mu \psi_k)(\bar\psi_l \gamma^\mu \psi_n),&
Q_{12} &= i W^{(12)}_{jk}\, \bar\psi_j \left(\not\!\! D \not\!\! D \not\!\! D\psi\right)_k,\nonumber\\
Q_{13} &= \frac12 W^{(13)}_{a,jk}\, \phi_a (D_\mu\psi)_j^T C (D^\mu\psi)_k + {\rm h.c.},&
Q_{14} &= W^{(14)}_{a,jk}\, \phi_a \psi_j^T C (D_\mu D^\mu\psi)_k + {\rm h.c.},\nonumber\\
Q_{15} &= \frac12 W^{(15)}_{a,jk}\, \phi_a (D_\mu\psi)_j^T C \sigma^{\mu\nu} (D_\nu\psi)_k + {\rm h.c.},&
Q_{16} &= \frac{i}{2} W^{(16)}_{ab,jk}\, \phi_a\phi_b\, \left[ (\bar\psi\,\raisebox{3.5mm}{}^{\leftarrow}\hspace{-4mm} \not\!\! D)_j \psi_k- \bar\psi_j (\not\!\! D\psi)_k \right],\nonumber\\
Q_{17} &= W^{(17)}_{ab,jk}\, \phi_a(D_\mu \phi)_b\, \bar\psi_j \gamma^\mu \psi_k,&
Q_{18} &= \frac{1}{12} W^{(18)}_{abc,jk}\, \phi_a\phi_b\phi_c\, \psi_j^T C \psi_k + {\rm h.c.},\nonumber\\
Q_{19} &= \frac12 W^{(19)A}_{a,jk}\, \phi_a F^A_{\mu\nu}\, \psi_j^T C \sigma^{\mu\nu} \psi_k + {\rm h.c.},&
Q_{20} &= i W^{(20)A}_{jk}\, F^A_{\mu\nu}\, \left[ (\bar\psi\,\raisebox{3.5mm}{}^{\leftarrow}\hspace{-3.3mm} D^\nu)_j \gamma^\mu \psi_k - \bar\psi_j \gamma^\mu (D^\nu \psi)_k\right],\nonumber\\
Q_{21} &= i W^{(21)A}_{jk}\, \widetilde F^A_{\mu\nu}\, \bar\psi_j\gamma^\mu (D^\nu \psi)_k,&
Q_{22} &= W^{(22)A}_{jk}\, \left(D^\mu F_{\mu\nu}\right)^A \bar\psi_j\gamma^\nu \psi_k,
\end{align}
where $W^{(N)}$ contain both the WCs and the necessary