Version 3 of {\tt RunDec} and {\tt CRunDec}

TL;DR

This paper introduces updated versions of { t RunDec} and { t CRunDec} software packages that incorporate higher-order corrections for precise calculations of strong coupling and quark masses in QCD.

Contribution

The new versions include five-loop beta function corrections, four-loop decoupling effects, and advanced conversion formulas for heavy quark masses, enhancing computational accuracy.

Findings

Implementation of five-loop QCD beta function corrections.

Inclusion of four-loop decoupling effects.

Enhanced conversion formulas for heavy quark masses.

Abstract

We present new versions of the packages {\tt RunDec} and {\tt CRunDec} which can be used for the running and decoupling of the strong coupling constant and quark masses. Furthermore several conversion formulae for heavy quark masses are implemented. The new versions include five-loop corrections of the QCD beta function and four-loop decoupling effects. Furthermore, various relations between the heavy quark mass defined in the $\overline{\rm MS}$ and other short-distance schemes are implemented to next-to-next-to-next-to-leading order. We discuss in detail the improvements and provide several examples which show how {\tt RunDec} and {\tt CRunDec} can be used in frequently occurring situations.

Tables

Table 1. Table 1: Uncertainty induced by truncation ( δ trunc subscript 𝛿 trunc \delta_{\mathrm{trunc}} ) and decoupling scale uncertainties ( δ b subscript 𝛿 𝑏 \delta_{b} and δ c subscript 𝛿 𝑐 \delta_{c} ) in the renormalization group running of α s subscript 𝛼 𝑠 \alpha_{s} from m τ subscript 𝑚 𝜏 m_{\tau} to M Z subscript 𝑀 𝑍 M_{Z} as a function of the number of loops used for the beta function.

$\#$ loops	$\delta =\sqrt{{\delta }_{\mathrm{trunc}}^2+{\delta }_b^2+{\delta }_c^2}$
2	$0.0054$
3	$0.0009$
4	$0.0005$
5	$0.0003$

Table 2. Table 2: Λ ( 5 ) superscript Λ 5 \Lambda^{(5)} calculated from α s ( 5 ) ​ ( M Z ) superscript subscript 𝛼 𝑠 5 subscript 𝑀 𝑍 \alpha_{s}^{(5)}(M_{Z}) using both the explicit and implicit routine. The difference decreases with increasing number of loops.

$\#$ loops	LamExpl	LamImpl	difference
1	$88.35$ MeV	$88.35$ MeV	$0$ MeV
2	$209.86$ MeV	$227.51$ MeV	$17.65$ MeV
3	$210.10$ MeV	$209.54$ MeV	$0.56$ MeV
4	$209.78$ MeV	$209.53$ MeV	$0.25$ MeV
5	$209.80$ MeV	$209.87$ MeV	$0.07$ MeV

Table 3. Table 3: Λ ( n f ) superscript Λ subscript 𝑛 𝑓 \Lambda^{(n_{f})} calculated from α s ( 5 ) ​ ( M Z ) = 0.1181 ± 0.0011 superscript subscript 𝛼 𝑠 5 subscript 𝑀 𝑍 plus-or-minus 0.1181 0.0011 \alpha_{s}^{(5)}(M_{Z})=0.1181\pm 0.0011 . The uncertainties due to truncation of the perturbative series and due to the two different methods are shown. For our analysis we use five-loop accuracy.

$n_f$	${\Lambda }^{\left(n_f\right)}$	exp. uncertainty	${\delta }_{\mathrm{trunc}}$	${\delta }_{\mathrm{diff}}$
3	$336$ MeV	$17$ MeV	$1$ MeV	$1$ MeV
4	$292$ MeV	$16$ MeV	$2$ MeV	$1$ MeV
5	$210$ MeV	$13$ MeV	$0$ MeV	$0$ MeV
6	$89$ MeV	$6$ MeV	$0$ MeV	$0$ MeV

Equations

$$(\mathtt{asMz})$$

$$(\mathtt{Mz})$$

$$(\mathtt{muc})$$

$$(\mathtt{mub})$$

$$(\mathtt{Mc})$$

$$(\mathtt{Mt})$$

$${\alpha }_s^{(5)}(M_Z)=0.1179\pm 0.0010\pm 0.0002$$

$${\alpha }_s^{(5)}(M_Z)=0.1177\pm 0.0009\pm 0.0002\pm 0.0003,$$

$$m_b^{(5)}(10\text{mbox}GeV)=\left(3610-\frac{{\alpha }_s-0.1189}{0.002}\cdot 12\pm 11\right)\text{mbox}MeV,$$

$$m_b^{(5)}(M_H)=2771\pm {8|}_{m_b}\pm {15|}_{{\alpha }_s}\text{mbox}MeV.$$

$$m_t^{\mathrm{PS}}$$

$$m_t^{\overline{\mathrm{MS}}}$$

$$M_t$$

$$M_b$$

Full text

PACS numbers: 12.38.-t 12.38.Bx 14.65.-q

Program summary

• Title of program: RunDec, CRunDec
• Available from: https://www.ttp.kit.edu/preprints/2017/ttp17-011/
• Computer for which the program is designed and others on which it is operable: Any computer where Mathematica or a C++ compiler is available.
• Operating system or monitor under which the program has been tested: Linux
• No. of bytes in distributed program including test data etc.: $400\,000$
• Distribution format: source code
• Keywords: Quantum Chromodynamics, running coupling constant, running quark mass, on-shell mass, $\overline{\rm MS}$ mass, threshold masses, decoupling of heavy particles
• Nature of physical problem: The value for the coupling constant of Quantum Chromodynamics, $\alpha_{s}^{(n_{f})}(\mu)$, depends on the considered energy scale, $\mu$, and the number of active quark flavours, $n_{f}$. The same applies to light quark masses, $m_{q}^{(n_{f})}(\mu)$, if they are, e.g., evaluated in the $\overline{\rm MS}$ scheme. In the programs RunDec and CRunDec all relevant formulae are collected and various procedures are provided which allow for a convenient evaluation of $\alpha_{s}^{(n_{f})}(\mu)$ and $m_{q}^{(n_{f})}(\mu)$ using the state-of-the-art correction terms. Furthermore, the programs contain several conversion formulae which allow to transfrom the $\overline{\rm MS}$ value of a heavy quark into other short-distance values or the on-shell definition.
• Method of solution: CRunDec is implemented in C++. For the solution of the differential equations an adaptive Runge-Kutta procedure has been implemented. The Mathematica version RunDec uses function provided by Mathematica to solve the differential equations.
• Restrictions on the complexity of the problem: It could be that for an unphysical choice of the input parameters the results are nonsensical.
• Typical running time: In general the run time for the individual operations is below a millisecond. In some cases it can increase to the order of a second.

1 Introduction

The fundamental parameters of QCD are the quark masses ($m_{q}$) and the strong coupling constant ($\alpha_{s}$) which are usually defined in the $\overline{\rm MS}$ scheme. As a consequence their numerical values depend on the renormalization scale $\mu$, which in general is of the same order as the energy scale of the considered process, and the number of active quark flavours $n_{f}$. In practice, $\alpha_{s}$ and $m_{q}$ are determined for certain values of $\mu$ and $n_{f}$. Afterwards they enter predictions which require other choices. It is thus crucial to have at hand precise relations for $m_{q}$ and $\alpha_{s}$ evaluated at different renormalization scales and different number of active flavours.

For the heavy quark masses there are two widely used renormalization schemes, the on-shell and the $\overline{\rm MS}$ scheme. Depending upon the considered physical process, there are further short-distance definitions which have advantageous properties and are thus often used to parametrize perturbative predictions. It is important to have available precise relations between the various schemes in order not to lose precision due to the transformations.

The Mathematica program RunDec [1] and its C++ counterpart CRunDec [2] achieve these requirements: they implement the highest available perturbative QCD corrections both for the running and decoupling of $\alpha_{s}$ and $m_{q}$, and for the conversion of the heavy quark masses among different schemes. In this paper we describe versions 3 of RunDec and CRunDec which contain several improvements. They are described in Section 2. Section 3 contains several practical examples. In this paper we refrain from presenting explicit formulae which are implemented in the routines. They can either be found in Ref. [1], in the original papers where the higher order corrections have been computed, or can easily be extracted from the source codes of RunDec and CRunDec.

The use of the Mathematica version RunDec is straightforward. After loading RunDec.m all Mathematica-modules are available and can immediately be used. CRunDec is written in C++ which offers several possibilities to access the implemented functions. In the following we present two skeleton files which exemplify the usage. They can easily be adapted to the problem at hand. On the one hand it is possible to work with pointers to an object of the type CRunDec and access the member functions correspondingly:

#include <iostream> #include "CRunDec.h" using namespace std; int main(){ CRunDec * <pointer> = new CRunDec(); double <result> = <pointer> -> <function>(<parameters>); return(0); }

Alternatively, also the following realization is possible:

#include <iostream> #include "CRunDec.h" using namespace std; int main(){ CRunDec <object>; double <result> = <object>.<function>(<parameters>); return(0); }

Several explicit examples are discussed in Section 3. They are illustrated with the help of Mathematica code; the corresponding C++ code can be found in the ancillary files to this paper. Section 4 contains a brief summary.

2 New and updated routines in RunDec and CRunDec

All routines connected to the running (of $\alpha_{s}$ and $m_{q}$) and to the decoupling of heavy quarks have been updated. In all of them it is now possible to use five-loop running accompanied by four-loop decoupling. We have also updated the routines establishing the relations between $\alpha_{s}$ and the QCD scale parameter $\Lambda$ which allow for a more precise extraction of $\Lambda$. The corresponding analytic expressions have been obtained in the following papers: The four-loop decoupling constants for $\alpha_{s}$ is available from Refs. [3, 4] and the one for the light quark masses has been computed in [5]. The five-loop anomalous dimension of the quark masses has been computed by two groups [6, 7, 8] and the five-loop beta function is available from [9, 10, 11].

As a second major update we have implemented the four-loop relation between the heavy quark masses defined in the $\overline{\rm MS}$ and on-shell scheme [12, 13]. In this context a couple of new routines have been introduced which allow the transformation between the $\overline{\rm MS}$ or on-shell and so-called threshold masses. In particular, we have implemented the potential subtracted (PS) [14], the 1S [15, 16, 17] and the renormalon subtracted (RS) [18] masses. In Section 3 we show how the new routines can be used to obtain the $\overline{\rm MS}$ mass from an experimentally determined threshold mass including the uncertainty on the strong coupling constant.

We refrain from providing analytic results for the new perturbative corrections which have been implemented in RunDec and CRunDec. One can either find them in the original papers or easily extract them from the Mathematica source code. For example, the decoupling constant which establishes the transition from $\alpha_{s}$ defined in the $n_{f}$-flavour theory to $\alpha_{s}$ in the $(n_{f}-1)$-flavour theory using the $\overline{\rm MS}$ definition of the heavy quark mass, can be found up to four loops with the help of

RunDec‘Modules‘as6to5ms /. setdec

The inverted relations and the ones where different renormalization schemes for the heavy quark mass have been chosen are contained in the variables as6to5si, as6to5os, as5to6ms, as5to6si and as5to6os. Analytic results up to three loops are given in Eqs. (20) to (25) of Ref. [1]. The coefficients of the QCD $\beta$ function and the mass anomalous dimension can be extracted from the variables setbeta and setgamma, respectively.

In the following subsections we provide merely the name of the function in case it has only been extended to higher loop order. For a detailed description of the arguments we refer to Refs. [1] and [2]. For the new functions and for the functions where additional arguments have been introduced111Note that the functions have been overloaded such that it is still possible to call them with the old argument list. The only exception is the argument handling the light quark masses in the relation between the $\overline{\rm MS}$ and on-shell masses as implemented in CRunDec, see Subsection 2.2. we display the complete function header.

2.1 Running and decoupling of $\alpha_{s}$ and $m_{q}$

The following functions related to the running of $\alpha_{s}$ and $m_{q}$ have been updated to five-loop accuracy:

LamImpl, LamExpl, AlphasLam,

AlphasExact, mMS2mMS, mMS2mSI, AsmMSrunexact,

mMS2mRGI, mMS2mRGImod.

Correspondingly we implemented the four-loop decoupling relations into the following routines:

DecAsUpOS, DecAsDownOS, DecAsUpMS, DecAsDownMS, DecAsUpSI, DecAsDownSI,

DecMqUpOS, DecMqDownOS, DecMqUpMS, DecMqDownMS, DecMqUpSI, DecMqDownSI,

DecLambdaUp, DecLambdaDown.

As a consequence also the functions AlL2AlH and AlH2AlL, which perform a combined running and decoupling can be used at five-loop order.

2.2 Quark mass relations

The functions implementing the transitions between the heavy quark masses defined in the on-shell and $\overline{\rm MS}$ scheme have been extended to four loops. Since the non-logarithmic four-loop term is not known analytically but has an uncertainty of the order of $0.2\%$ [13] we have introduced an additional argument for the following functions where this can be taken into account

mOS2mMS[mOS_,mq_,asmu_,mu_,nnf_,loops_,fdelm_] mOS2mMS[mOS_,mq_,asmu_,mu_,nnf_,loops_] mOS2mSI[mOS_,mq_,asM_,nnf_,loops_,fdelm_] mOS2mSI[mOS_,mq_,asM_,nnf_,loops_] mMS2mOS[mMS_,mq_,asmu_,mu_,nnf_,loops_,fdelm_] mMS2mOS[mMS_,mq_,asmu_,mu_,nnf_,loops_]

Here fdelm multiplies the non-logarithmic four-loop coefficient of order $\alpha_{s}^{4}$. The default value is 1. A $0.2\%$ variation is obtained with fdelm=0.998. The function prototype of the corresponding routines in CRunDec read

double mOS2mMS(double mOS, std::pair<double,double>* mq, double asmu, double mu, int nf, int nloops, double fdelm); double mOS2mMS(double mOS, std::pair<double,double>* mq, double asmu, double mu, int nf, int nloops); double mOS2mSI(double mOS, std::pair<double,double>* mq, double asM,int nf, int nloops, double fdelm); double mOS2mSI(double mOS, std::pair<double,double>* mq, double asM,int nf, int nloops); double mMS2mOS(double mMS, std::pair<double,double>* mq, double asmu, double mu, int nf, int nloops, double fdelm); double mMS2mOS(double mMS, std::pair<double,double>* mq, double asmu, double mu, int nf, int nloops);

The arguments of the following functions are unchanged:

mOS2mMSrun, mOS2mMSit, mMS2mOSrun.

A further improvement in these functions is related to the light quark mass effects. Up to now they have only been implemented up to two-loop order [19]. We have extended the implementation to three loops using the results of Ref. [20]. The light quark masses, $m_{q}$, are renormalized in the $\overline{\rm MS}$ scheme at their own renormalization scale $\mu_{q}$. In the previous versions of RunDec the argument mq was a list containing the light quark masses. For example, finite charm and bottom quark masses in the top quark mass relation are taken into account via {4.163,0.986}. After including the three-loop corrections the scale $\mu_{q}$ has to be specified and the argument mq has been extended to {{4.163,4.163},{0.986,3.0}} to specify $m_{b}(m_{b})$ and $m_{c}(3~{}\mbox{GeV})$. Note that it is still possible to provide a non-nested list. In that case the quark masses are interpreted as $m_{q}(m_{q})$.

In the C++ version modifications in the parameter passing were necessary, which are incompatible with older versions in case non-zero light quark masses are used. In version 3 an array of pairs of double variables has to be passed instead of a double array with four elements. The first element of each pair is the mass, the second is the scale. Note that the array must either contain four elements or can be a null pointer.

The four-loop relation between the $\overline{\rm MS}$ and on-shell quark mass can be used to derive the relations to the so-called threshold masses to the corresponding accuracy (see Ref. [13] for more details). In particular, we have implemented the following relations to the potential subtracted mass (PS), to the 1S mass (1S), to the renormalon subtracted mass (RS), and to a modified version of the latter (RSp):

mOS2mPS[mOS_,mq_,asmu_,mu_,muf_,nl_,loops_] mMS2mPS[mMS_,mq_,asmu_,mu_,muf_,nl_,loops_] mMS2mPS[mMS_,mq_,asmu_,mu_,muf_,nl_,loops_,fdelm_] mPS2mMS[mPS_,mq_,asnlmu_,mu_,muf_,nl_,loops_] mPS2mMS[mPS_,mq_,asnlmu_,mu_,muf_,nl_,loops_,fdelm_] mPS2mSI[mPS_,mq_,asfct_,muf_,nl_,loops_] mPS2mSI[mPS_,mq_,asfct_,muf_,nl_,loops_,fdelm_]

mOS2m1S[mOS_,mq_,asmu_,mu_,nl_,loops_] mMS2m1S[mMS_,mq_,asmu_,mu_,nl_,loops_] mMS2m1S[mMS_,mq_,asmu_,mu_,nl_,loops_,fdelm_] m1S2mMS[m1S_,mq_,asnlmu_,mu_,nl_,loops_] m1S2mMS[m1S_,mq_,asnlmu_,mu_,nl_,loops_,fdelm_] m1S2mSI[m1S_,mq_,asfct_,nl_,loops_] m1S2mSI[m1S_,mq_,asfct_,nl_,loops_,fdelm_]

mOS2mRS[mOS_,mq_,asmu_,mu_,nuf_,nl_,loops_] mMS2mRS[mMS_,mq_,asmu_,mu_,nuf_,nl_,loops_] mMS2mRS[mMS_,mq_,asmu_,mu_,nuf_,nl_,loops_,fdelm_] mRS2mMS[mRS_,mq_,asnlmu_,mu_,nuf_,nl_,loops_] mRS2mMS[mRS_,mq_,asnlmu_,mu_,nuf_,nl_,loops_,fdelm_] mRS2mSI[mRS_,mq_,asfct_,nuf_,nl_,loops_] mRS2mSI[mRS_,mq_,asfct_,nuf_,nl_,loops_,fdelm_]

mOS2mRSp[mOS_,mq_,asmu_,mu_,nuf_,nl_,loops_] mMS2mRSp[mMS_,mq_,asmu_,mu_,nuf_,nl_,loops_] mMS2mRSp[mMS_,mq_,asmu_,mu_,nuf_,nl_,loops_,fdelm_] mRSp2mMS[mRS_,mq_,asnlmu_,mu_,nuf_,nl_,loops_] mRSp2mMS[mRS_,mq_,asnlmu_,mu_,nuf_,nl_,loops_,fdelm_] mRSp2mSI[mRS_,mq_,asfct_,nuf_,nl_,loops_] mRSp2mSI[mRS_,mq_,asfct_,nuf_,nl_,loops_,fdelm_]

In the C++ version the function prototypes are given by

double mOS2mPS(double mOS, std::pair<double,double>* mq, double asmu, double mu, double muf, int nl, int nloops); double mMS2mPS(double mMS, std::pair<double,double>* mq, double asmu, double mu, double muf, int nl, int nloops); double mMS2mPS(double mMS, std::pair<double,double>* mq, double asmu, double mu, double muf, int nl, int nloops, double fdelm); double mPS2mMS(double mPS, std::pair<double,double>* mq, double asmu, double mu, double muf, int nl, int nloops); double mPS2mMS(double mPS, std::pair<double,double>* mq, double asmu, double mu, double muf, int nl, int nloops, double fdelm); double mPS2mSI(double mPS, std::pair<double,double>* mq, double (as)(double), double muf, int nl, int nloops); double mPS2mSI(double mPS, std::pair<double,double> mq, double (*as)(double), double muf, int nl, int nloops, double fdelm);

double mOS2m1S(double mOS, std::pair<double,double>* mq, double asmu, double mu, int nl, int nloops); double mMS2m1S(double mMS, std::pair<double,double>* mq, double asmu, double mu, int nl, int nloops); double mMS2m1S(double mMS, std::pair<double,double>* mq, double asmu, double mu, int nl, int nloops, double fdelm); double m1S2mMS(double m1S, std::pair<double,double>* mq, double asmu, double mu, int nl, int nloops); double m1S2mMS(double m1S, std::pair<double,double>* mq, double asmu, double mu, int nl, int nloops, double fdelm); double m1S2mSI(double m1S, std::pair<double,double>* mq, double (as)(double), int nl, int nloops); double m1S2mSI(double m1S, std::pair<double,double> mq, double (*as)(double), int nl, int nloops, double fdelm);

double mOS2mRS(double mOS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops); double mMS2mRS(double mMS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops); double mMS2mRS(double mMS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops, double fdelm); double mRS2mMS(double mRS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops); double mRS2mMS(double mRS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops, double fdelm); double mRS2mSI(double mRS, std::pair<double,double>* mq, double (as)(double), double nuf, int nl, int nloops); double mRS2mSI(double mRS, std::pair<double,double> mq, double (*as)(double), double nuf, int nl, int nloops, double fdelm);

double mOS2mRSp(double mOS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops); double mMS2mRSp(double mMS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops); double mMS2mRSp(double mMS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops, double fdelm); double mRSp2mMS(double mRS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops); double mRSp2mMS(double mRS, std::pair<double,double>* mq, double asmu, double mu, double nuf, int nl, int nloops, double fdelm); double mRSp2mSI(double mRS, std::pair<double,double>* mq, double (as)(double), double nuf, int nl, int nloops); double mRSp2mSI(double mRS, std::pair<double,double> mq, double (*as)(double), double nuf, int nl, int nloops, double fdelm);

The meaning of the arguments is in close analogy to the function implementing the $\overline{\rm MS}$-on-shell relation, see also the description of the individual modules in the Mathematica version. In particular, also the argument mq for light quark mass effects is present. However, in the relations involving threshold masses it is not active.

For the relations involving PS and RS masses additional factorization scales are introduced which are denoted by muf and nuf, respectively.222See the original publications [14] and [18] for more details. Note that for technical reasons it is necessary to provide just the function name and not the numerical value of $\alpha_{s}$ for those functions which convert to the scale-invariant mass (“SI”). This is denoted by asfact in the argument list. In the C++ version a pointer to a function taking the renormalization scale $\mu$ as argument has to be passed instead.

In RunDec there is also the routine AsRunDec which extracts from the renormalization scales specified in the input the necessary information about the decoupling steps. Since for some cases this might lead to inconsistencies we recommend not to use this module but use instead AlL2AlH or AlH2AlL, see also the examples in Section 3. For this reason we do not maintain this routine. This also concerns the versions of mOS2mMS and mMS2mOS with the headers mOS2mMS[mOS_,nnf_,loops_] and mMS2mOS[mMS_,nnf_,loops_].

3 Useful examples

In this section we present various concrete examples which are useful for many everyday situations. We discuss in detail numerical effects and provide the source codes which can easily be adapted to the own programs.

The examples require various input values which we choose as follows [21, 22, 23]

[TABLE]

The symbols inside the brackets show the notation used in RunDec and CRunDec. The central values (without uncertainties) are implemented in the variable NumDef (both in RunDec and CRunDec).

3.1 Running and decoupling

3.1.1 $\alpha_{s}$ at high energies

As a typical example we consider the extraction of $\alpha_{s}$ from the two- to three-jet event ratio as, for example, performed by CMS [24]. For $\mu=896$ GeV the value $\alpha_{s}(\mu)=0.0889\pm 0.0034$ has been obtained. Interpreting this result as the strong coupling in a six-flavour theory we can use

muin = 896; as6mu = 0.0889; as5Mz = AlH2AlL[as6mu, muin, {{6, Mt /. NumDef, 2*Mt /. NumDef}}, Mz /. NumDef, 5];

and obtain $\alpha_{s}^{(5)}(M_{Z})=0.1170$. Performing the decoupling for $\mu_{\rm dec}^{(t)}=M_{t}$ instead of $\mu_{\rm dec}^{(t)}=2M_{t}$ does not change the provided four digits. The same is true if four-loop (instead of five-loop) accuracy is used for the running. If, however, as6mu is interpreted in the five-flavour theory one obtains $\alpha_{s}^{(5)}(M_{Z})=0.1199$ after using

AlphasExact[as6mu, muin, Mz /. NumDef, 5, 5]

Note that AlH2AlL implements the on-shell decoupling constants. In case the $\overline{\rm MS}$ or scale-invariant (“SI”) version shall be used one has to combine AlphasExact and DecAsDownMS or DecAsDownSI to obtain $\alpha_{s}^{(5)}(M_{Z})$.

As a further example we consider the recent determination of $\alpha_{s}$ from the double-differential inclusive jet cross section as reported by the CMS collaboration in Ref. [25]. The measured transverse momentum ($p_{\mathrm{T}}$) interval is divided into several ranges and in each of them the strong coupling constant is extracted. In the last row of Tab. 5 of Ref. [25] one finds $\alpha_{s}^{(5)}(M_{Z})=0.1162_{-0.0062}^{+0.0070}$ which is obtained from an energy scale of $Q=1508.04$ GeV. In Ref. [25] two-loop running with five active flavours has been used to obtain $\alpha_{s}^{(5)}(Q)=0.0822_{-0.0031}^{+0.0034}$. Within RunDec this result can be obtained via

asmz = 0.1162; asmzplus = asmz + 0.0070; asmzminus = asmz - 0.0062; Q = 1508.04;

nloops = 2;

asQ = AlphasExact[asmz, Mz /. NumDef, Q, 5, nloops]; delasQplus = Abs[asQ - AlphasExact[asmzplus, Mz /. NumDef, Q, 5, nloops]]; delasQminus = Abs[asQ - AlphasExact[asmzminus, Mz /. NumDef, Q, 5, nloops]]; truncuncert = Abs[asQ - AlphasExact[asmz, Mz /. NumDef, Q, 5, nloops-1]]; totuncertplus = Sqrt[truncuncert^2 + delasQplus^2]; totuncertminus = Sqrt[truncuncert^2 + delasQminus^2];

where we have introduced an additional uncertainty due to the truncation of the perturbative series. We obtain $\alpha_{s}^{(5)}(Q)=0.0822_{-0.0032}^{+0.0035}$. Choosing five-loop accuracy, i.e. nloops = 5, leads to $\alpha_{s}^{(5)}(Q)=0.0822_{-0.0031}^{+0.0034}$ and thus has only a minor effect on the result.

At energy scales above a few hundred GeV also the top quark is an active quark flavour and, in principle, one has to include decoupling effects when relating $\alpha_{s}^{(5)}(M_{Z})$ to $\alpha_{s}^{(6)}(Q)$. With the help of RunDec this can be taken into account as follows

nloops = 5;

dec = {{6, Mt /. NumDef, 2*Mt /. NumDef}}; asQ = AlL2AlH[asmz, Mz /. NumDef, dec, Q, nloops]; delasQplus = Abs[asQ - AlL2AlH[asmzplus, Mz /. NumDef, dec, Q, nloops]]; delasQminus = Abs[asQ - AlL2AlH[asmzminus, Mz /. NumDef, dec, Q, nloops]]; truncuncert = Abs[asQ - AlL2AlH[asmz, Mz /. NumDef, dec, Q, nloops-1]]; totuncertplus = Sqrt[truncuncert^2 + delasQplus^2]; totuncertminus = Sqrt[truncuncert^2 + delasQminus^2];

It is furthermore possible to vary the decoupling scale between $M_{t}/f<\mu_{\mathrm{dec}}^{(t)}<fM_{t}$ where $f$ is often chosen between $2$ and $4$. Within Mathematica this can be realized for $f=4$ via

f = 4; step = 5; tmp = Map[ AlL2AlH[asmz, N[Mz /. NumDef], {{6, N[Mt /. NumDef], #}}, Q, nloops]&, Range[N[Mt /. NumDef]/f, f*N[Mt /. NumDef], step]]; scaleuncert = Max[ tmp ] - Min[ tmp ];

Using five-loop accuracy we arrive at $\alpha_{s}^{(6)}(Q)=0.0840_{-0.0033}^{+0.0036}$ which differs significantly from the value for $\alpha_{s}^{(5)}(Q)$ given above. Here, the scale uncertainty (“scaleuncert”) is negligible. For nloops = 2 we obtain $\alpha_{s}^{(6)}(Q)=0.0839_{-0.0033}^{+0.0036}$ where 10% of the error is due to scale uncertainty.

3.1.2 Compute $\alpha_{s}^{(5)}(M_{Z})$ from $\alpha_{s}^{(3)}(m_{\tau})$

As a further example where higher order corrections are crucial, we consider the extraction of $\alpha_{s}^{(5)}(M_{Z})$ from $\tau$ lepton decays. In this case one has to take into account the effect of two flavour thresholds when running from $m_{\tau}$ to $M_{Z}$. Using AlphasExact and DecAsUpSI we can calculate $\alpha_{s}^{(5)}(M_{Z})$ to $n$-loop accuracy with the help of

As5MZ[asin_?NumberQ, mu_?NumberQ, thr1_?NumberQ, thr2_?NumberQ, n_?IntegerQ] := Module[ {as3c, as4c, as4b, as5b, as5, as5mz}, as3c = AlphasExact[asin, mu, thr1, 3, n]; as4c = DecAsUpSI[as3c, muc /. NumDef, thr1, 3, n]; as4b = AlphasExact[as4c, thr1, thr2, 4, n]; as5b = DecAsUpSI[as4b, mub /. NumDef, thr2, 4, n]; as5mz = AlphasExact[as5b, thr2, Mz /. NumDef, 5, n]; Return[as5mz]; ];

This module can be used to obtain $\alpha_{s}^{(5)}(M_{Z})$ including the uncertainties due to truncation of the perturbative series and the scale variation introduced by matching the three- and four-, as well as four- and five-flavour theory. Following Ref. [23] we calculate the truncation uncertainty by taking the difference between $n$-loop and $(n-1)$-loop results for $\alpha_{s}^{(5)}(M_{Z})$. We obtain the scale uncertainties by varying the decoupling scale between $\mu_{\mathrm{dec}}/3$ and $3\mu_{\mathrm{dec}}$ around $\mu^{(c)}_{\mathrm{dec}}=3.0$ GeV for charm and $\mu^{(b)}_{\mathrm{dec}}=m_{b}(m_{b})$ for bottom. Using $\alpha_{s}^{(3)}(m_{\tau})=0.332\pm 0.016$ [23], the scale invariant charm and bottom quark masses, and the following RunDec commands

mudecc = 3.0; mudecb = mub /. NumDef; asmtauerror = 0.016; as5 = As5MZ[asMtau /. NumDef, Mtau /. NumDef, mudecc, mudecb, 5]; f = 3; step = 1; truncerr = Abs[as5 - As5MZ[asMtau /. NumDef, Mtau /. NumDef, mudecc, mudecb, 5-1]]; tmp = Map[ As5MZ[asMtau /. NumDef, Mtau /. NumDef, #, mudecb, 5]&, Range[mudecc/f, fmudecc, step]]; scaleuncertc = Max[ tmp ] - Min[ tmp ]; tmp = Map[ As5MZ[asMtau /. NumDef, Mtau /. NumDef, mudecc, #, 5]&, Range[mudecb/f, fmudecb, step]]; scaleuncertb = Max[ tmp ] - Min[ tmp ]; totaluncert = Sqrt[truncerr^2 + scaleuncertc^2 + scaleuncertb^2]; expuncert = Abs[as5 - As5MZ[(asMtau /. NumDef)-asmtauerror, Mtau /. NumDef, mudecc, mudecb, 5]];

one obtains $\alpha_{s}^{(5)}(M_{Z})=0.1201\pm 0.0019\pm 0.0003$. The first uncertainty reflects the error of $\alpha_{s}^{(3)}(m_{\tau})$ and the second one the truncation and scale uncertainties which amount to $\delta_{\mathrm{trunc}}=0.00005$, $\delta_{b}=0.00003$ and $\delta_{c}=0.00030$, respectively. It is clearly dominated by the scale uncertainty due to the decoupling of the charm quark. In Tab. 1 $\sqrt{\delta_{\mathrm{trunc}}^{2}+\delta_{b}^{2}+\delta_{c}^{2}}$ is shown as a function of the number of loops used for the running of $\alpha_{s}$. One observes a dramatic reduction after including three loops. Afterwards the improvements are significantly smaller than the uncertainty of $\alpha_{s}^{(3)}(m_{\tau})$.

Fig. 1 shows the dependence of $\alpha^{(5)}_{s}(M_{Z})$ on the decoupling scales for the charm (left) and bottom (right) quark mass using three-, four- and five-loop running. It is easily obtained with the help of As5MZ introduced above. In the case of the bottom quark one observes an almost $\mu^{(b)}_{\rm dec}$-independent behaviour at five loops. In fact, the variation of $\alpha^{(5)}_{s}(M_{Z})$ in the considered range of $\mu^{(b)}_{\rm dec}$ is below 0.03%. Also in the case of the charm quark the curves become flatter when including higher order quantum correction. However, at the five-loop order the variation of $\alpha^{(5)}_{s}(M_{Z})$ still amounts to about 0.3% which corresponds to $\delta_{c}=0.00030$ as mentioned above.

3.1.3 $\Lambda$ and $\alpha_{s}$

RunDec and CRunDec implement two different routines which allow to obtain the QCD scale parameter $\Lambda^{(n_{f})}$ for a given $\alpha_{s}^{(n_{f})}(\mu)$. The numerical results are slightly different since one of the routines uses an explicit solution of the form $\Lambda^{(n_{f})}=f(\alpha_{s}^{(n_{f})})$ whereas the other looks for an implicit solution of $\alpha_{s}^{(n_{f})}=f(\Lambda^{(n_{f})})$. Using

Do[ expl[i] = LamExpl[asMz /. NumDef, Mz /. NumDef, 5, i]; impl[i] = LamImpl[asMz /. NumDef, Mz /. NumDef, 5, i]; diff[i] = Abs[expl - impl] ,{i,1,5} ]

we obtain the values shown in Tab. 2. As expected, the difference decreases with increasing number of loops.333The one-loop relation trivially leads to identical results for LamExpl and LamImpl.

In the next example we use the PDG value for the strong coupling constant (see Eq. (1)) and we calculate $\Lambda^{(n_{f})}$ for $n_{f}=3,4,5,6$. To do so we provide the following routine, which requires as input the strong coupling constant and its uncertainty for $n_{f}$ active flavours at the scale $\mu$. Furthermore the number of loops has to be specified.

CalcLam[as_,aserr_,mu_,nf_,nloops_] := Module[{expl4, impl4, expl, impl, explplus, implplus, explminus, implminus, mean, mean4, truncuncert, diffuncert, expuncert}, expl = LamExpl[as, mu, nf, nloops]; impl = LamImpl[as, mu, nf, nloops]; expl4 = LamExpl[as, mu, nf, nloops-1]; impl4 = LamImpl[as, mu, nf, nloops-1]; explplus = Abs[LamExpl[as + aserr, mu, nf, nloops] - expl]; implplus = Abs[LamImpl[as + aserr, mu, nf, nloops] - impl]; explminus = Abs[LamExpl[as - aserr, mu, nf, nloops] - expl]; implminus = Abs[LamImpl[as - aserr, mu, nf, nloops] - impl]; mean = (expl + impl)/2; mean4 = (expl4 + impl4)/2; truncuncert = Abs[mean - mean4]; diffuncert = Abs[expl - impl]/2; expuncert = Max[explplus, implplus, explminus, implminus]; Return[{mean, expuncert, truncuncert, diffuncert}]; ];

The uncertainties introduced through truncation of the perturbative series is taken to be the difference between $n$- and $(n-1)$-loop results. We use both LamExpl and LamImpl and take the mean value as the result and assign an uncertainty due to half of the difference of both methods. For the uncertainty induced by $\delta\alpha_{s}$ we cite the larger one obtained by the two methods. For $n_{f}=5$ we obtain $\Lambda^{(5)}$ from

lam5 = CalcLam[asMz /. NumDef, 0.0011, Mz /. NumDef, 5, 5];

For the other values of $n_{f}$ the code can be found in the supplementary files. Let us only mention that, in order to obtain $\alpha_{s}^{(n_{f})}(\mu)$ we perform a decoupling of the top, bottom and charm quarks at the scales $M_{t}$, $m_{b}(m_{b})$ and $3$ GeV. The results for $\Lambda^{(n_{f})}$ and the corresponding uncertainties can be found in Tab. 3. Our central values and uncertainties for $n_{f}=4,5,6$ are identical to the ones from PDG [21]. For $n_{f}=3$ a minor difference is observed which is due to the different decoupling scale chosen for the charm quark. In Ref. [21] $\mu^{(c)}_{\rm dec}=1.3$ GeV has been used which results in $\Lambda=332\pm 17$ MeV. We can reproduce this result using our code with four-loop accuracy. Since $\alpha_{s}^{(3)}(\mu^{(c)}_{\rm dec}=1.3~{}\mbox{GeV})$ is already quite large we prefer to decouple the charm quark for $\mu^{(c)}_{\rm dec}=3$ GeV.

In a recent publication the ALPHA collaboration has presented results for $\Lambda^{(3)}$ and $\alpha_{s}^{(5)}(M_{Z})$ [26]. In the following example we use $\Lambda^{(3)}=(332\pm 14)$ MeV [26], compute $\alpha_{s}^{(5)}(M_{Z})$ using two approaches, and compare to Ref. [26]. In the first one we compute $\Lambda^{(4)}$ and $\Lambda^{(5)}$ and finally extract $\alpha_{s}^{(5)}(M_{Z})$. The corresponding RunDec commands read

Lambda3 = 0.332; nloops = 5; Lambda4 = DecLambdaUp[Lambda3, muc /. NumDef, 3, nloops]; Lambda5 = DecLambdaUp[Lambda4, mub /. NumDef, 4, nloops]; aslam = AlphasLam[Lambda5, Mz /. NumDef, 5, nloops];

We obtain $\alpha_{s}^{(5)}(M_{Z})=0.1180$ in excellent agreement with

[TABLE]

from Ref. [26]. We can also reproduce the uncertainties which origin from the one of $\Lambda^{(3)}$ and the use of perturbation theory (see the Mathematica and C++ code in the ancillary files.).

In the second approach one can use AlphasLam to obtain $\alpha_{s}^{(3)}$ and calculate $\alpha_{s}^{(5)}(M_{Z})$ by running and decoupling as described in Section 3.1.2. Using five-loop accuracy, we obtain

[TABLE]

where the last two uncertainties are due to truncation of the perturbative series and the scale uncertainty. Both the central value and the three uncertainties are obtained with the help of

Lambda3 = 0.332; Lambda3plus = Lambda3 + 0.014; Lambda3minus = Lambda3 - 0.014; mudecc = 3.0; mudecb = mub /. NumDef; nloops = 5; f = 3;

As3Lambda[lamin_?NumberQ, scale1_?NumberQ, scale2_?NumberQ, n_?IntegerQ] := Module[{as31, as32}, as31 = AlphasLam[lamin, scale1, 3, n]; as32 = AlphasExact[as31, scale1, scale2, 3, n]; Return[as32]; ];

As5MZfromLambda[lamin_?NumberQ, scale1_?NumberQ, thr1_?NumberQ, thr2_?NumberQ, n_?IntegerQ] := Module[{as3, as5}, as3 = As3Lambda[lamin, scale1, thr1, n]; as5 = As5MZ[as3, thr1, thr1, thr2, n]; Return[as5]; ];

as5 = As5MZfromLambda[Lambda3, mudecc, mudecc, mudecb, nloops]; expuncert = Max[ Abs[as5 - As5MZfromLambda[Lambda3plus, mudecc, mudecc, mudecb, nloops]], Abs[as5 - As5MZfromLambda[Lambda3minus, mudecc, mudecc, mudecb, nloops]] ]; truncuncert = Abs[as5 - As5MZfromLambda[Lambda3, mudecc, mudecc, mudecb, nloops-1]]; step = 1; tmp = Map[ As5MZfromLambda[Lambda3, #, mudecc, mudecb, nloops]&, Range[mudecc/f, fmudecc, step]]; scaleuncertlam = Max[ tmp ] - Min[ tmp ]; tmp = Map[ As5MZfromLambda[Lambda3, mudecc, #, mudecb, nloops]&, Range[mudecc/f, fmudecc, step]]; scaleuncertc = Max[ tmp ] - Min[ tmp ]; tmp = Map[ As5MZfromLambda[Lambda3, mudecc, mudecc, #, nloops]&, Range[mudecb/f, f*mudecb, step]]; scaleuncertb = Max[ tmp ] - Min[ tmp ]; totalscaleuncert = Sqrt[scaleuncertc^2 + scaleuncertb^2 + scaleuncertlam^2];

We have introduced as5MZfromLambda which calculates $\alpha_{s}^{(3)}(\mu)$. It is based on as5MZ, which has been introduced in Section 3.1.2 to compute $\alpha_{s}^{(5)}(M_{Z})$ from $\alpha_{s}^{(3)}(m_{\tau})$. Note that the central values in Eqs. (2) and (3) agree within the second uncertainty of Eq. (2) which is due to the use of perturbation theory when relating $\Lambda^{(3)}$ to $\Lambda^{(5)}$. Note, however, that the corresponding uncertainty in our second method, which is the one we recommend for such calculations, amounts to $\sqrt{0.0002^{2}+0.0003^{2}}\approx 0.0004$ and is twice as large.

As a last example in this subsection we use $\Lambda^{(3)}$ from Ref. [26] and compute $\alpha_{s}^{(3)}(m_{\tau})$ with the help of the following commands

astau = AlphasLam[Lambda3, Mtau /. NumDef, 3, 5]; astau4 = AlphasLam[Lambda3, Mtau /. NumDef, 3, 4]; astauplus = Abs[AlphasLam[Lambda3plus, Mtau /. NumDef, 3, 5] - astau]; astauminus = Abs[AlphasLam[Lambda3minus, Mtau /. NumDef, 3, 5] - astau]; truncuncert = Abs[astau - astau4]; expuncert = Max[astauplus, astauminus];

We obtain $\alpha_{s}^{(3)}(m_{\tau})=0.3119\pm 0.0073\pm 0.0040$, where the first uncertainty is due to the one of $\Lambda^{(3)}$ and the second one due to the truncation of the perturbative series. For comparison, we also show the value obtained from computing in a first step $\alpha_{s}^{(3)}(3~{}\mbox{GeV})$ and the subsequent running from 3 GeV to $m_{\tau}$. We obtain $\alpha_{s}^{(3)}(m_{\tau})=0.3125\pm 0.0074\pm 0.0019$. The results are consistent with each other. However, the uncertainties from the truncation of the perturbative series differ by a factor two which indicates that $\alpha_{s}$ is relatively large. It seems to be advantageous to use the relation between $\Lambda$ and $\alpha_{s}$ at higher scales and use the renormalization group running to arrive at $\mu=m_{\tau}$.

3.1.4 Running and decoupling for $m_{b}$

For the decay of the Standard Model Higgs boson to bottom quarks it is necessary to evaluate the $\overline{\rm MS}$ bottom quark mass at an energy scale which is of the order of $M_{H}$. The uncertainty of the decay rate depends crucially on the accuracy of $m_{b}$ and thus it is important to consistently propagate the uncertainties from low to high energies. In Ref. [22] one finds the following result for the bottom quark mass

[TABLE]

which translates to

[TABLE]

The corresponding Mathematica commands to obtain the central value are given by

mb10 = 3.610 - 12/1000*((asMz /. NumDef) - 0.1189)/0.002; mu10 = 10; nloops = 5; as10 = AlphasExact[asMz /. NumDef, Mz /. NumDef, mu10, 5, nloops]; asMh = AlphasExact[asMz /. NumDef, Mz /. NumDef, Mh /. NumDef, 5, nloops]; mMS2mMS[mb10, as10, asMh, 5, nloops]

The code which calculates the uncertainties and the C++ code can be found in the supplementary files.

As a further example let us consider the bottom quark mass at the scale $\mu=M_{t}$ in the six-flavour theory. With the help of

mL2mH[mb10, as10, mu10, {{6, Mt /. NumDef, 2*Mt /. NumDef}}, Mt /. NumDef, 5]

one obtains $m_{b}^{(6)}(M_{t})=2670$ MeV.

3.2 Quark mass relations

3.2.1 Relation between threshold and $\overline{\rm MS}$ quark masses

In this subsection we provide RunDec (and CRunDec) commands which allow to check the numbers in Tab. 3 of Ref. [13]. To do so we use the newly implemented routines for the conversion between threshold and $\overline{\rm MS}$ quark masses. In addition we allow for an uncertainty in the threshold mass and $\alpha_{s}^{(5)}(M_{Z})$ and compute the resulting uncertainty of the $\overline{\rm MS}$ quark mass in the output. The RunDec commands which fulfill this task are given by

xerr = 0.002; mbSI = mub /. NumDef; mtOS = Mt /. NumDef; mcSI = muc /. NumDef;

mThr2mSI[mThr_,merr_,asmz_,aserr_,nl_,nloop_,scheme_] := Module[ {as, asp, asm, muf, mSI, mcentral, msoserr, expuncert, muncert, asuncert}, as[mu_] := Switch[nl, 5, AlphasExact[asmz, Mz /. NumDef, mu, 5, 4], 4, AlphasExact[DecAsDownSI[AlphasExact[asmz, Mz /. NumDef, 2mbSI, 5, 4], mbSI, 2mbSI, 4, 4], 2mbSI, mu, 4, 4], 3, AlphasExact[DecAsDownSI[AlphasExact[DecAsDownSI[AlphasExact[ asmz, Mz /. NumDef, 2mbSI, 5, 4], mbSI, 2mbSI, 4, 4], 2mbSI, 3.0, 4, 4], mcSI, 3.0, 3, 4], 3.0, mu, 3, 4] ]; asp[mu_] := Switch[nl, 5, AlphasExact[asmz + aserr, Mz /. NumDef, mu, 5, 4], 4, AlphasExact[DecAsDownSI[AlphasExact[asmz + aserr, Mz /. NumDef, 2mbSI, 5, 4], mbSI, 2mbSI, 4, 4], 2mbSI, mu, 4, 4], 3, AlphasExact[DecAsDownSI[AlphasExact[DecAsDownSI[AlphasExact[ asmz + aserr, Mz /. NumDef, 2mbSI, 5, 4], mbSI, 2mbSI, 4, 4], 2mbSI, 3.0, 4, 4], mcSI, 3.0, 3, 4], 3.0, mu, 3, 4] ]; asm[mu_] := Switch[nl, 5, AlphasExact[asmz - aserr, Mz /. NumDef, mu, 5, 4], 4, AlphasExact[DecAsDownSI[AlphasExact[asmz - aserr, Mz /. NumDef, 2mbSI, 5, 4], mbSI, 2mbSI, 4, 4], 2mbSI, mu, 4, 4], 3, AlphasExact[DecAsDownSI[AlphasExact[DecAsDownSI[AlphasExact[ asmz - aserr, Mz /. NumDef, 2mbSI, 5, 4], mbSI, 2mbSI, 4, 4], 2mbSI, 3.0, 4, 4], mcSI, 3.0, 3, 4], 3.0, mu, 3, 4] ]; muf := Switch[nl, 5, 80.0, 4, 2.0, 3, 2.0];

mSI[m_,asnl_,err_] := Switch[scheme,
            "1S", m1S2mSI[m, {}, asnl, nl, nloop, 1+err],
            "PS", mPS2mSI[m, {}, asnl, muf, nl, nloop, 1+err],
            "RS", mRS2mSI[m, {}, asnl, muf, nl, nloop, 1+err],
            "RSp", mRSp2mSI[m, {}, asnl, muf, nl, nloop, 1+err]];

mcentral := mSI[mThr, as, 0];
msoserr := Abs[mSI[mThr, as, xerr] - mcentral];
If[merr =!= 0,
    muncertplus := Abs[mcentral - mSI[mThr + merr[[1]], as, 0]],
    muncertplus = 0;
];
If[Length[merr] > 1,
    muncertminus := Abs[mcentral - mSI[mThr - merr[[2]], as, 0]],
    muncertminus = muncertplus;
];
If[aserr =!= 0,
    asuncert := Max[ Abs[mcentral - mSI[mThr, asp, 0]],
                     Abs[mcentral - mSI[mThr, asm, 0]] ],
    asuncert = 0;
];
Return[{mcentral, muncertplus, muncertminus, asuncert, msoserr}];

];

Using this routine we can compute the Tab.3a of [13] with the help of

Do[ mfromPS = First[mThr2mSI[168.049, 0, asMz /. NumDef, 0, 5, i, "PS"]]; mfrom1S = First[mThr2mSI[172.060, 0, asMz /. NumDef, 0, 5, i, "1S"]]; mfromRS = First[mThr2mSI[166.290, 0, asMz /. NumDef, 0, 5, i, "RS"]]; mfromRSp = First[mThr2mSI[171.785, 0, asMz /. NumDef, 0, 5, i, "RSp"]]; Print[i, " ", mfromPS, " ", mfrom1S, " ", mfromRS, " ", mfromRSp]; ,{i,1,4} ];

The remaining three tables are obtained with similar code (see ancillary files).

As a further example let us assume that the top quark PS mass has been extracted from experimental data (e.g. from the threshold cross section of a future electron positron linear collider) to

[TABLE]

Using $\alpha_{s}^{(5)}(M_{Z})$ from Eq. (1) and mThr2mSI leads to

[TABLE]

It is interesting to note that an uncertainty of 0.0011 in $\alpha_{s}^{(5)}(M_{Z})$ induces an uncertainty of about 40 MeV into the $\overline{\rm MS}$ top quark mass.

In Ref. [27, 28] the PS bottom quark mass has been determined to $m_{b}^{\rm PS}=4.532^{+0.013}_{-0.039}$ GeV using QCD sum rules. With the help of

mbPS = 4.532; delmbPSplus = 0.013; delmbPSminus = 0.039; as = asMz /. NumDef; alsuncert = 0.0013; mThr2mSI[mbPS, {mbPSplus, mbPSminus}, asMz /. NumDef, alsuncert, 4, 4, "PS"];

we obtain $m_{b}(m_{b})=4.209^{+0.014}_{-0.036}$ GeV, in good agreement with the result given in [28] $m_{b}(m_{b})=4.203^{+0.016}_{-0.034}$ GeV.

3.2.2 $\overline{\rm MS}$-OS relations including light quark mass effects

Light quark mass effects in the $\overline{\rm MS}$-OS relation of the top and bottom quark masses can be computed with the help of the following commands

as6[mu_] := AlL2AlH[asMz /. NumDef, Mz /. NumDef, {{6, Mt /. NumDef, 2*Mt /. NumDef}}, mu, 5]; as5[mu_] := AlphasExact[asMz /. NumDef, Mz /. NumDef, mu, 5, 5];

mut = 163.0; Mt4 = mMS2mOS[mut, {}, as6[mut]*XXX, mut, 6, 4]; Mtb = mMS2mOS[mut, {mub /. NumDef}, as6[mut]*XXX, mut, 6, 4]; Mtbc = mMS2mOS[mut, {{mub /. NumDef, mub /. NumDef}, {mc3 /. NumDef, 3.0}}, as6[mut]*XXX, mut, 6, 4]; delb = Expand[(Mtb - Mt4)]; delc = Expand[(Mtbc - Mtb)];

Mb4 = mMS2mOS[mub /. NumDef, {}, as5[mub /. NumDef]*XXX, mub /. NumDef, 5, 4]; Mbc = mMS2mOS[mub /. NumDef, {{mc3 /. NumDef,3.0}}, as5[mub /. NumDef]*XXX, mub /. NumDef, 5, 4]; delc = Expand[(Mbc - Mb4)];

The label XXX has been introduced to separate the different loop orders and the mass effects are contained in the quantities delc and delb. For the top and bottom quark mass we have

[TABLE]

where the subscripts are self-explanatory. In all cases the mass corrections at three loops are larger than at two loops which suggests that there is no convergence in the mass correction terms. The situation is improved after decoupling the heavy quarks and using $\alpha_{s}^{(3)}$ as an expansion parameter (see, e.g., Ref. [29]).

4 Summary

This article describes the improvements implemented in versions 3 of the programs RunDec and CRunDec. This concerns in particular the five-loop corrections to the running of strong coupling constant and the quark masses, the four-loop correction to the decoupling of heavy quarks from the running, the four-loop corrections to the relation between the $\overline{\rm MS}$ and on-shell heavy quark mass, and various relations between the $\overline{\rm MS}$ and on-shell heavy quark mass to so-called threshold masses. Furthermore, light quark mass effects are implemented in the $\overline{\rm MS}$-on-shell relation to three loops. We provide a large number of examples which exemplify the use of both the Mathematica and C++ version. It is straightforward to apply modifications and include them in other codes.

Acknowledgements

We thank Konstantin Chetyrkin for providing analytic results for the five-loop QCD beta function and quark anomalous dimension. This work is supported by the BMBF through Grant No. 05H15VKCCA.