T

***DRAFT***

Rolf Mertig
and
Frederik Orellana
AF
Guide to FeynCalc 4.2

CERN
March 1st, 2002
DR
 T
Contents

1 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1

2
1.1
1.2

2.3
2.4
2.5
2.6
2.7
AF
Version History . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Installation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Input Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2.1
2.2
Lorentz Tensors and Scalar Products . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Dirac Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Spinors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
SU(N) Matrices and Structure Constants . . . . . . . . . . . . . . . . . . . . . . . . . .
Denominators of Propagators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Small Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Quantum Fields . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
2
4
6
7
9
10
11
13
14
14
3 Inside FeynCalc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3.1 Startup Sequence, Modules, Add-ons and Extensibility . . . . . . . . . . . . . . . . . . 16
3.2 Configuration and Runtime Variables . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
3.3 Data Types . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
3.4 Output Forms and Internal Representation . . . . . . . . . . . . . . . . . . . . . . . . . 21
DR
3.5 Help system . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
4 Elementary Calculations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.1 Lorentz Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
4.2 Dirac Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
4.3 Dirac Traces . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39
4.4 SU(N) Traces and Algebra . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 45
4.5 Green’s functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 49
5 One-Loop Calculations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
5.1 Passarino-Veltman Integrals and Reduction of Coefficient Functions . . . . . . . . . . . 54
5.2 A One-Loop Self Energy Diagram . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
¢
5.3 Generic Diagrams for W ® fi f̄ j with OneLoop . . . . . . . . . . . . . . . . . . . . . . 64
5.4 The Options of OneLoop . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
5.5 OneLoopSum and Its Options . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 70

I
 5.6 Box Graphs of e+ e- ® ZH . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 73
5.7 Processing Amplitudes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 79

T
6 Advanced Calculations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.1 QCD with FeynCalc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.2 ChPT with FeynCalc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.3 Two-Loop Calculations . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
6.4 Amplitude and Integral Tables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
7 Miscellaneous Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
7.1 Low Level Dirac Algebra Functions . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

8
7.2
7.3
7.4
7.5
7.6
7.7
7.8
7.9
7.10
AF
Functions for Polynomial Manipulations . . . . . . . . . . . . . . . . . . . . . . . . .
An Isolating Function for Automatically Introducing Abbreviations . . . . . . . . . . .
An Extension of FreeQ and Two Other Useful Functions . . . . . . . . . . . . . . . . .
Writing Out to Mathematica, Fortran, Macsyma and Maple . . . . . . . . . . . . . . . .
More on Levi-Civita Tensors . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Simplifications of Expressions with Mandelstam Variables . . . . . . . . . . . . . . . .
Manipulation of Propagators . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Polarization Sums . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
Permuting the Arguments of the Four-Point Function . . . . . . . . . . . . . . . . . . .
Reference Guide for FeynCalc . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
83
85
87
88
90
92
93
94
94
96

Bibliography 120
DR
1. Introduction 1

1 Introduction

T
FeynCalc is a (³ 3) collection of utilities for algebraic calculations in high energy physics. It is implemented as
a Mathematica package; that is, a number of extensions to the programming language Mathematica, themselves
written in Mathematica. In the section below are described some of the main new capabilities provided.
This document is the technical manual of FeynCalc; explanations are sometimes rather short. The user is assumed
to know Quantum Field Theory and Mathematica. It is strongly recommended to study the Mathematica book [1]
by Stephen Wolfram before starting with FeynCalc.
The original idea of FeynCalc was to provide convenient tools for radiative corrections in the Standard Model
of particle physics. The input for FeynCalc, the analytical expressions for the diagrams, can be entered by
hand or can be taken directly from the output of another package, FeynArts [2] . The user can provide certain

AF
additional information about the process under consideration, i.e. the kinematics and the choice of the standard
matrix elements may be defined. Once this is done, FeynCalc performs the algebraic calculations like tensor
algebra, tensor integral decomposition and reduction, yielding a polynomial in standard matrix elements, special
functions, kinematical variables and scalars.
FeynCalc also provides calculator-type like features. You enter a Dirac trace in a very similar notation you use
by hand and get back an answer, suitable for further manipulation. These features include basic operations like
contraction of tensors, simplification of products of Dirac matrices and trace calculation.
More complex algebraic operations have also been implemented, notably derivation of polynomials in quantum
fields with respect to such fields.
Over the years, the detailed course of and motivation for the development of FeynCalc has changed somewhat
both in scope and focus. This has several reasons: 1) the different research interests of the two authors; 2) the
relative slowness of Mathematica and the rapid development of multi-loop calculations carried out with tools
more suited for very large scale calculations; 3) the rapid development of the raw computing power of hardware.
The first two points have had as consequence that the focus has moved away from providing cutting edge results
of loop calculations in the Standard Model and in QCD. The last point has had as consequence that it has been
possible to explore other types of calculations, namely complex algebraic manipulations of quantum fields and
lagrangians, traditionally done by hand only.
DR
Despite the motivations driving development, the central vision remains largely the same: FeynCalc was con-
ceived as and continues to be developed as a general-purpose modular package for quantum field theory calcula-
tions. Dirac algebra utilities, functional derivation utilities, integral tables etc. have been clearly separated off in
distinct functions which do well-defined operations. Such basic functions can then be used on a higher level to
build sophisticated model dependent functions.
In the following we list what we consider the most important missions of the FeynCalc project:

Code reuse. In calculations as complex as quantum field theory calculations, the code used should be
thoroughly checked and reinventing the wheel for every calculation should be avoided.

Standardization. In order to reuse code, clear standards should be formulated, thoroughly documented
and followed. This should also make it easier to reach common standards with other similar or related
projects (using other programming languages) for fields, lagrangians, 4-vectors, etc. in the end allowing
easy comparison of calculations of the same process.

Repository of lagrangians, amplitudes and integrals. The agreement on standards allows the creation
of a database of quantum field theory results stored in a standardized electronic form. We encourage users
1. Introduction 2

of FeynCalc to contribute back the results they obtain.

T
Algorithm optimization. The more people using (an implementation of) an algorithm, the better the
chances of improving (the implementation of) it.

Fast prototyping. Quickly trying out new quantum field theory models should be made easier by using
the building blocks provided by a clear standardization as well as a set of functions for the most common
calculational tasks.

Notice in this connection that the standards put forth in this document are what we consider to be the most general
but still useful standards for doing quantum fields theory with Mathematica. This means that that standards are to
be considered as relatively fixed, but not that we are unwilling to change them given sufficiently good arguments.

AF
From all of the above it should be clear that we consider interaction with users to be crucial for the further evolv-
ing of FeynCalc. Therefore, suggestions and in particular code contributions are warmly welcomed. Smaller
contributions can be emailed to [email protected]; larger contributions should be coordinated with the de-
velopers who can be reached at the same email address. Though much testing of the code has been done, there is
absolutely no claim that FeynCalc is bug-free. You should be sceptical about the results, and when you are sure
the program returned a wrong answer, you are encouraged to send email to [email protected].

1.1 Version History

The roots of FeynCalc go back to 1987. During a stay as a graduate student in Albuquerque, New Mexico, Rolf
Mertig learned to program in Macsyma [3] from the experts Stanly Steinberg and Michael Wester. Meanwhile
in Germany, elementary particle physicists needed automation of the calculation of Feynman diagrams of eletro-
weak processes to one loop. The algorithms were provided mostly by Ansgar Denner and Manfred Böhm and
implemented in a purely functional way by Rolf Mertig during the years 1987 - 1989.
The basic idea was to have general functions for some of the more mechanical parts of the diagram calculations,
generalizable tools for use in calculations of different 1-loop processes, especially 1®2 and 2®2 processes.
These included tools for:
DR
Lorentz algebra. gΜΝ pΜ ® pΝ , gΑΒ gΑΒ ® n × × ×,
_ _
Dirac algebra. ΓΑ ΓΝ ΓΑ ® (2 - n) ΓΝ , v(p, m) p/ ® - m v(p, m) × × ×,

Passarino-Veltman - tensor integral decomposition. Applications of these tools included complete 1-loop
processes in the Standard Model, e+ e- ® Z H , e+ e- ® W +W - and the 2-loop photon self-energy in
QED.

However, at the end of 1989 several problems showed up with the Macsyma implementation. The purely func-
tional programming style proved to be difficult to debug and, in fact, inappropriate. The rudimentary pattern
matcher in Macsyma was not useful. There was no way to incorporate new functions easily into the whole
1. Introduction 3

Macsyma system, and no possibility of providing online documentation. Furthermore, Macsyma’s memory
managment ("garbage collection") was slow when handling large expressions.

T
In early 1990 it became clear that Mathematica was a much more natural (programming) environment for Feyn-
Calc.

1990-1991 : The first version of FeynCalc in Mathematica

In 1990, user-friendly packages were built with extended automatic capabilities (OneLoop, OneLoopSum), and
SU(3) algebra capabilities were added (SU3Simplify).
In 1991 initial documentation was written and the program was made available on anonymous ftp-servers: math-

AF
source.wolfram.com and canc.can.nl
Applications from 1990 - 1996 included:

1-loop 2 ®2 processes in the Standard Model, such as:

gg ® tt , e+ e- ® Z H , W +W - ® W+ W- , ZZ ® ZZ

background field gauge calculations,

High-energy approximation of e+ e- ® W+ W- .

2-loop Standard Model self-energies.

No attempt was made to provide tools for tree-level calculations. For this purpose other programs appeared,
among them another Mathematica package, HIP [4], developed at SLAC.

1992-1995 : FeynCalc 2.0-2.2, unification and simplification.

During this period of development the SU(3) algebra was changed to SU(N). Several tools for automatic tree-

was not updated.) All sub-packages were put into one file I > 10 4 lines). The result was FeynCalc2.2beta.m.
level calculation were added, for example the function SquareAmplitude. (Unfortunately, the documentation
DR
1993-1996 : FeynCalc 3.0, modularization, typesetting

Due to the rapidly increasing amount of code, FeynCalc has been reorganized in a completely modular way. Each
function in a package is a file which is loaded only on demand. For the maintenance of hundreds of packages,
totalling 2.5 MegaByte, software engineering was needed.

The new typesetting capabilities of Mathematica 3 (TraditionalForm) were used to substantially improve
®
the look of the output. Typesetting rules were added for e.g., ¶ Μ .
1. Introduction 4

Code was written to allow new abstract datatypes, for example for noncommutative algebra and for special
integrals.

T
QCD tools for the Operator Product Expansion (OPE) were added.

Automatic Feynman rule derivation (with functional differentation) was coded, in order to get special
Feynman rules for twist-2 (and higher) operators.

1997-2000 : FeynCalc 4.0-4.1, QCD and OPE, ChPT, tables

In these years Rolf Mertig made many improvements to the code, driven by his own work in perturbative Quan-
tum Chromo Dynamics (QCD).

AF
One effort was to build data bases: Convolutions, integrals, tensor integral transformation formulas, Feyn-
man rules, and Feynman parameterizations. Applications include 2-loop spin-dependent and spin-independent
Altarelli-Parisi Splitting functions.
Another was the package TARCER, which was initially an independent project, but then integrated into Feyn-
Calc. TARCER [6] adds two-loop functionality for propagator-type integrals using the recurrence relations of
Tarasov [5].
In 2000, maintanance of the package was taken over by Frederik Orellana. He worked in Chiral Perturbation
Theory [7] (ChPT) and made some changes, as well as adding code to FeynCalc in order to support ChPT and
effective theories in general, and interfacing with FeynArts. Also, a first implementation of the ’tHooft-Veltman
formulae [8] for numerical evaluation of the one-loop integrals B0, C0 and D0 was added.

1.2 Installation
Download the file "HighEnergyPhysics-4.2.tar.gz" or "HighEnergyPhysics-4.2.zip" (if you’re using using
Windows you’ll probably want the zip file).

Place the file in the directory "mathhome/AddOns/Applications", where "mathhome" is the direc-
DR
tory containing your Mathematica installation. If you’re on a Unix system, "mathhome" can also
be " /.Mathematica/x", where x is the version of your Mathematica installation. (if " /.Mathemat-
ica/x/AddOns/Applications" does not exist, you can safely create it).

Make sure there is not already a directory "HighEnergyPhysics" (and move it out of the way if there is).

Unpack the file: Under UNIX, type tar -xvzf HighEnergyPhysics-4.2.tar.gz; under Win-
dows and MacOS, use some utility like WinZip or StuffIt Expander.

If you’ve made any customizations in the configuration file FCConfig.m, merge them from the file you’ve
moved away into the new file.
1. Introduction 5

Start Mathematica.

T
Choose ’Rebuild Help Index’ from the ’Help’ menu.

Load FeynCalc with «HighEnergyPhysics‘FeynCalc‘

AF
DR
2. Input Functions 6

2 Input Functions

T
The FeynCalc syntax for metric tensors, four-vectors, Dirac matrices, etc., is such that the positioning of the
arguments automatically defines the nature of the variables. No declaration of Lorentz indices or four-vectors
has to be made. Covariant and contravariant Lorentz indices are treated on an equal basis, assuming summation
over (twice) repeated indices, where each pair of indices are assumed to be co- and contravariant respectively.
Since explicit components of Lorentz tensors are not used, this convention causes no problems. The ambiguity
in the sign of the Levi-Civita tensor can be fixed by an option of the function DiracTrace and EpsChisholm,
see page 42.
The input functions are macros that are immediately translated into the internal representation of FeynCalc. But

AF
these sometimes lengthy internal representations are difficult to recognize when working interactively. Therefore,
some effort has been put into making the output of FeynCalc look as much as possible like typeset formulas. The
typesetting of FeynCalc depends on the input/output interface in use.

Terminal interface. Per default FeynCalc sets the global Mathematica variable $PrePrint to
FeynCalcForm, forcing the display to be in a more readable manner. It is important to realize that the
display given by FeynCalcForm is different from the input syntax. Thus, you may not give as input, for
example, a scalar product in the result of a trace calculation by copying the form you see on the screen.
To have the output be the internal representation, set $PrePrint=.. To return to formatted output, set
$PrePrint = FeynCalcForm.

Notebook interface. FeynCalc per default automatically sets the Mathematica default output format type
to TraditionalForm. Because FeynCalc defines the TraditionalForm-look of its objects, the output
looks very much like typeset formulas. Again, the screen output cannot be copied and used as input. If the
Mathematica default output format type 1 is set to InputForm or StandardForm, the screen output is the
internal representation of FeynCalc and can be copied and used as input. To obtain the same output as with
a terminal interface, set the Mathematica default output format type to OutputForm and set $PrePrint
= FeynCalcForm. To return to formatted output, set the Mathematica default output format type to
TraditionalForm.
DR
In the rest of this guide, the examples given will use the notebook interface.
The internal structure of FeynCalc is explained briefly in section 3 and in the reference section 8. Usually it is
not necessary to know it. Notice simply that there are three layers of FeynCalc: The input functions, an output
representation of those and the internal structure.
In order to do calculations in the framework of D-dimensional regularization, FeynCalc can be used for calcula-
tions in 4, D dimensions. The dimension of metric tensors, Dirac matrices and four-vectors is specified by setting
the option Dimension of the corresponding input functions. The default is four. If FeynCalc is used for interac-
tive D-dimensional calculations, you should change the option of the input functions. Note that Lorentz indices,
1
The Mathematica default output format type is set using the menu "Cell" ® "Default Output Format Type".
2. Input Functions 7

momenta and Dirac matrices carry their dimension locally, i.e., for calculating a Dirac trace in D dimensions the
dimension of the Dirac matrices has to be set accordingly, thus there is no need of a dimension option for e.g.

T
the function DiracTrace.

2.1 Lorentz Tensors and Scalar Products

FourVector[p, Μ] four-vector pΜ

AF
LeviCivita[Μ, Ν, Ρ, Σ]
MetricTensor[Μ, Ν]
ScalarProduct[p, q]

Basic Lorentz tensor input functions.

option name
Levi-Civita tensor ¶ΜΝΡΣ
metric tensor gΜΝ
p×q

default value

Dimension 4 number of space-time dimensions

Option for FourVector, MetricTensor, LeviCivita and ScalarProduct.

DR
Internally, the input given with FourVector, MetricTensor, LeviCivita and ScalarProduct is repre-
sented in terms of the lower level functions Pair, Momentum and LorentzIndex (this is elaborated in section
3.4).
The following examples show the input syntax and the typesetting of FeynCalc.

First we have to load FeynCalc. In[1]:= «HighEnergyPhysics‘FeynCalc‘

Enter a scalar product p × q. In[2]:= ScalarProduct[p, q]

This is the typeset output.
Out[2]= p.q
ΜΝ
This is the input for g . In[3]:= MetricTensor[Μ, Ν]
Out[3]= gΜΝ
2. Input Functions 8

A metric tensor gΜΝ in D In[4]:= MetricTensor[Μ, Ν, Dimension ® D]

dimensions is entered in this way.
Out[4]= gΜΝ

T
The number of dimensions is
suppressed in the screen output
(for notebook output. For
terminal output, the number of
dimensions is displayed as an
index, g [mu, nu]).
D

A four-dimensional pΜ . In[5]:= FourVector[p, Μ]

Out[5]= pΜ

You may also enter a linear

combination of four-vectors:
(p - 2 q)Μ .

This is a D-dimensional qΜ .

A polarization vector ¶Μ (k) is a

special four-vector.

This is how to enter a ¶*Μ (k).

AF In[6]:= FourVector[p - 2 q, Μ]
Out[6]= (p - 2 q)Μ

In[7]:= FourVector[q, Μ, Dimension ® D]

Out[7]= qΜ

In[8]:= PolarizationVector[k, Μ]
Out[8]= ¶Μ (k)

In[9]:= Conjugate[PolarizationVector[k, Μ]]

Out[9]= ¶*Μ (k)

Polarization vectors are represented in a special way (see page 42). The transversality condition ¶(k) × k = 0 is
automatically fulfilled (see page 31). Polarization vectors are defined in FeynCalc in four dimensions only. For
FourVector, MetricTensor, LeviCivita, and ScalarProduct other dimensions may be specified with
the option Dimension.
DR
PolarizationVector[k, ¶Μ (k)
mu]
Conjugate[ ¶*Μ (k)
PolarizationVector[k, mu]]

The input for a polarization vector and polarization.

2. Input Functions 9

2.2 Dirac Matrices

T
DiracMatrix[mu, nu, Dirac matrices ΓΜ ΓΝ . . .
...]
DiracSlash[p, q, ...] Feynman slashes p/ q/ . . .
DiracMatrix[5] Γ5

AF
ChiralityProjector[+1]
DiracMatrix[6]
ChiralityProjector[-1]
DiracMatrix[7]

Various input functions for Dirac matrices.

Ω+ = (1 + Γ5 )/ 2
Γ6 = (1 + Γ5 )/ 2
Ω- = (1 - Γ5 )/ 2
Γ7 = (1 - Γ5 )/ 2

A Dirac matrix ΓΜ is represented by DiracMatrix[mu]. For p/ = pΜ ΓΜ you may use DiracSlash[p]. Prod-
ucts of Dirac matrices or slashes can either be entered by adding subsequent arguments, i.e., DiracMatrix[mu,
nu, ...] and DiracSlash[p, q, ...], or by multiplying the DiracMatrix and DiracSlash with the
Mathematica Dot, “.”.
The Mathematica Dot, “.”, is used in the input as noncommutative multiplication operator for the objects
DiracMatrix, DiracSlash, Spinor, LeptonSpinor, QuarkSpinor and GellMannMatrix. The “.”
may also be used as a delimiter instead of the “,” within the functions DiracMatrix, DiracSlash and
GellMannMatrix.
In the output with FeynCalcForm the “.” as noncommutative multiplication operator is suppressed.
DR
This is how you enter In[10]:= (DiracSlash[p + q] + m) . DiracMatrix[Μ]
(p/ + /q + m) ΓΜ .
Out[10]= (m + Γ × (p + q)) ΓΜ

Here is ΓΜ Γ5 ΓΝ Γ6 ΓΡ Γ7 . In[11]:= DiracMatrix[Μ, 5, Ν, 6, Ρ, 7]

Out[11]= ΓΜ Γ5 ΓΝ Γ6 ΓΡ Γ7

This is a four-dimensional In[12]:= DiracSlash[2b, a, 2(d - c), 6q - 3p]

product:
Out[12]= 2Γ × b Γ × a 2 (Γ × d - Γ × c) (6 Γ × q - 3 Γ × p)]
2b/ a/ 2 (d/ - /c) (6 q/ - 3 p/).
2. Input Functions 10

Slashed polarization vectors /¶(k) In[13]:= DiracSlash[Polarization[k]]

are entered in this way.
Out[13]= Γ × ¶(k)

T
option name default value

Dimension 4 space-time dimension

Entering of a D-dimensional ΓΜ .
The number of dimensions is
suppressed in the screen output
(for notebook output).

This is ΓΜ ΓΜ in D - 4 dimensions.
AF
Option for DiracMatrix and DiracSlash.

As setting for Dimension, a Mathematica Symbol dim, or dim-4 are possible.

In[14]:= DiracMatrix[Μ, Dimension ® D]

Out[14]= ΓΜ

In[15]:= DiracMatrix[mu, mu, Dimension ® D - 4]

Out[15]= ΓΜ ΓΜ

2.3 Spinors
In FeynCalc spinors are entered with the four functions SpinorU, SpinorUBar, SpinorV, SpinorVBar. Prod-
ucts of spinors with spinors or Dirac matrices (Fermion chains) are built with the Mathematica Dot, “.”.
DR
2. Input Functions 11

T
SpinorU[p, m] u(p, m)
SpinorUBar[p,m] u(p, m)
SpinorV[p, m] v(p, m)
SpinorVBar[p,m] v(p, m)

The input functions for fermionic spinors.

This is u(p, m) /p.

On the right of /p the spinor,

u(p, m) is used.

This is v(p, m) q/ /p.

Here we have Γ × p v(p, m).

AF In[16]:= SpinorUBar[p, m] . DiracSlash[p]
Out[16]= u(p, m) Γ × p

In[17]:= DiracSlash[p] . SpinorU[p, m]

Out[17]= Γ × p u(p, m)

In[18]:= SpinorVBar[p, m] . DiracSlash[q, p]

Out[18]= v(p, m) Γ × q Γ × p

In[19]:= DiracSlash[p] . SpinorV[p, m]

Out[19]= Γ × p v(p, m)

Enter a spinor obeying the In[20]:= SpinorU[p, 0]

massless Dirac equation. The Out[20]= u(p)
FeynCalcForm suppresses
the 0.
DR
You may also omit the second In[21]:= SpinorU[p]
argument for a massless spinor.
Out[21]= u(p)

2.4 SU(N) Matrices and Structure Constants

FeynCalc provides functions for the input of SU(N) matrices and the corresponding structure constants. More
specialized input functions in SU(2) and SU(3) (Gell-Mann and Pauli matrices) are provided by the subpackage
PHI. These are described in the PHI user’s guide ???.
2. Input Functions 12

T
SUNT[a] the a’th generator, Ta , of SU(N) in the fundamental
representation

Input of SU(N) matrices.

For noncommutative multiplication of SU(N) matrices, use the Mathematica Dot, “.”.

This is Ta Tb Tc .

The above can also be entered like

this. AF
This is how you enter Ta Tb Tc ∆c d .
In[22]:= SUNT[a] . SUNT[b] . SUNT[c]
Out[22]= Ta Tb Tc

In[23]:= SUNT[a, b, c]
Out[23]= Ta Tb Tc

In[24]:= SUNT[a, b, c] SUNDelta[c, d]

Out[24]= Ta Tb Tc ∆c d

SUNDelta[i,j] Kronecker delta function in SU(N)

SUNF[i,j,k] antisymmetric structure constants of SU(N)
SUND[i,j,k] symmetric structure constants of SU(N)
DR
Input of SU(N) structure constants.
 2. Input Functions 13

T
option name default value

Explicit True replace SUNF or SUND by traces

An option for the structure constants SUNF and SUND.

This is how you enter f a b c .

This is how you enter da b c .

They can be expressed in terms of

the generating matrices (see
section 4.4 for a discussion of the
trace).

Antisymmetry, f a c b = - fa b c .
AF
In[25]:= SUNF[a, b, c]
Out[25]= fa b c

In[26]:= SUND[a, b, c]
Out[26]= da b c

In[27]:= SUNF[a, b, c, Explicit ® True]

Out[27]= 2 ä ( tr(Ta Tc Tb ) - tr(Ta Tb Tc ) )

In[28]:= SUNF[a, b, c, Explicit ® True] +

SUNF[a, c, b, Explicit ® True] //
Expand
Out[28]= 0

Symmetry, da c b = da b c . In[29]:= SUND[a, b, c, Explicit ® True] -

SUND[a, c, b, Explicit ® True] //
Expand
Out[29]= 0
DR
2.5 Denominators of Propagators
The denominators of propagators are entered in a special way. Each one-loop Feynman amplitude has factors of
the form
1
df = 2
[q - m0 ] [(q + p1 ) - m21 ] [(q + p2 )2 - m22 ] . . .
2 2

with q as loop momentum and the pi denoting linear combinations of the external four-vectors.
2. Input Functions 14

T
2 2
FeynAmpDenominator[ 1/ ([q2 - m0 ][(q + p)2 - m1 ]) . . .
PropagatorDenominator[q,
m0 ],
PropagatorDenominator[q +
p, m1 ], ...]

Entering denominators of propagators.

This is
1/ ([q2 - m21 ][(q + p)2 - m22 ]).

2.6 Small Variables

AFIn[30]:= FeynAmpDenominator[ PropagatorDenominator[q,

Out[30]=
m1], PropagatorDenominator[q + p, m2]]

2 2
1
(q - m1 )((q + p)2 - m22 )

For radiative corrections in the standard model, fermionic masses often can be neglected with respect to the
gauge boson masses. Since, however, some of the Passarino-Veltman integrals may be infrared divergent, the
fermionic (and photonic) small masses must remain as arguments of them and cannot be set to 0. In order to
achieve this behavior, these small masses have to be entered with head Small. The idea is that every variable
with head Small evaluates to 0, unless it is an argument of a scalar integral.
You can avoid to explicitly wrap the head Small around a mass by using the option SmallVariables of the
function OneLoop (the function OneLoop is described in section 5.1).
DR
Small[m] head of a small mass m, m † M

A head for small variables.

2.7 Quantum Fields

FeynCalc is meant to be a general framework for calculations in quantum field theory. Thus, FeynCalc defines
notation not only for working with what comes out of a Feynman amplitude calculation, namely loop integrals,
2. Input Functions 15

momenta, Dirac and SU(N) structures, propagators, etc., but also for the quantities needed to work out the input
to such calculations, namely quantum fields and lagrangians.

T
QuantumField[par1, par2, denotes a quantum field of type ftype with possible Lorentz
... , ftype, {lorind}, indices lorind and SU(N) indices sunind. The optional first
{sunind}] arguments par1, par2, × × × , are partial derivatives acting on the
field
PartialD[Μ] denotes a space-time derivative when given as first argument

Input of quantum fields.

Some field Ψ.
AF
If the field is considered as part of
an SU(N) multiplet and the
SU(N) index is i, this is the
notation.
to QuantumField

In[31]:= QuantumField[Ψ]
Out[31]= Ψ

In[32]:= QuantumField[Ψ, {i}]

Out[32]= Ψi

Some field g with an SU(N) index In[33]:= QuantumField[g, {Ν}, {i}]

i and a Lorentz index Ν. Out[33]= giΜ

This is the notation for the In[34]:= QuantumField[PartialD[Μ],g, {Ν}, {i}]

space-time derivative ¶/ ¶xΜ of the
Out[34]= ¶Μ giΝ
same field.
DR
3. Inside FeynCalc 16

3 Inside FeynCalc

T
This section, which may be skipped on a first read, deals with the internals of FeynCalc. For advanced users and
people considering contributing to FeynCalc, it is a must-read. ??? fill in some more bla bla ???

3.1 Startup Sequence, Modules, Add-ons and Extensibility

FeynCalc is loaded with the following command:
«HighEnergyPhysics‘FeynCalc‘

AF
This causes the program file "FeynCalc.m" to be loaded. This file contains definitions of the core
objects, used by higher level, functions. The more important of these objects are: DiracGamma,
FeynAmpDenominator, FourVector, LorentzIndex, Momentum, NonCommutative, Pair, PartialD,
PropagatorDenominator, QuantumField, SUNIndex, ScalarProduct, Spinor.
"FeynCalc.m" also scans the subdirectories of the directory "HighEnergyPhysics" for files with an extension
".m". Each such file, e.g. "FeynRule.m", should contain the definition of a function, e.g. FeynRule.
Each definition, whether in one of these files or in "FeynCalc.m" is, however, not loaded into memory. Instead the
function name is declared using DeclarePackage, so that when this function is used the first time, the definition
is loaded into memory. This standard technique significantly reduces startup time and memory consumption.
Which subdirectories are scanned is defined in "FeynCalc.m". The idea is that each directory corresponds to a
module, that is, a group of functions pertaining to some subject within quantum field theory. The core modules
are:

fctables. Databases of lagrangians, amplitudes and integrals. The more important functions are: B0, C0,
Lagrangian, Amplitude, Integrate2.

fcloops. Tools for calculating loop integrals. The more important functions are: OneLoop,
PaVeReduce.

fctools. Various tools for working with quantum fields and amplitudes. The more important functions are:
Contract, DiracReduce, FunctionalD, FeynRule, Tr, FermionSpinSum.
DR
general. Mathematical tools of a general nature that are used by one or more functions of the other
subpackages, but may be useful in other contexts as well.
qcd. Tools for working with QCD. The more important functions are: ???.

The governing idea of the file layout of FeynCalc is modularity. The files belonging to each module are in a
separate directory; each file corresponds to one function. If a function uses some support functions or options
that are not used by other functions but desirable to have globally accessible, one may put these in the same
context as the function and add them to the list multifunpack in "FeynCalc.m". The dependence on functions
in other contexts should be clearly stated with MakeContext statements at the beginning of each file.
The modules listed above all adhere to these conventions.
3. Inside FeynCalc 17

As will be noticed there are some files and directories not mentioned so far. Apart from the directory "Documen-
tation", which is a directory for standard Mathematica package documentation, they are listed below under the

T
packages to which they belong. These packages are not loaded by default, but must be enabled by setting certain
configuration variables (see section 3.2). The reasons for this are: These packages are not considered essential
for all users and also don’t follow the loading conventions described above, but load all definitions on startup
and thus take up memory and take some time in loading (still of the order of seconds though).

FeynArts is made up of the file "FeynArts.m" , the directories "GraphInfo", "Models" and some more files
on the top level of "HighEnergyPhysics". It is an independent package by Sepp Kueblbeck, Hagen Eck
and Thomas Hahn for generating Feynman graphs and corresponding amplitudes with Feynman rules as
input. Integration within FeynCalc is not intended, but can, with a few modifications, be achieved (see
PHI below). For more information on FeynArts, see ref 2.

AF
PHI is a package by Frederik Orellana providing utilities for working with effective field theories and
interacting with FeynArts. All files belonging to PHI are contained in the directory "Phi". It was not
conceived as a FeynCalc subpackage and the file layout does not adhere to the FeynCalc conventions.
Never the less, it has been modified to effectively act as a FeynCalc subpackage and is now distributed
only with FeynCalc. For more information on PHI, see ref. ??? and the PHI user’s guide ???.
TARCER is a package by Rolf Mertig for working with 2-loop propagator type integrals. Its file layout
also does not adhere to the FeynCalc conventions, but it also is integrated tightly within FeynCalc. The
files belonging to TARCER are contained in the directory "Tarcer". For more information on FeynArts,
see ref. 6.
fcdevel is code which is not considered production ready and is meant to be used by developers only.

3.2 Configuration and Runtime Variables

As we have seen, the behaviour of most functions is controlled by options like e.g. Dimension. Additionally
the behaviour of some functions depends on the setting of certain environment variables. A few of these should
be set before loading FeynCalc, namely $LoadTARCER, $LoadPhi, $LoadFeynArts.
DR
variable name default value

$LoadTARCER False load TARCER

$LoadPhi False load PHI
$LoadFeynArts False load FeynArts

Variables switching loading of extra packages on and off.

3. Inside FeynCalc 18

Others can be set at runtime; e.g. $Color, $Covariant, $Gauge, $NonComm, $Abbreviations.
$BreitMaison and $Larin are special cases in that they are set at runtime, but, once set cannot be changed.

T
variable name default value

$Color False colour special variables

$Covariant True display lorentz indices as upper or lower indices
$Gauge 1 (Feynman gauge) the gauge fixing parameter of QED in Lorentz

$NonComm

$Abbreviations

$BreitMaison

$Larin

$VeryVerbose
AF {DiracGamma,
DiracGammaT,
..., OPESum}
{"ˆ" ® "", "*"
® "", ...,
"Vector" ® "V"}
False

False

0
gauge. Notice that $Gauge is used by some func-
tions, the option Gauge by others
a list of all noncommutative heads

a list of string substitution rules used when gener-

ating names for storing intermediate results. Used
by OneLoop and PaVeReduce
use the Breitenlohner-Maison Γ 5 scheme (cur-
rently not supported)
use the Larin-Gorishny-Atkyampo-DelBurgo Γ 5
scheme
display intermediate messages from FeynCalc
$MemoryAvailable 8 the amount of available main memory in
megabytes
$SpinorMinimal False a global switch for an additional simplification
attempt in DiracSimplify for more than one
Spinor line
DR
Runtime variables.

The variable $VeryVerbose may be set to 0, 1, 2 or 3. The higher the setting the more intermediate information
is printed during the calculations.
FeynCalc is designed in such a way that certain intermediate results are stored in order to speed up the com-
putations. This of course may become too memory consuming. The storing stops, when the value of 10ˆ
(-6)*MemoryInUse[ ] gets bigger than $MemoryAvailable-1.
The default of FeynCalc is to use the naive Γ 5 prescription, i.e., Γ5 anticommutes with D - dimensional Dirac
3. Inside FeynCalc 19

matrices. Setting $BreitMaison to True changes the commutation behavior of Γ 52 : It anti-commutes with
Dirac matrices in four dimensions, but commutes with the (D-4)-dimensional part. The basic features of the

T
Breitenlohner-Maison scheme are implemented in FeynCalc, but they have not very thoroughly been tested
(some simple calculations are given in section 4.2). Therefore one should check the results for correctness.

3.3 Data Types

In quantum field theory, a number types of variables are needed. E.g. variables representing Lorentz indices,
momenta, SU(N) indices and quantum fields. As we have seen in previous sections, the way to tell FeynCalc that
a variable is of one of these types is to wrap some head around it. However, FeynCalc provides also a method for
having variables be of a certain type without wrapping a head around them. The knowledge about such variables

DataType[__, _] := False

AF
is carried by the function DataType. The default setting is

For example, to assign the data-type PositiveInteger to the variable x, do

DataType[x, PositiveInteger] = True

DataType[x, type] = True

DataType[x1, x2, ...,
type]
defines the symbol x to have data-type type
defines the symbols x1, x2, . . . to have data-type type

The function carrying the knowledge of FeynCalc data-types.

2
In fact, how FeynCalc treats Γ5 depends on the setting of the variables $BreitMaison, $Larin and $West. They are all
boolean variables; the first two specify the Γ5 scheme. None of them have been neither thoroughly implemented nor tested. If $West
DR
is set to True (which is the default), traces involving more than 4 Dirac matrices and a Γ5 are calculated recursively according to formula
(A.5) from [11], which is based on the Breitenlohner Maison -scheme.
3. Inside FeynCalc 20

T
NonCommutative a variable treated as noncommutative by Dot, “.”
PositiveInteger a positive integer variable
NegativeInteger a negative integer variable
PositiveNumber a positive number variable
FreeIndex a Lorentz index not to be contracted by contract
GrassmannParity DataType[F, GrassmannParity] = 1 declares a field F

FeynCalc data-types.

Declare some symbols f and g to

be noncommutative.
An algebraic expression using
Dot, “.”.
AF to be bosonic, DataType[F, GrassmannParity] = -1
declares it to be fermionic.

In[35]:= DataType[f, g, NonCommutative] = True;

In[36]:= t = f.g - g.(2a).f

Out[36]= f .g - g.(2a). f

DotSimplify only extracts a In[37]:= DotSimplify[t]

out of the noncommutative
product. Out[37]= f .g - 2a g. f

Declare some symbols m and a to In[38]:= DataType[m, odd] = DataType[a, even] =

be of data-types even and odd. True;
DR
Define functions for reducing In[39]:= ptest1[x_] := x /. (-1)ˆn_ ¦ -1 /;
powers of -1. DataType[n, odd] ;
ptest2[x_] := x /. (-1)ˆn_ ¦ 1 /;
DataType[n, even];

Redefine the expression t. In[40]:= t = (-1)ˆm + (-1)ˆa + (-1)ˆz

Out[40]= (-1)a + (-1)m + (-1)z

Apply the functions to the In[41]:= ptest1[t]

expression t.
Out[41]= -1 + (-1)a + (-1)z
3. Inside FeynCalc 21

In[42]:= ptest2[%]

T
Out[42]= (-1)z

Clear t. In[43]:= Clear[t];

DeclareNonCommutative[x, sets DataType[x, NonCommutative] = True;

AF
y, ...]

Declaration of noncommutative variables.

3.4
DataType[y, NonCommutative] = True ; ...

Output Forms and Internal Representation

By default, the internal representation is hidden. For some purposes, like debugging or hacking the FeynCalc
source, however, it may be useful to know how the various objects are represented in FeynCalc.
Some input functions are transformed right away to the internal representation, others only on being acted
upon by utility functions. An example of the first kind is DiracMatrix[Μ]. An example of the sec-
ond kind is FourVector[p, Μ]; during the internal evaluation of e.g. Contract[FourVector[p, Μ],
FourVector[p, Μ]], however, a conversion to the internal representation is done. To see the internal repre-
sentation of an object, the function FeynCalcInternal can always be used.
The basic idea is to wrap a special head around each special input variable. For example, the arguments of
MetricTensor[mu, nu] each get a head LorentzIndex. These heads have only a few functional definitions.
A D-dimensional LorentzIndex[mu, D], for example, simplifies to LorentzIndex[mu] when D is replaced
by 4.
Inside FeynCalc the functions and rules are specified in such a way that they only apply to those objects with the
DR
right head. This programming style, which makes strong use of the pattern matching capabilities of Mathematica,
especially the so-called upvalue function definitions, has proven to be useful and reliable for the purpose of
algebraic calculations in physics.
3. Inside FeynCalc 22

T
Pair[a, b] is a special pairing used in the internal representation: a and
b may have heads LorentzIndex or Momentum. If both a
and b have head LorentzIndex, the metric tensor is
understood. If a and b have head Momentum, a scalar product
is meant. If one of a and b has head LorentzIndex and the
other Momentum, a Lorentz vector (e.g. pΜ ) is understood
Momentum[p] is a four-dimensional momentum. For other than four

ExplicitLorentzIndex[Μ]
AF
LorentzIndex[Μ]

Internal representation of Lorentz input functions.

dimensions: Momentum[p, d]. Momentum[p, 4]
simplifies to Momentum[p]
is a four-dimensional Lorentz index. When Μ is an integer, it
evaluates to mbExplicitLorentzIndex[Μ]. For other than four
dimensions: LorentzIndex[p, d]. LorentzIndex[p,
4] simplifies to LorentzIndex[p]
is an explicit Lorentz index, i.e., Μ is an integer

Now we shall study the internal representation through a few examples. FeynCalcInternal shall be applied
when necessary.

Suppress FeynCalc typesetting by In[44]:= SetOptions[$FrontEnd,

going from "CommonDefaultFormatTypes"->"Output"
TraditionalForm output -> StandardForm]
to StandardForm output.
This can also be achieved via the
DR
menu setting of "Cell" ®
"Default Output Format Type".
This is the internal representation In[45]:= DiracMatrix[Μ]
of a ΓΜ in four dimensions.
Out[45]= DiracGamma[LorentzIndex[Μ]]

Here is a ΓΜ in D dimensions. In[46]:= DiracMatrix[Μ, Dimension®D]

Out[46]= DiracGamma[LorentzIndex[Μ, D], D]

3. Inside FeynCalc 23

This is a product of a four- In[47]:= DiracSlash[q] . DiracSlash[q, Dimension

dimensional q/ and a ® D]

T
D-dimensional q/.
Out[47]= DiracGamma[Momentum[q]] . DiracGamma[Momentum[q,
D], D]

This shows the convention for a In[48]:= DiracSimplify[%]

four-dimensional scalar product.
Out[48]= Pair[Momentum[q], Momentum[q]]

The head Pair is also used for In[49]:= MetricTensor[Μ, Ν, Dimension ® D]

metric tensors; in this case in D
dimensions. The dimension is
provided as an argument.

Changing D to 4 recovers the

default for a four-dimensional
gΜΝ .

A four-vector does not

immediately evaluate to the
internal representation.

By applying
FeynCalcInternal we
force the internal representation
to be used: A four-vector is also
represented as a Pair internally.
AF
Out[49]= Pair[LorentzIndex[Μ, D], LorentzIndex[Ν, D]]

In[50]:= % /. D ® 4

Out[50]= Pair[LorentzIndex[Μ], LorentzIndex[Ν]]

In[51]:= FourVector[p, Μ]

Out[51]= FourVector[p, Μ]

In[52]:= FourVector[p, Μ] // FeynCalcInternal

Out[52]= Pair[LorentzIndex[Μ], Momentum[p]]

By applying some utility function, In[53]:= FourVector[p, Μ] FourVector[p, Μ] //

transformation to the internal Contract
representation is automatically
done. Out[53]= Pair[Momentum[p], Momentum[p]]
DR
A (D - 4)-dimensional In[54]:= FourVector[p, Μ, Dimension ® D - 4] //
four-vector. FeynCalcInternal

Out[54]= Pair[LorentzIndex[Μ, -4 + D], Momentum[p, -4 + D]]

It vanishes after changing the In[55]:= % /. D ® 4

dimension.
Out[55]= 0
3. Inside FeynCalc 24

A special kind of 4-vectors are In[56]:= PolarizationVector[k, Μ]

polarization vectors. This shows

T
the internal representation of Out[56]= Pair[LorentzIndex[Μ], Momentum[Polarization[k]]]
these.

DiracGamma[x] head of a four-dimensional ΓΜ or p/

DiracGamma[x, D] head of a D-dimensional ΓΜ or p/

AF
Internal representation of Dirac matrices.

Polarization[k]

Internal representation of Polarization vectors.

A polarization vector ¶(k) is understood when the argument
of Momentum has head Polarization

Internally in FeynCalc, all spinors are represented with the same function, Spinor. Which of the Dirac spinors
u, v and the conjugate spinors u, v are understood, depends on the position of the spinors in the Dirac chain and
the sign of the momentum argument.
DR
Spinor[p, m] u(p, m) or u(p, m)
Spinor[-p,m] v(p, m) or v(p, m)

Internal representation of spinors.

3. Inside FeynCalc 25

The internal representation of In[57]:= SpinorV[-p, m] - SpinorU[p, m] //

v(-p, m) and u(p, m) is the same. FeynCalcInternal

T
Out[57]= 0

Analogously to Lorentz indices, SU(N) indices are also in the internal representation wrapped with a head.

AF
SUNIndex[i]

ExplicitSUNIndex[i]

Internal representation of SU(N) input functions.

is an SU(N) index. When i is an integer, it evaluates to
ExplicitSUNIndex[i]
is an explicit SU(N) index, i.e., i is an integer

After having completed a calculation with FeynCalc and obtained some screen output, a natural question will
often arise: How does one export the results to a file or to some other application. The screen output in
TraditionalForm is not very useful; copying and pasting it to a text editor will produce some very gar-
bled string with all the typesetting codes of Mathematica included. Saving an expression with Put or save will
produce the same as copying the screen output in InputForm, namely the internal representation of FeynCalc,
which is also not very useful, because it contains all the heads, options, etc. FeynCalc needs to make sense of
the expression. For these reasons the FeynCalc external output format exists. An expression in the internal rep-
resentation is translated to the FeynCalc external output format with the command FeynCalcExternal. The
inverse translation is done with FeynCalcInternal.
DR
FeynCalcExternal[exp] translates exp from the internal FeynCalc representation to
the simpler external one (i.e., FV, GA, GS, etc.)
FeynCalcInternal[exp] translates exp into the internal FeynCalc representation

Translation to and from external output format.

3. Inside FeynCalc 26

T
option name default value

FinalSubstitutions {} additional translation rules

Option of FeynCalcExternal and FeynCalcInternal.

The external output form of ΓΜ .

Translation back to the internal

representation.

Switch back to FeynCalc

typesetting by going from
StandardForm output to
TraditionalForm output.
This can also be achieved via the
menu setting of "Cell" ®
AF
In[58]:= FeynCalcExternal[DiracMatrix[Μ],
FinalSubstitutions ® {Μ ® mu}]

Out[58]= GA[mu]

In[59]:= FeynCalcInternal[%, FinalSubstitutions

® {mu ® Σ}]

Out[59]= DiracGamma[LorentzIndex[Σ]]

In[60]:= SetOptions[$FrontEnd,
"CommonDefaultFormatTypes"->"Output"
-> TraditionalForm]

"Default Output Format Type".

3.5 Help system

The help system follows standard Mathematica conventions: Description of an object obj is obtained by evalu-
DR
ating ?obj.

E.g. the description of the In[61]:= ?FeynRule

function FeynRule is obtained Out[61]= FeynRule[lag, fields] gives the Feynman rule corresponding
by evaluating ?FeynRule.
to the field configuration fields of the lagrangian lag.

More in-depth information about e.g. FeynRule can be obtained by typing in FeynRule in the AddOns part of
the help browser (see figure 1).
The files configuring what appears in the help browser are: "FeynCalcBook.nb" and "BrowserCategories.m" in
the directory "HighEnergyPhysics/Documentation/English". The first file is a notebook containing the actual
3. Inside FeynCalc 27

content organized in cells, all of which carry a cell tag. The second file defines the organization of the contents
in terms of the cell tags. After a new install of FeynCalc or a change to one of these files the, "Rebuild Help

T
Index" from the "Help" menu must be selected. Then, after clicking the navigation button "Add-ons" in the help
browser window, in the left pane "High Energy Physics" will appear. Clicking this and the resulting fields in
the other three panes will cause FeynCalc help information to appear. The second pane has various introductory
material and the field "Functions". Clicking this field causes the appearance in the third pane of the fields
"Core", "Tools", "Loops", "Tables", "QCD" and "General" corresponding to the file organization of FeynCalc
as described in section 3.1. Clicking each of these will display a list of the corresponding objects in the fourth
pane. Each of these lists is organized in groups of objects, with the groups in the following order: Functions,
abbreviations, constants, options and finally internal functions which are described only for completeness, but
are of no interest for other than developers.

AF
DR
3. Inside FeynCalc 28

T
AF
DR
Figure 1: The help system of FeynCalc.
4. Elementary Calculations 29

4 Elementary Calculations

T
You can use FeynCalc for basic calculations like Lorentz algebra and Dirac and color trace evaluations. This
chapter contains simple examples of such calculations.

4.1 Lorentz Algebra

The Contract function contracts equal Lorentz indices, if at least one belongs to a metric tensor, a four-vector
or a Levi-Civita tensor.

In four dimensions gΜΜ = 4.

While in D dimensions gΜΜ = D.

AF
Contract[expr]

The function for contraction of tensors.

Out[62]= 4
contract double Lorentz indices in expr

In[62]:= Contract[MetricTensor[Μ, Μ]]

In[63]:= Contract[MetricTensor[Μ, Μ, Dimension ®

D]]

Out[63]= D

Contract gΑΒ pΒ . In[64]:= Contract[MetricTensor[Α, Β]

FourVector[p, Β]]
DR
Out[64]= pΑ

Contract qΑ (p - q)Α . In[65]:= Contract[FourVector[q, Α] FourVector[p -

q, Α]]

Out[65]= (p - q) × q

Numerical factors are pulled out In[66]:= FourVector[2 p, Μ] FourVector[2 p, Μ] //

when calculating with Contract
FourVectors.
Out[66]= 4 p2
4. Elementary Calculations 30

This contracts gΑΒ ΓΑ . In[67]:= Contract[MetricTensor[Α, Β]

DiracMatrix[Α]]

T
Out[67]= ΓΒ

Contracting qΑ ΓΑ yields a In[68]:= Contract[FourVector[q, al]

Feynman slash. DiracMatrix[al]]

Out[68]= Γ × q

Contracting ¶ΜΝΡΣ pΣ gives ¶ΜΝΡp. In[69]:= Contract[LeviCivita[mu, nu, ro, si]

FourVector[p, si]]

The contraction of ¶ΑΝΡΣ ¶ΒΝΡΣ

yields -6 gΑΒ .

option name
AF
Out[69]= ¶ΜΝΡp

In[70]:= Contract[LeviCivita[Α, Ν, Ρ, Σ]
LeviCivita[Β, Ν, Ρ, Σ], ]

Out[70]= -6 gΑΒ

default value

EpsContract False contract Levi-Civita Eps

Expanding True expand the input
Factoring False factor canonically

Options for Contract.

DR
Contracting only In[71]:= Contract[MetricTensor[Α, Σ] *
gΑΣ pΑ pΣ in FourVector[p, Α] FourVector[p, Σ] *
gΑΣ pΑ pΣ (qΒ + rΒ ) (pΒ - sΒ ). (FourVector[q, Β] + FourVector[r, Β]) *
(FourVector[p, Β] - FourVector[q, Β]),
Expanding ® False]

Out[71]= (pΒ - qΒ ) (qΒ + rΒ ) p2

4. Elementary Calculations 31

FeynCalc uses the transversality In[72]:= Contract[FourVector[k, Μ]

condition (kΜ × ¶Μ (k)) = 0 for PolarizationVector[k, Μ]]

T
polarization vectors.
Out[72]= 0

ExpandScalarProduct[expr] expand scalar products and four-vectors in expr

(a + b) × (c - 2d).
AF
MomentumExpand[expr]

MomentumCombine[expr]
expand Momentum[a+b+ ...] in expr into Momentum[a]
+ Momentum[b] + ...
invert the operation of MomentumExpand and
ExpandScalarProduct

Functions for expansion and combination of scalar products and four-vectors.

As an example, expand In[73]:= ExpandScalarProduct[ScalarProduct[a + b,

c - 2 d]]

Out[73]= a × c - 2 a × d + b × c - 2 b × d

Combine again. In[74]:= MomentumCombine[%]

Out[74]= (a + b) × (c - 2d)

Consider again qΑ (p - q)Α . In[75]:= Contract[FourVector[q, Α] FourVector[p -

Contract expands scalar q, Α]]
DR
products.
Out[75]= (p - q) × q

This is how you can substitute In[76]:= % /. ScalarProduct[q, q] ® 0

q2 ® 0 afterwards.
Out[76]= p × q

Instead of substituting scalar products at the end of the calculation another possibility is to assign special values
for scalar products first. These special values are inserted immediately whenever possible during the calculation.

Set q2 = 0 before a calculation. In[77]:= ScalarProduct[q, q] = 0;

4. Elementary Calculations 32

Contracting (and expanding) In[78]:= Contract[FourVector[q, Α] FourVector[p -

qΑ (p - q)Α now yields (p × q). q, Α]]

T
Out[78]= p × q

Clear the value of (p × q). In[79]:= DownValues[Pair] = Select[DownValues[Pair],

FreeQ[#, q]&];

This expands (a + b)Μ to aΜ + bΜ . In[80]:= ExpandScalarProduct[FourVector[a + b,

Μ]]

Out[80]= aΜ + bΜ

4.2 Dirac Algebra

AF
For the manipulation of noncommutative products of Dirac matrices and spinors, a number of functions are
provided (see also section 7.1). DiracEquation applies the Dirac equation without expanding. DiracOrder
orders products of Dirac matrices in a canonical way: Basically it is just the implementation of the anticommu-
tator relation {ΓΜ , ΓΝ } = 2 gΜΝ . Chisholm substitutes products of three Dirac matrices or slashes in expr using the
Chisholm identity.

DiracEquation[expr] apply the Dirac equation

Chisholm[expr] apply the Chisholm identity
DiracOrder[expr] alphabetical ordering of Dirac matrices in expr
DiracOrder[expr, {a, b, ordering according to a, b, ...
...}]
DR
Manipulation functions for Dirac matrices and spinors.

All functions take as expr any expression with "." as the noncommutative multiplication operator between Dirac
matrices or Dirac slashes.

The Dirac equation. In[81]:= (# Š DiracEquation[#])&[DiracSlash[p] .

Spinor[p, m]]

Out[81]= (Γ × p) .j(p, m) Š m j(p, m)

4. Elementary Calculations 33

The Chisholm identity. In[82]:= (# Š Chisholm[#])&[DiracMatrix[Μ, Ν, Ρ]]]

T
Out[82]= ΓΜ ΓΝ ΓΡ Š ä Γ$MU$26 . Γ5 ΕΜΜΡ$MU$26 + ΓΡ gΜΝ - ΓΝ gΜΡ + ΓΜ gΝΡ

Order the product In[83]:= DiracOrder[DiracMatrix[Β, Α]]

ΓΒ ΓΑ ® 2 gΑΒ - ΓΑ ΓΒ .
Out[83]= 2 gΑΒ - ΓΑ ΓΒ

Anticommute back to ΓΒ ΓΑ . In[84]:= DiracOrder[%, {Β, Α}]

Out[84]= ΓΒ ΓΑ

Simplifications like
ΓΜ ΓΜ /p /p = 4 p2 are built in.

ΓΑ ΓΜ ΓΑ = (2 - D) ΓΜ in D
dimensions.

-p/ /q /p = /q p2 - 2 /p (p × q).
AF In[85]:= DiracOrder[DiracMatrix[Μ, Μ],
DiracSlash[p, p]]

Out[85]= 4 p2

In[86]:= DiracOrder[DiracMatrix[a, m, a,
Dimension ® D]]

Out[86]= 2 Γm - D Γm

In[87]:= DiracOrder[DiracSlash[-p, q, p]]

Out[87]= Γ × q p2 - 2 Γ × p p × q

DotSimplify expands and reorders noncommutative terms using relations specified by the option
DotSimplifyRelations or by Commutator and/or AntiCommutator definitions. Whether noncommu-
tative expansion is done depends on the option Expanding. Notice that in the rules of the setting of
DotSimplifyRelations, Condition should not be used and patterns should be avoided on the right-
hand sides. Also, the performance of DotSimplify scales inversely and very badly with the complexity of
DotSimplifyRelations and the number of terms of the expression to be simplified.
DR
DotSimplify[expr] expand and reorder noncommutative terms

Simplification of noncommutative products.

4. Elementary Calculations 34

T
option name default value

Expanding True noncommutatively expand the result

DotSimplifyRelations {} a list of substitution rules of the form
DotSimplifyRelations ® {a . b ®
c, bˆ2 ® 0, ...}
DotPower False whether noncommutative powers are represented
by successive multiplication or by Power.

Options for DotSimplify.

This is a four-dimensional
product:
2b/ a/ 2 (d/ - /c) (6 q/ - 3 p/).
DotSimplify pulls common
numerical factors out.

Here is another product. Notice

that we are using the shorthand
FeynCalcExternal form
(see section 3.4) for input.
AF
In[88]:= DiracSlash[2 b, a, 2 (d - c), (6 q - 3
p)] // DotSimplify

Out[88]= -12 Γ × b Γ × a Γ × (d - c) Γ × (p - 2 q)

In[89]:= GA[Μ].(a GS[p] - b GS[q]).GS[q].GA[Ν]]

Out[89]= ΓΜ . (a Γ × p - b Γ × q) . (Γ × q) . ΓΝ

With Expanding -> True In[90]:= DotSimplify[%, Expanding -> True]

sums are distributed over. This
also causes symbols not known Out[90]= a ΓΜ . (Γ × p) (Γ × q) . ΓΝ - b ΓΜ (Γ × q) . (Γ × q) . ΓΝ
as being noncommutative (see
section 3.3) to be pulled out.
DR
With DotPower -> True In[91]:= DotSimplify[%, DotPower -> True]
dot products of identical objects
are replaced with powers. Out[91]= a ΓΜ . (Γ × p) (Γ × q) . ΓΝ - b ΓΜ (Γ × q)2 . ΓΝ

One may specify relations to be In[92]:= DotSimplify[%, DotPower -> True,

included in the simplification DotSimplifyRelations -> {GS[q]ˆ2 -> 1}]
process.
Out[92]= a ΓΜ . (Γ × p) (Γ × q) . ΓΝ - b ΓΜ . ΓΝ

Declare some symbols as In[93]:= DeclareNonCommutative[a, b, c];

noncommuting and define a Commutator[a, c] = 1;
commutator.
4. Elementary Calculations 35

DotSimplify uses this In[94]:= DotSimplify[a . (b - z c) . a]

information.

T
Out[94]= a . b . a - z (a + c . a . a)

Clear definitions. In[95]:= UnDeclareNonCommutative[a, b, c];

Commutator[a, c] = 0;

AF
DiracSimplify[expr]
DiracSimplify2[expr]

DiracReduce[expr]

DiracTrick[expr]
contract all Lorentz indices and simplify
like DiracSimplify but leaves any Γ5 untouched. Γ6 and
Γ7 are replaced with their definitions
reduce Dirac matrices to the standard basis (S, P, V , A, T )
using the Chisholm identity
contracts gamma matrices with each other and performs
several simplifications, but no expansion

Simplification functions for Dirac matrices and spinors.

All functions take as expr any expression with "." as the noncommutative multiplication operator between Dirac
matrices or Dirac slashes.
DR
DiracBasis a head wrapped around Dirac structures (and 1) by
DiracReduce)

A head used by DiracReduce.

DiracSimplify contracts Dirac matrices with equal indices, moves Γ 5 , Γ6 and Γ7 to the right, applies the
Dirac equation and expands noncommutative products (see section 3.2). The Dirac matrices in the result of
DiracSimplify are only ordered in a canonical way if they are between spinors. See below and section 3.2 for
the treatment of Γ5 in D dimensions.
4. Elementary Calculations 36

This is ΓΜ ΓΜ = D. In[96]:= DiracSimplify[DiracMatrix[Μ, Μ,

Dimension ® D]]

T
Out[96]= D

Here the Kahane algorithm is In[97]:= DiracSimplify[DiracMatrix[Μ, Ν, Ρ, Σ, Μ]]

used.
ΓΜ ΓΝ ΓΡ ΓΣ ΓΜ = -2 ΓΣ ΓΡ ΓΝ . Out[97]= -2 ΓΣ . ΓΡ . ΓΝ

Kahane also gives this identity: In[98]:= DiracSimplify[1/2 DiracMatrix[Μ, Α, Β, Γ,

1 Μ Α Β Γ ∆ Μ
2
Γ Γ Γ Γ Γ Γ = ∆, Μ]]
ΓΓ ΓΒ ΓΑ Γ∆ + Γ ∆ ΓΑ ΓΒ ΓΓ .

This is
/p (m-q

This is Γ5 ΓΜ = -ΓΜ Γ5 .

Γ6 ΓΝ Γ7 ΓΜ = Γ Ν ΓΜ Γ6 .
AF
/ ) /p = /q p2 + p2 m-2 /p (p×q).
Out[98]= ΓΓ . ΓΒ . ΓΑ . Γ∆ + Γ∆ . ΓΑ . ΓΒ . ΓΓ

In[99]:= DiracSimplify[DiracSlash[p],
DiracSlash[-q] + m, DiracSlash[p]]

Out[99]= Γ × q p2 + m p2 - 2 Γ × p p × q

In[100]:= DiracSimplify[DiracMatrix[5],
DiracMatrix[Μ]]

Out[100]= -ΓΜ Γ5

In[101]:= DiracSimplify[DiracMatrix[6, Ν, 7, Μ]]

Out[101]= ΓΝ ΓΜ Γ6

This is (p/ - m) u(p) = 0. In[102]:= DiracSimplify[(DiracSlash[p] - m) .

SpinorU[p, m]]

Out[102]= 0
DR
Here is the Dirac equation for In[103]:= DiracSimplify[(DiracSlash[p] + m) .
v(p): (p/ + m) v(p) = 0. SpinorV[p, m]]

Out[103]= 0

For the conjugate spinor: In[104]:= DiracSimplify[SpinorUBar[p, m] .

u (p/ - m) = 0. (DiracSlash[p] - m)]

Out[104]= 0
4. Elementary Calculations 37

This is v q/ (p/ - m) = 2 v p × q. In[105]:= DiracSimplify[SpinorVBar[p, m] .

DiracSlash[q] . (DiracSlash[p] - m)]

T
Out[105]= 2 p × q j(-p, m)

Also more complicated structures In[106]:= DiracSimplify[SpinorVBar[p, m] .

are simplified; for example, DiracSlash[q, p] . SpinorU[q, M]]
v(p) q/ p/ u(q) =
v(p) u(p) [ 2 (p × q) + m M ]. Out[106]= j(-p, m) . j(q, M) (m M + 2 p × q)

The behaviour of DiracSimplify may be tuned with the setting of various options.

option name

DiracCanonical
DiracSigmaExplicit

DiracSimpCombine

DiracSubstitute67
Expanding
AF
default value

False
True

False

False
True
use DiracOrder internally
substitute the explicit representation of Σ (also a
function )
try merging DiracGamma’s in DiracGamma[ ..
+ .. + ]’s
substitute the explicit representation of Γ 6 and Γ7
when set to False only a limited set of simplifica-
tion rules are used
Factoring False factor canonically
InsideDiracTrace False assume the expression being simplified is inside a
Dirac trace
DR
Options for DiracSimplify.

DiracReduce reduces all four-dimensional Dirac matrices to the standard basis (S, P, V , A, T ) using the
Chisholm identity. In the result the basic Dirac structures are wrapped with a head DiracBasis. I.e., S corre-
sponds to DiracBasis[1], P : DiracBasis[DiracMatrix[5]], V : DiracBasis[DiracMatrix[Μ]],
A: DiracBasis[DiracMatrix[Μ, 5]], T : DiracBasis[DiracSigma[DiracMatrix[Μ, Ν]]]. By
default DiracBasis is substituted with Identity. Notice that the result of DiracReduce is given in
FeynCalcExternal notation, i.e., evtl. you may want to use FeynCalcInternal on the result.
4. Elementary Calculations 38

T
option name default value

Factoring False factor canonically

FinalSubstitutions {} substitutions done at the end of the calculation

Options for DiracReduce.

Reducing a product of two Dirac

matrices to a standard basis.

Reducing a product of three Dirac

matrices to a standard basis.

Reducing a product of four Dirac

matrices to a standard basis.

Contract the square of the this.

AF In[107]:= DiracReduce[DiracMatrix[Μ, Ν]]

Out[107]= gΜΝ - ΣΜΝ

In[108]:= DiracReduce[DiracMatrix[Μ, Ν, Ρ]]

Out[108]= äΓMu(1) . Γ5 ΕΜΝΡMu(1) + ΓΡ gΜΝ - ΓΝ gΜΡ + ΓΜ gΝΡ

In[109]:= DiracReduce[DiracMatrix[Μ, Ν, Ρ, Σ]]

Out[109]= -ä Γ5 ΕΜΝΡΣ - ä ΣΡΣ gΜΝ + ä ΣΝΣ gΜΡ - ä Σ ΝΡ gΜΣ - ä ΣΜΣ gΝΡ +

gΜΣ gΝΡ + ä ΣΜΡ gΝΣ - gΜΡ gΝΣ - ä ΣΜΝ gΡΣ + gΜΝ gΡΣ

In[110]:= Contract[DiracSimplify[% . %]]

Out[110]= -128

Calc does the full job. In[111]:= Calc[%% . %%]

Out[111]= -128
DR
Calc[expr] applies DotSimplify, DiracSimplify, EpsEvaluate,
Contract and other functions to expr, trying to reduce to
the simplest form

The highest-level FeynCalc simplification function.

4. Elementary Calculations 39

As mentioned in section 3.2, basic features of the Breitenlohner-Maison scheme [14] (for a short explanation
of the Breitenlohner-Maison symbols like Γ̂ Μ , see e.g. ref. 15) are implemented. Below are given some simple

T
illustrations.

Setting the Breitenlohner-Maison In[112]:= $BreitMaison = True;

Γ5 scheme.
Entering Γ5 ΓΜ , with ΓΜ In[113]:= DiracMatrix[5] . DiracMatrix[Μ,
D-dimensional. Dimension ®D]

Out[113]= Γ5 . ΓΜ

Now only the 4-dimensional part In[114]:= DiracSimplify[%]

of ΓΜ anticommutes, while the
D - 4 dimensional part 2 Γ̂Μ
commutes.

Project out the positive chirality

part of ΓΜ .

The expression is expanded and

Γ5 is moved to the right.

Go back to naive Γ5 scheme (for

some operations a kernel restart
AF
Out[114]= 2 Γ̂Μ . Γ5 - ΓΜ . Γ5

In[115]:= DiracMatrix[6] . DiracMatrix[Μ,

Dimension®D]

Out[115]= Γ6 . ΓΜ

In[116]:= DiracSimplify[%]

Out[116]=
ΓΜ
2
+ Γ̂Μ . Γ5 -
ΓΜ . Γ 5
2
In[117]:= $BreitMaison = True;

is necessary).

4.3 Dirac Traces

The function DiracTrace takes as expr either subsequent DiracMatrix or DiracSlash separated by "," or
DR
any expression with "." as noncommutative multiplication operator.
The default of DiracTrace is not to evaluate Dirac traces directly. For direct calculation the function Tr can be
used.
 4. Elementary Calculations 40

T
DiracTrace[expr] head of a Dirac trace
Tr[expr] calculate the trace directly

Two Dirac trace functions.

tr( ΓΑ ΓΒ ) = 4 gΑΒ . In[118]:= Tr[DiracMatrix[Α, Β]]

tr( a/ /b /c d/ ) = 4 {(a × d)(b × c) - (a ×

c)(b × d) + (a × b)(c × d) }.

tr( Γa Γb Γc Γd Γ5 ) = -4 i ¶a b c d .

You may include metric tensors or

four-vectors, for example,
tr( 41 gΑΒ ΓΜ ΓΑ pΜ ) = pΒ .
AF Out[118]= 4 gΑΒ

In[119]:= Tr[DiracSlash[a, b, c, d]]

Out[119]= 4 (a × d b × c - a × c b × d + a × b c × d)

In[120]:= Tr[DiracMatrix[Α, Β, Γ, ∆, 5]]

Out[120]= -4 ä ¶Α Β Γ ∆

In[121]:= Tr[MetricTensor[Α, Β]/4

DiracMatrix[Μ].DiracMatrix[Α]
FourVector[p, Μ]] // Contract

Out[121]= pΒ

If you want to do more complicated traces it is often convenient to introduce your own abbreviations. The
following examples, some of which verify results given in [19], show how to do this.
DR
Consider a trace corresponding to the square of the s-channel diagram for Γe scattering:

1
T1 = tr[ (p/ ¢ + m) ΓΑ (p/ + k/ + m) ΓΒ (p/ + m) ΓΒ (p/ + k/ + m) ΓΑ ]
16

Set the abbreviations for Dirac In[122]:= (pps = DiracSlash[p’];

matrices and slashes here. ps = DiracSlash[p];
ks = DiracSlash[k];
a = DiracMatrix[Α];
b = DiracMatrix[Β];)
4. Elementary Calculations 41

This is the input for the trace T1 . In[123]:= Tr[(pps + m).a.(ps + ks + m).b.(ps +
The CPU time needed for the m).b.(ps + ks + m).a/16]//Expand

T
calculation is of the order of
seconds. Out[123]= 4 m4 + 4 k2 m2 + 4 k × p m2 - 4 k × p¢ m2 - 3 p × p¢ m2 +
2 k × p k × p¢ + 2 k × p¢ p2 - k2 p × p¢ + p2 p × p¢
Clear symbols used. In[124]:= Clear[pps, ps, ks, a, b];

Another nontrivial example is a D-dimensional trace involving 14 Dirac matrices:

T2 = tr( ΓΒ ΓΑ p/1 p/2 ΓΝ ΓΒ p/2 p/3 ΓΑ p/1 ΓΝ p/3 p/1 p/2 )

This defines abbreviations for

trace T2 . a, b, n denote ΓΑ , ΓΒ , ΓΝ
in D dimensions.
The last command sets ps1 = /p1 ,
ps2 = /p2 , ps3 = /p3 .
Here is the input for trace T2 .
The result is again collected with
respect to scalar products.
AF
In[125]:= a = DiracMatrix[Α, Dimension -> D];
b = DiracMatrix[Β, Dimension -> D];
n = DiracMatrix[Ν, Dimension -> D];
{ps1, ps2, ps3} = Map[DiracSlash, {p1,
p2, p3}];
In[126]:= Tr[b.a.ps1.ps2.n.b.ps2.ps3.a.ps1.n.ps3.ps1.ps2,
PairCollect ® True]

Out[126]= 4 ((-288 + 224 D - 56 D2 + 4 D3 ) p1 × p2 p1 × p3 2 p22 +

(256 - 128 D + 16 D2 ) p1 × p2 2 p1 × p3 p2 × p3 + (112 -
104 D + 28 D2 - 2 D3 ) p21 p1 × p3 p22 p2 × p3 + (-128 + 64 D -
8 D2 ) p21 p1 × p2 p2 × p3 2 + (-128 + 64 D - 8 D2 ) p1 × p2 3 p23 +
(168 - 104 D + 20 D2 - D3 ) p21 p1 × p2 p2 × p2 p23 )

This calculates T2 in four In[127]:= Tr[b.a.ps1.ps2.n.b.ps2.ps3.a.ps1.n.ps3.ps1.ps2

dimensions. Since the "." is used, /. D ®4, PairCollect ® True]
the replacement D ® 4 applies
to all Dirac matrices. The time Out[127]= 4 (-32 p1 × p2 p22 p1 × p32 + 16 p12 p22 p2 × p3 p1 × p3 +
needed would be twice as much 8 p12 p1 × p2 p22 p32 )
without calculating the
D-dimensional case before.
DR
Clear symbols used. In[128]:= Clear[a, b, n, ps1, ps2, ps3];

Sometimes you do not want a In[129]:= DiracTrace[DiracMatrix[Α, Β, Ρ, Σ]]

trace to be evaluated immediately.
Here you get the input Out[129]= tr(ΓΑ ΓΒ ΓΡ ΓΣ )
tr( ΓΑ ΓΒ ΓΡ ΓΣ ) back (typeset).

You may then contract, e.g., with In[130]:= Contract[% MetricTensor[Α, Β]]
gΑΒ .
Out[130]= tr(ΓΒ ΓΒ ΓΡ ΓΣ )
4. Elementary Calculations 42

This evaluates the Dirac trace. In[131]:= % /. DiracTrace ® Tr

T
Out[131]= 16 gΡΣ

option name default value

DiracTraceEvaluate False evaluate the trace

LeviCivitaSign

Factoring
Mandelstam
PairCollect
Schouten

TraceOfOne
FeynCalcExternal

EpsContract
AF
-1

False
{}
True
0

0
0

False
which sign convention to use in the result of
tr( Γa Γb Γc Γd Γ5 ). The default gives (-1)4 i ¶a b c d
factor canonically
utilize the Mandelstam relation
collect Pairs
maximum number of terms on which to apply the
Schouten identity
the trace of an identity matrix
give output in FeynCalcExternal form (see sec-
tion 3.4)
contract Levi-Civita Eps

Options for DiracTrace.

Tr takes the options of DiracTrace, but the default setting of DiracTraceEvaluate is True. Additionally, Tr
takes the two options SUNTrace and SUNNToCACF, which control if and how SU(N) traces are evaluated. This
is elaborated upon in section 4.4.
DR
The option PairCollect determines whether the resulting polynomial is collected with respect to metric ten-
sors, four-vectors and scalar products. In the internal representation these three objects have the same head Pair,
hence the name PairCollect.
For 2 ® 2 processes the traces are often expressed in terms of Mandelstam variables. In order to replace these
for the scalar products you can use SetMandelstam.
4. Elementary Calculations 43

T
SetMandelstam[s, t, u, define scalar products in terms of Mandelstam variables and
p1 , p2 , p3 , p4 , m1 , m2 , m3 , put the pi on-shell
m4 ]

A function for introducing Mandelstam variables.

Assuming all pi incoming, i.e., p1 + p2 + p3 + p4 = 0, the Mandelstam variables are defined by

AF s = (p1 + p2 )2 , t = (p1 + p3 )2 , u = (p1 + p4 )2 .

products (pi × p j ) in terms of s, t, u and mi .

For calculation of traces the Mandelstam relation
2 2
Using these three equations and the on-shell conditions, p i = mi , SetMandelstam sets the 10 possible scalar
2

s + t + u = m21 + m22 + m23 + m24

can often be used to get a compact result. If you set the option
Mandelstam ® {s, t, u, m1ˆ2 + m2ˆ2 + m3ˆ2 + m4ˆ2}

FeynCalc tries to figure out the best choice of s, t or u in each factor of the result.
As an example for calculating a trace in terms of Mandelstam variables, consider the following squared amplitude
ΑΡ ΒΡ
from the process gg ® tt, with S1 and S2 as polarization sums for the gluons.
Α Β ΑΡ ΒΣ
T3 = tr( ΓΣ (k/1 - p/1 - mt ) ΓΡ (p/1 + mt )(p/2 - mt ) ) p1 p2 S1 S2 ,
ΑΡ Α Ρ Ρ Α
S1 = -gΑΡ + 4 Α Ρ
2 (4 mt - s) k1 k1 + u-t [k1 (p1 - p2 ) + k1 (p1 - p2 ) ]
2 2
DR
(u-t)
ΒΣ Β Σ Σ Β
S2 = -gΒΣ + 4
(t-u)
Β Σ
2 (4 mt - s) k2 k2 + t-u [k2 (p1 - k2 ) + k2 (p1 - p2 ) ]
2 2
4. Elementary Calculations 44

Set up s, t, u for gg ® tt, with In[132]:= SetMandelstam[s,t,u, k1,k2,-p1,-p2,

k1 , k2 as gluon and p1 , p2 as 0,0,m,m];

T
fermion momenta. Again {ks1, ps1, ps2} = Map[ DiracSlash, {k1,
abbreviations with capital letters p1, p2} ];
are introduced for the Dirac {si, ro} = Map[ DiracMatrix,{Σ, Ρ} ];
matrices and slashes. polsum1 polsum1 = PolarizationSum[Α, Ρ, k1, p1 -
and polsum2 are the polarization p2];
sums for the gluons. As external polsum2 = PolarizationSum[Β, Σ, k2, p1 -
momentum the choice p2];
n = p1 - p2 has been made. p1al = FourVector[p1, alpha];
p2be = FourVector[p2, Β];

This is a possible input for trace In[133]:= Tr[ (polsum1 polsum2 p1al p2be si) .
T3 . FeynCalc contracts first all
Lorentz indices and then
calculates the trace.
Since the option Mandelstam
has been specified, the result is
given in a factored form, where in
each factor one of s, t or u is
eliminated via the Mandelstam
relation. Note that a factor (t - u)
has been cancelled.

An alternative method would be

to first calculate the trace without
the polarization sums.
AF (ks1 - ps1 - m) . ro . (ps1 + m) .
(ps2 - m), Mandelstam ® {s, t, u, 2 mˆ2}
]

Out[133]= -
2 m s (m4 - t u) (8 m4 - t 2 - u2 - 6 t u)
(t - u)3

In[134]:= Tr[si, ks1 - ps1 - m, ro, ps1 + m, ps2 -

m]

Out[134]= (-2 m t + 2 m u) gΡΣ - 4 m k1Σ p1Ρ - 4 m k1Ρ p1Σ +

8 m p1Ρ p1Σ + 4 m k1Σ p2Ρ + 4 m k1Ρ p2Σ - 8 m p1Ρ p2Σ

Then contract the result with In[135]:= TrickMandelstam[ExpandScalarProduct[Contract[

the polarization sums, expand the % polsum1 polsum2 p1al p2be]], {s, t, u,
scalar products and use 2 mˆ2}]
TrickMandelstam (see
section 7.7) in order to get the 2 m s (m4 - t u) (8 m4 - t 2 - u2 - 6 t u)
DR
Mandelstam variable substitution. Out[135]= -
This method is faster; but that is (t - u)3
not the case for all trace
calculations.

Clear symbols used. In[136]:= Clear[ks1,ps1,ps2,si,ro,polsum1,polsum2,p1al,p2be];

Since Dirac matrices can be given in any dimensions, FeynCalc is also able to calculate traces in D-4 dimensions.
Defining T (n) = tr(ΓΜ1 ΓΜ2 ...ΓΜn ΓΜ1 ΓΜ2 ...ΓΜn ) we give a list of timings and results for T (8) to T (11). The trace
T (10) is a verification of the result given in [18].
4. Elementary Calculations 45

This is a little program defining T . In[137]:= T[n_] := T[n] = Block[{gammas, calc},

The dimension of each particular gammas = Dot @@ Table[

T
Dirac matrix is set to d - 4. DiracMatrix[a[i], Dimension ® (d - 4)],
The calculations were done with {i, 1, n} ];
Mathematica 4.2 under Linux on calc = Timing[ Tr[ gammas . gammas ] //
a 1.8 GHz Pentium 4 box with Expand ];
256 MB of RAM. Print["Time = ", calc[[1]] ];
calc[[2]]];

This calculates a trace of 16 In[138]:= T[8]

matrices.
Time = 0.58 Second

Here we have 18.

The trace of 20 Dirac matrices.

AF Out[138]= 123469824 - 135962624 d + 63224832 d 2 - 16145920 d 3 +
2461760 d 4 - 227584 d 5 + 12320 d 6 - 352 d 7 + 4 d 8

In[139]:= T[9]
Time = 1.6 Second

Out[139]= -1879576576 + 2220901376 d - 1127626752 d 2 +

321806848 d 3 - 56625408 d 4 + 6331584 d 5 -
446208 d 6 + 18912 d 7 - 432 d 8 + 4 d 9

In[140]:= T[10]
Time = 5.88 Second

Out[140]= -31023169536 + 38971179008 d - 21328977920 d 2 +

6679521280 d 3 - 1320732160 d 4 + 171464832 d 5 -
14710080 d 6 + 816960 d 7 - 27840 d 8 + 520 d 9 - 4 d 10

With 22 Dirac matrices it gets In[141]:= T[11]

slow.
Time = 23.15 Second
DR
Out[141]= 551768735744 - 731506905088 d + 427299186688 d 2 -
144858475520 d 3 + 31576821760 d 4 - 4629805312 d 5 +
463655808 d 6 - 31521600 d 7 + 1415040 d 8 - 39600 d 9 +
616 d 10 - 4 d 11

4.4 SU(N) Traces and Algebra

The functions for calculations with SU(N) matrices and the corresponding structure constants were developed
for calculations in N-dimensional color space. More specialized functions developed for calculations in 2- and
4. Elementary Calculations 46

3-dimensional flavor space (Pauli and Gell-Mann matrices) are proveded by the subpackage PHI. These are
described in the PHI user’s guide ???.

T
SUNTrace[expr] calculate the trace of SU(N) matrices

Trace calculation of SU(N) matrices in the fundamental representation.

Explicit

Option for SUNTrace.

AF
Like Dirac traces, traces of the SU(N) matrices Ti are calculated algebraically. The matrices are assumed to be
in the fundamental representation and traces are given in terms of N.

option name default value

False evaluate the trace

SUNDeltaContract[expr] contract SUNDeltas

SUNSimplify[expr] simplify polynomials in the SU(N) Kronecker delta ∆ i j and
DR
structure functions f i jk , di jk and generating matrices Ti

Functions for simplifying expressions with SU(N) matrices and structure functions.

The result of SUNSimplify involves either N or the Casimir invariants CA and CF . Which, depends on the
setting of the option SUNNToCACF.
4. Elementary Calculations 47

T
SUNN the N of SU(N)
CA CA = N in the funcamental representation
CF CF = (N 2 - 1)/ (2N) in the funcamental representation

Casimir invariants of SU(N).

option name

SUNTrace

Explicit

Factoring
AF default value

False

False

False
if set to False, then any SUNT-matrices are taken
out of DiracTrace[...]; otherwise a color-trace
is taken (by SUNTrace) before taking the SU(N)
objects in front of DiracTrace[...]
express structure functions ( f i jk , di jk ) in terms of
traces of generator matrices (Ti )
factor the result
SUNIndexRename True rename contracted SU(N) indices systematically
SUNFJacobi False use the Jacobi identity
SUNNToCACF True express the result in terms of the Casimir invariants
CA and CF instead of N
Expanding False do noncommutative expansion
DR
Options for SUNSimplify.

To evaluate f a b c use the option In[142]:= SUNF[a, b, c, Explicit ® True]

Explicit ® True.
The input form of the trace in the Out[142]= 2ä (tr(Ta Tc Tb ) - tr(Ta Tb Tc ))
output is Tr.
4. Elementary Calculations 48

tr(Ta Tb ) = ∆a b / 2. In[143]:= SUNTrace[SUNT[a] . SUNT[b]]]

T
∆a b
Out[143]=
2

tr(3 Ta Tb Ta Tb ) = 1/ (4N) - N/ 4. In[144]:= SUNTrace[SUNT /@ (a.b.a.b)]

1 N
Out[144]= -
4N 4

tr(Ta Tb Tc ) stays as it is. In[145]:= SUNTrace[SUNT /@ (a.b.c)]

tr(Ta Tb Tc fa b c ) = i CA2 CF / 2.

tr( fa r s fb r s ) = CA fa r s fb r s =
CA2 ∆a b .

The Jacobi identity:

AF Out[145]= tr(Ta Tb Tc )

In[146]:= SUNTrace[SUNF[a, b, c] SUNT /@ (a.b.c)]

Out[146]=
// SUNSimplify

1
2
ä CA2 CF

In[147]:= SUNF[a, r, s] SUNF[b, r, s] //

SUNSimplify

Out[147]= CA2 ∆a b

In[148]:= SUNSimplify[SUNF[a,b,r] SUNF[r,c,s] +

fa b r fr c s + fb c r fr a s + fc a r fr b s = 0. SUNF[b,c,r] SUNF[r,a,s] + SUNF[c,a,r]
SUNF[r,b,s], SUNFJacobi ® True]

Out[148]= 0

Ta Tb Ta = - 12 (CA - 2CF ) Tb . In[149]:= SUNT[a, b, a] // SUNSimplify

DR
1
Out[149]= - (C - 2CF ) Tb
2 A

This is fa b c Tb Tc = i CA Ta / 2. In[150]:= SUNF[c, a, b] SUNT[b, c] // SUNSimplify

1
Out[150]= äC T
2 A a
4. Elementary Calculations 49

4.5 Green’s functions

T
Quantum fields (see section 2.7) can be combined in polynomials to form lagrangians. From such lagrangians,
the Green’s function or Feynman rule of an interaction vertex can be found by calculating functional derivatives
with respect to the fields of the vertex. As a very simple example, consider the vertex obtained from the following
term of the QED lagrangian:

Mathematica (FeynCalc) notation In[151]:= e QuantumField[ , { }].QuantumField[Ψ].

¯ Μ Ψ.
for eAΜ ΨΓ DiracMatrix[{ }].QuantumField[ ]



¯ ΜΨ
Out[151]= eAΜ ΨΓ

rule.

AF
Calculation of the ΨΨΓΜ3 Feynman In[152]:= FeynRule[%,
{QuantumField[ ][p1],
QuantumField[Ψ][p2],

Out[152]= ieΓΜ3


QuantumField[ , { 3}][p3]}]

Notice that FeynRule does not write out the momentum conserving ∆(p 1 + p2 + p3 ). As we shall see later, this
is anyway enforced if the vertex is used for Feynman diagram calculations.
Besides calculating the functional derivative, FeynRule does some simplification on the result and transforms to
momentum space. To calculate the functional derivative FeynRule uses a lower level function: FunctionalD.
Contrary to FeynRule FunctionalD does do any cleaning up on the result and therefore may be faster but
return longer expressions.
By default FunctionalD operates in position space. However, no explicit space-time symbols should be given
and none will be returned. Thus, a few conventions are used: Instead of the usual ∆Φ(x)/ ∆Φ(y) = ∆ (D) (x - y) the
arguments and the ∆ function are omitted, i.e., for simplicity ∆Φ/ ∆Φ is taken to be 1. Similarly, instead of the
usual ∆¶Μ Φ(x)/ ∆Φ(y) = ¶Μ ∆(D) (x - y) the arguments are omitted, and the ¶ Μ operator is specified by default to be
-
®
an integration by parts operator, i.e., the right-hand side will be just -¶ Μ or, more precisely (by default), -¶Μ .
If the QuantumFields of the first argument (e.g. a lagrangian) of FunctionalD are given an extra argument
DR
(e.g. QuantumField[...][p]), the argument is assumed to be a momentum and transformation to momentum
space is done.
4. Elementary Calculations 50

T
FunctionalD[expr, calculates the functional derivative of expr with respect to
fi1[p1], fi2[p2], ...] quantum fields fi1, fi2, × × × and does the Fourier transform to
field momenta p1, p2, × × ×
FunctionalD[expr, fi1, calculates the functional derivative of expr and does partial
fi2, ...] integration but omits the x-space delta functions.
FeynRule[lag, fi1[p1], calculates the Feynman rule of lag with respect to fields fi1,
fi2[p2], ...] fi2, × × × and momenta p1, p2, × × ×

Calculation of Green’s functions.

Define a two-gluon product aa

with contracted indices.

Calculate the functional

derivative.
AFIn[153]:= aa = QuantumField[PartialD[LorentzIndex[ ]],
GaugeField, LorentzIndex[ ],
SUNIndex[a]].QuantumField[
PartialD[LorentzIndex[ ]], GaugeField,
LorentzIndex[ ], SUNIndex[a]]

Out[153]= ¶Β AaΑ ¶Β AaΑ

In[154]:= dd = FunctionalD[aa,

QuantumField[GaugeField, { 1}, {i1}],

QuantumField[GaugeField, { 2}, {i2}]]

-
®- ®
Out[154]= -2¶Β .¶Β gΜ1Μ2 ∆i1i2
See the internal representation. In[155]:= dd // StandardForm
Notice the symbol
DR
RightPartialD. Out[155]= -2 RightPartialD[LorentzIndex[ ]] .
RightPartialD[LorentzIndex[ ]]
Pair[LorentzIndex[ 1], LorentzIndex[ 2]]

SUNDelta[SUNIndex[i1], SUNIndex[i2]]
We can apply dd to some other In[156]:= dd . QuantumField[ , { 1}, {i1}] //


field Ψ. ExpandPartialD

Out[156]= -2gΜ1Μ2 (¶Β ¶Β Ψi2

Μ1 )
4. Elementary Calculations 51

See the internal representation. In[157]:= dd // StandardForm

Notice that applying

T
ExpandPartialD causes Out[157]= -2 RightPartialD[LorentzIndex[ ]] .
RightPartialD to RightPartialD[LorentzIndex[ ]]
disappear in favour of Pair[LorentzIndex[ 1], LorentzIndex[ 2]]

PartialD. SUNDelta[SUNIndex[i1], SUNIndex[i2]]

Calculate the corresponding In[158]:= FunctionalD[aa, {QuantumField[GaugeField,

Feynman rule (in momentum { 1}, {i1}][p1], QuantumField[GaugeField,

space). { 2}, {i2}][p2]}]

Out[158]= I-ägΑΜ1 p1Β ∆Αi1 M . I-ägΑΜ2 p2Β ∆Αi2 M

I-ägΑΜ2 p2Β ∆Αi2 M . I-ägΑΜ1 p1Β ∆Αi1 M
+

Clear intermediate variables.

AF
In[159]:= Clear[aa];

RightPartialD[Μ]

LeftPartialD[Μ]

LeftRightPartialD[Μ]
denotes partial space-time differentiation ¶/ ¶x Μ , acting to the
right.
denotes partial space-time differentiation ¶/ ¶x Μ , acting to the
left.
denotes partial space-time differentiation ¶/ ¶x Μ , acting to the
left and right.
ExplicitPartialD[LeftRightPartialD[Μ]] gives 1/
2 (RightPartialD[Μ] - LeftPartialD[Μ])
LeftRightPartialD2[Μ] denotes partial space-time differentiation ¶/ ¶x Μ , acting to the
left and right.
DR
ExplicitPartialD[LeftRightPartialD[Μ]] gives
(RightPartialD[Μ] + LeftPartialD[Μ])
ExplicitPartialD[exp] inserts in exp the definitions for LeftRightPartialD and
LeftRightPartialD2.
ExpandPartialD[exp] expands DOT products of RightPartialD’s and/or
LeftPartialD’s with QuantumField’s in exp using the
Leibniz rule.

Partial space-time derivatives.

4. Elementary Calculations 52

As another example consider the strong QCD 4-gluon vertex. The relevant part of the QCD lagrangian is already
known by FeynCalc.

T
The gluon self-interaction part of In[160]:= Lagrangian["QCD"]
the QCD lagrangian .
1 a a
Out[160]= - FΑΒ . FΑΒ
4
We can write out the field strength In[161]:= Lagrangian["QCD"] /.
tensors. FieldStrength[x__] ¦
FieldStrength[x, Explicit ® True] //
DotExpand

I - Ab11

Calculate the 4-gluon Feynman

rule.
AF
Out[161]= 1
4

{i1}][p1],
a
c15 b12 c16
Α .AΒ .AΑ .AΒ

Α .AΒ
a

In[162]:= FeynRule[Lagrangian["QCD"], {
QuantumField[GaugeField, { 1},

QuantumField[GaugeField, { 2},
{i2}][p2],
QuantumField[GaugeField, { 3},
{i3}][p3],
QuantumField[GaugeField, { 4},
{i4}][p4]}]
a

c16
fab11c15 fab12c16 g2s -
AΑ .AΒ .¶Α AΒ fab11c15 gs + Ab11
b11 c15

c15
Α .AΒ .¶Β AΑ
fab11c15 gs - ¶Α AΒ .AΑ .AΒ fab12c16 gs +
a b12 c16

¶Α AΒ .¶Β AΑ + ¶Β AaΑ .¶Α AaΒ - ¶Β AaΑ .¶Β AaΑ M

¶Β AaΑ .Ab12 fab12c16 gs - ¶Α AaΒ .¶Α AaΒ +
a

Out[162]= ä IgΜ1Μ3 gΜ2Μ4 - gΜ1Μ2 gΜ3Μ4 M fi1i4si3 fi2i3si3 g2s +

ä IgΜ1Μ4 gΜ2Μ3 - gΜ1Μ2 gΜ3Μ4 M fi1i3si3 fi2i4si3 g2s +
ä IgΜ1Μ4 gΜ2Μ3 - gΜ1Μ3 gΜ2Μ4 M fi1i2si3 fi3i4si3 g2s

The function Lagrangian reads a database of lagrangians and returns the one corresponding to the name (a
string) given as argument. Currently the following names are known by Lagrangian:
DR
Lagrangian["oqu"] gives the unpolarized OPE quark operator.

Lagrangian["oqp"] gives the polarized quark OPE operator.

Lagrangian["ogu"] gives the unpolarized gluon OPE operator.

Lagrangian["ogp"] gives the polarized gluon OPE operator.

Lagrangian["ogd"] gives the sigma-term part of the QCD lagrangian.

Lagrangian["QCD"] gives the gluon self interaction part of the QCD lagrangian.
4. Elementary Calculations 53

More can be added easily (as done e.g. by the optional subpackage PHI).

T
Lagrangian["name"] returns a lagrangian name in FeynCalc notation.

A database of lagrangians.

AF
DR
5. One-Loop Calculations 54

5 One-Loop Calculations

T
In this section is described the capabilities of FeynCalc to reduce one-loop Feynman diagrams. If is also dis-
cussed how to provide input for FeynCalc and how to further process the output of FeynCalc.
The methods and conventions implemented in FeynCalc for the evaluation of one-loop diagrams are described
in [9] and [10]. The usual Passarino-Veltman scheme for the one-loop integrals is adapted to a large extent [9].
The coefficient functions of the tensor integrals are defined similar to [9], except that the Passarino-Veltman
integrals take internal masses squared as arguments.
FeynCalc can reduce all n-point integrals with n £ 4 to scalar integrals A 0 , B0 , C0 and D0 .
For the numerical evaluation of scalar integrals, several possibilities exist: 1) The program FormF by M. Veltman.
Unfortunately this only runs in CDC and 68000 assembler and is thus not a realistic alternative. 2) The library FF

not very well tested.

5.1
AF
by G.J. van Oldenborgh [12] written in Fortran 77. The library can be put to use with the LoopTools package [13]
written by Thomas Hahn, which features a Fortran, C++, and Mathematica interface. Loading the mathematica
package will simply cause the functions A 0 , B0 , C0 and D0 (and E0 and F0 ) to return numerical values when given
numerical arguments. This is the recommended procedure for obtaining numerical output from FeynCalc results.
A more simple wrapper Fortran program to link FF and FeynCalc is available from Rolf Mertig. 3) The optional
subpackage PHI provides some functions for evaluating B 0 and C0 . These are written purely in Mathematica but

Passarino-Veltman Integrals and Reduction of Coefficient Functions

The scalar integrals A0 , B0 , C0 and D0 are represented in FeynCalc as functions with all arguments consisting
of scalar products or masses squared. Thus A 0 has one, B0 three, C0 six, and D0 ten arguments. The symmetry
properties of the arguments are implemented, i.e., a standard representative of all possible argument permutations
of each B0 , C0 and D0 is returned. For example, B0[pp, m2ˆ2, m1ˆ2] ® B0[pp, m1ˆ2, m2ˆ2], where pp
denotes the scalar product (p × p) = p2 .
DR
5. One-Loop Calculations 55

T
(iΠ2 )-1 Ù d D q(q2 - m0 )-1
2
A0[m02]
(iΠ2 )-1 Ù d D q([(q2 - m0 ][(q + p1 )2 - m1 ])-1
2 2
B0[p10,m02,m12]
2 2 2 2
DB0[p10,m02,m12] ¶B0 (p1 , m0 , m1 )/ ¶p1
(iΠ2 )-1 Ù d D q([q2 - m0 ][(q + p1 )2 - m1 ][(q + p2 )2 - m2 ])-1
2 2 2
C0[p10,p12,p20,m02,m12,
m22]
D0[p10,p12,p23,p30,p20,p13, (iΠ2 )-1 Ù d D q([q2 - m0 ][(q + p1 )2 - m1 ][(q + p2 )2 - m2 ][(q +
2 2 2

AF
m02,m12,m22,m32] p )2 - m23 ])-1
3

Scalar Passarino-Veltman functions A0 , B0 ,B¢0 , C0 and D0 .

In FeynCalc and in the mathematical definitions given above, the factor (2ΠΜ) (4-D) with the scaling variable Μ is
2 2
suppressed. The convention for the scalar arguments is pi0 = p i pi j = (pi - p j )2 , mi2 = mi .

The B0 function is symmetric in

the mass arguments.

Taking the derivative with respect

In[163]:= B0[s, mz2, mw2]

Out[163]= B0 (s, mw2, mz2)

In[164]:= D[%, s]
to the first argument yields DB0.
Out[164]= DB0(s, mw2, mz2)

The tensor-integral decomposition is automatically done by FeynCalc when calculating one-loop amplitudes, but
extra functions are provided to reduce the coefficients of the tensor-integral decomposition.
DR
For fixing the conventions of the coefficient functions the definitions of the tensor-integrals and the decomposi-
tion are given below. In general the one-loop tensor integral is

à
(2ΠΜ)4-D q Μ1 × × × q ΜP
TΜN1 ...ΜP (p1 , . . . , pN-1 , m0 , . . . , mN-1 ) = d D
q
iΠ2 D0 D1 × × × DN-1
with the denominator factors
D0 = q2 - m20 Di = (q + pi )2 - m2i , i = 1, . . . , N - 1
originating from the propagators in the Feynman diagram. The i¶ part of the denominator factors is suppressed.
The tensor integral decompositions for the integrals that FeynCalc can do are listed below. The coefficient
functions Bi , Bi j , Ci , Ci j , Ci jk , Di , Di j , Di jk and Di jkl are totally symmetric in their indices.
5. One-Loop Calculations 56

T
BΜ = p1Μ B1

BΜΝ = gΜΝ B00 + p1Μ p1Ν B11

= p1ΜC1 + p2ΜC2 = â piΜCi

2
CΜ
i=1

CΜΝ = gΜΝC00 + p1Μ p1ΝC11 + p2Μ p2ΝC22 + (p1Μ p2Ν + p2Μ p1Ν )C12

= gΜΝC00 + â piΜ p jΝCi j

2

CΜΝΡ

AF i, j=1

= (gΜΝ p1Ρ + gΝΡ p1Μ + gΜΡ p1Ν )C001 + (gΜΝ p2Ρ + gΝΡ p2Μ + gΜΡ p2Ν )C002

+ p1Μ p1Ν p1ΡC111 + p2Μ p2Ν p2ΡC222

+ (p1Μ p1Ν p2Ρ + p1Μ p2Ν p1Ρ + p2Μ p1Ν p1Ρ )C112

+ (p2Μ p2Ν p1Ρ + p2Μ p1Ν p2Ρ + p1Μ p2Ν p2Ρ )C122

= â(gΜΝ piΡ + gΝΡ piΜ + gΜΡ piΝ )C00i + â piΜ p jΝ pkΡCi jk

2

i=1
2

i, j,k=1

= â piΜ Di
3
DΜ
i=1

= gΜΝ D00 + â piΜ p jΝ Di j

3
DΜΝ
i, j=1

= â(gΜΝ piΡ + gΝΡ piΜ + gΜΡ piΝ )D00i + â piΜ p jΝ pkΡ Di jk

3 3
DR
DΜΝΡ
i=1 i, j,k=1

DΜΝΡΣ = (gΜΝ gΡΣ + gΜΡ gΝΣ + gΜΣ gΝΡ )D0000

+ â (gΜΝ piΡ p jΣ + gΝΡ piΜ p jΣ + gΜΡ piΝ p jΣ + gΜΣ piΝ p jΡ + gΝΣ piΜ p jΡ + gΡΣ piΜ p jΝ )D00i j
3

i, j=1

+ â piΜ p jΝ pkΡ plΣ Di jkl

3

i, j,k,l=1

All coefficient functions and the scalar integrals are summarized in one generic function, PaVe.
5. One-Loop Calculations 57

T
PaVe[i, j, ..., {P10, Passarino-Veltman coefficient functions
P12, ...}, {m02, m12,
...}]

Passarino-Veltman coefficient functions of the tensor integral decomposition.

The first set of arguments i, j, ... are exactly those indices of the coefficient functions of the tensor integral

For the following examples some

options are set.

This is the scalar Passarino-

2
AF
decomposition. If only a 0 is given as first argument, the scalar integrals are understood. The last argument,
the list of inner masses m20 , m21 , ..., determines whether a one-, two-, three- or four-point function is meant.
PaVe is totally symmetric in the i, j, ... arguments. The foremost argument is the list of scalar products of
the pi . They are the same as defined above for the scalar B 0 , C0 and D0 functions. For A0 an empty list has to be
given.
A certain set of special PaVe shown in the following examples simplify to the usual notation.
To shorten the input squared masses are abbreviated with a suffix 2, i.e., a mass m 2 is denoted by m2. The scalar
quantity p2 is entered as pp, pi as pi0 and (pi - p j )2 as pij.

In[165]:= SetOptions[A0, A0ToB0 ® False];

SetOptions[{B1, B00, B11}, BReduce ®
False];
In[166]:= PaVe[0, {}, {m02}]
Veltman one-point function.
Out[166]= A0 (m02)

This is the two-point function In[167]:= PaVe[0, {pp}, {m02, m12}]

B0 (p2 , m20 , m21 ).
Out[167]= B0 (pp, m02, m12)
DR
Here is the coefficient function In[168]:= PaVe[1, {pp}, {m12, m22}]
B1 (p2 , m20 , m21 ).
Out[168]= B1 (pp, m12, m22)

Coefficient functions of metric In[169]:= PaVe[0,0, {pp}, {m02, m12}]

tensors have two "0" indices for
each gΜΝ . Out[169]= B00 (pp, m02, m12)

This is B11 (p21 , m0 , m1 ), the In[170]:= PaVe[1,1, {p10}, {m12, m22}]

coefficient function of p1Μ p1Ν of
BΜΝ . Out[170]= B11 (p10, m12, m22)
5. One-Loop Calculations 58

PaVe with one 0 as first In[171]:= PaVe[0, {p10, p12, p20}, {m12, m22,
argument are scalar m32}]

T
Passarino-Veltman integrals.
Out[171]= C0 (p10, p12, p20, m12, m22, m32)

This is D0 with 10 arguments. In[172]:= PaVe[0, {p10, p12, p23, p30, p20, p13},
{m12, m22, m32, m42}]

Out[172]= D0 (p10, p12, p23, p30, p20, p13, m12, m22, m32, m42)

AF
B1[p10, m02, m12]
B00[p10, m02, m12]
B11[p10, m02, m12]

Two-point coefficient functions.

2 2
coefficient function B1 (p1 , m0 , m1 )
2
coefficient function B00 (p1 , m0 , m1 )
2
coefficient function B11 (p1 , m0 , m1 )
2

2
2

The two-point coefficient functions can be reduced to lower-order ones. For special arguments also B 0 is ex-
pressed in terms of A0 , if the option BReduce is specified. Setting the option B0Unique to True simplifies
B0 (m2 , 0, m2 ) ® 2 + B0 (0, m2 , m2 ) and B0 (0, 0, m2 ) ® 1 + B0 (0, m2 , m2 ).

option name default value

DR
A0ToB0 False express A0 (m2 ) by m2 (1 + B0 (0, m2 , m2 ))
BReduce True, False for B0 reduce B0, B1, B00, B11 to A0 and B0
B0Unique False simplify B0 (a, 0, a) and B0 (0, 0, a)

Reduction options for A0 and the two-point functions.

5. One-Loop Calculations 59

The default is to reduce B1 to B0 . In[173]:= B1[pp, m12, m22]

T
B0 (pp, m12, m22)
Out[173]= - +
2

(-m12 + m22) (-B0 (0, m12, m22) + B0 (pp, m12, m22))

2 pp

Arguments of two-point functions with head Small are replaced by 0, if the other arguments have no head

The small mass m is set to 0, since

the other arguments are non-zero
and not SmallVariable.

But in this case no arguments are

replaced by 0.
SmallVariable heads are
AF
Small and are nonzero. A0[0] and A0[SmallVariable[m]ˆ2] simplify to 0.

In[174]:= B1[pp, SmallVariable(me2), m22]

Out[174]= -
B0 (pp, 0, m22)
2
+

m22 (-B0 (0, 0, m22) + B0 (pp, 0, m22))

2 pp

In[175]:= B1[SmallVariable[me2],
SmallVariable(me2), 0]

not displayed int 1 B0(me2, 0, me2)

TraditionalForm Out[175]= - -
2 2

In StandardForm we see In[176]:= % // StandardForm

them.
1 B0[SmallVariable[me2], 0, SmallVariable[me2]]
DR
Out[176]= - -
2 2

Any mass with head SmallVariable is neglected if it appears in a sum, but not as an argument of Passarino-
Veltman (PaVe) functions or PropagatorDenominator.
5. One-Loop Calculations 60

T
SmallVariable[var] is a small (negligible) variable

Head for small variables.

AF
PaVeReduce[expr]
KK[i]
reduces coefficient functions PaVe to A0, B0, C0, D0
abbreviations in HoldForm in the result of PaVeReduce

Reduction function for Passarino-Veltman coefficient functions.

Depending on the option BReduce B1, B00 and B11 may also remain in the result of PaVeReduce.

option name default value

IsolateNames False use Isolate with this option

Mandelstam {} Mandelstam relation, e.g., {s, t, u, 2 mwˆ2}

Options for PaVeReduce.

DR
The function Isolate is explained in section 7.3.

Reduce C2 (m2e , m2W , t, m2e , 0, m2W ) In[177]:= PaVeReduce[ PaVe[2, {SmallVariable[me2],

to scalar integrals. mw2, t},{SmallVariable[me2], 0, mw2} ]]

B0 (mw2, 0, mw2) B0 (t, 0, mw2)

Out[177]= -
mw2 - t mw2 - t
5. One-Loop Calculations 61

Break down the coefficient In[178]:= c12 = PaVeReduce[ PaVe[1, 2, {s, m2,
function m2}, {m2, m2, M2}],

T
C12 (s, m2 , m2 , m2 , m2 , M 2 ). IsolateNames ® c ]
This is the result in HoldForm.
Out[178]= c(11)

The FullForm of the In[179]:= c[11]

assignment to c12 is
HoldForm[c[11]]. If you 2 m2 c(3) c(1) c(7) c(2) c(8) c(4) c(9)
want to get the value of c[11], Out[179]= + + + +
s c(6) s c(6)2 2 c(6)2 s c(6)
you can either type
ReleaseHold[c12] or M2 c(5) c(10) 1
c[11] as done in the example.

Have B1 ’s be reduced to B0 ’s.

Repeated application of
ReleaseHold reinserts all K.
AF Out[181]=
c(6) 2

c12], _B0, _C0]

1
2 (4 m2 - s)
+
+
2 c(6)

In[180]:= SetOptions[B1, BReduce ® True];

In[181]:= Simplify /@ Collect[FixedPoint[ReleaseHold,

(m2 - M2) B0 (0, m2, M2)

2 m2 (4 m2 - s)
-

(8 m22 - 10 m2 M2 - 2 m2 s + M2 s) B0 (m2, m2, M2)

2 m2 (4 m2 - s)2

(4 m2 - 6 M2 - s) B0 (s, m2, m2)

+
2 (4 m2 - s)2

M2 (8 m2 - 3 M2 - 2 s) C0 (m2, m2, s, m2, M2, m2)

+
(4 m2 - s)2
DR
Take a coefficient function from In[182]:= d122 = PaVeReduce[
DΜ Ν Ρ : PaVe[1, 2, 2, {SmallVariable[me2], mw2,
D122 (m2e , m2w , m2w , m2e , s, t, 0, m2e , 0, m2e ). mw2, SmallVariable[me2], s, t},
{0, SmallVariable[me2], 0,
SmallVariable[me2]}],
Mandelstam ® {s, t, u, 2 mw2},
IsolateNames ® f ]

Out[182]= f[16]
5. One-Loop Calculations 62

Write the result out into a Fortran In[183]:= Write2[ "d122.for", d122res = d122,
file. FormatType ® FortranForm ];

T
This shows the resulting Fortran In[184]:= !!d122.for
file.
The first abbreviations are always f(1)= B0(mw2,me2,0D0)
f(2)= B0(s,0D0,0D0)
the scalar integrals.
f(3)= B0(t,me2,me2)
The partially recursive definitions f(4)= C0(mw2,mw2,t,me2,0D0,me2)
of the abbreviations are not fully f(5)= C0(mw2,s,me2,me2,0D0,0D0)
optimized. f(6)= C0(t,me2,me2,me2,me2,0D0)
The function Write2 is f(7)= D0(mw2,mw2,me2,me2,t,s,me2,0D0,me2,0D0)
explained in Section 7. f(8)= mw2 + s
Note that the head f(9)= 4*mw2 - t
SmallVariable is
eliminated in the Fortran output
automatically.

AF f(10)= mw2**2 - s*u

f(11)= mw2 - s
f(12)= 4*mw2**5-5*mw2**4*s-16*mw2**3*s**2+
& 4*mw2**2*s**3 + 4*mw2*s**4 - mw2**4*u -
& 4*mw2**2*s**2*u+8*mw2*s**3*u+4*mw2**2*s*u**2+
& s**3*u**2 + s**2*u**3
f(13)= mw2**2 - 4*mw2*s + 2*s**2 + s*u
f(14)= 4*mw2**3-9*mw2**2*s+2*s**3-mw2**2*u-
& 4*mw2*s*u + 5*s**2*u + 3*s*u**2
f(15)= 2*mw2**6-8*mw2**5*s+12*mw2**4*s**2-
& 8*mw2**3*s**3+2*mw2**2*s**4-2*mw2**5*t+
& 20*mw2**4*s*t-36*mw2**3*s**2*t+20*mw2**2*s**3*t-
& 2*mw2*s**4*t-6*mw2**3*s*t**2+6*mw2**2*s**2*t**2-
& 6*mw2*s**3*t**2+4*mw2*s**2*t**3-s**2*t**4
f(16)= -f(8)/(2D0*f(9)*f(10)) -
& (s**2*t**2*f(6)*f(11))/(2D0*f(10)**3) +
& (s**3*t**2*f(7)*f(11))/(2D0*f(10)**3) +
& (s**2*t*f(5)*f(11)**2)/f(10)**3 -
& (f(1)*f(12))/(2D0*f(9)**2*f(10)**2*f(11)) +
& (s*f(2)*f(13))/(2D0*f(10)**2*f(11)) +
& (f(3)*f(8)*f(14))/(2D0*f(9)**2*f(10)**2) -
& (f(4)*f(8)*f(15))/(2D0*f(9)**2*f(10)**3)
d122res = f(16)
Delete the output file. In[185]:= DeleteFile["d122.for"];
DR
The Fortran code generated by Write2 should be checked with care. All integer numbers (except 0 as argument
of B0, C0, D0) are translated to integers. This causes problems when translating variables with rational powers
and must be corrected in the Fortran output by hand.

5.2 A One-Loop Self Energy Diagram

The function OneLoop performs the algebraic simplifications of a given amplitude. The result is given in a
polynomial of standard matrix elements, invariants of the process under consideration, and Passarino-Veltman
integrals.
5. One-Loop Calculations 63

T
OneLoop[q, amp] calculates the one-loop amplitude amp with q as loop
momentum
OneLoop[name, q, amp] calculates the one-loop amplitude amp and gives it a name

Calculating one-loop amplitudes.

PropagatorDenominator[
Momentum[q], m]
PropagatorDenominator[
Momentum[q, D], m]
FeynAmpDenominator[
PropagatorDenominator[ ...
], PropagatorDenominator[
... ]]
AF a factor of the denominator of a propagator

a factor of the denominator of a propagator in D dimensions

a propagator

Representation of integrands.

The first argument to OneLoop is optional. It indicates a name for the amplitude for bookkeeping reasons. The
second argument q is the loop momentum, i.e., the integration variable.
DR
As last argument the analytical expression for the graph is given. It may be given in four dimensions. OneLoop
performs the necessary extension to D dimensions automatically.

This is In[186]:= -I/Piˆ2 FeynAmpDenominator[

-i Π-2 (2 ΠΜ)4-D Ù d D q (q2 -m2 )-1 ,

A0 = PropagatorDenominator[q, m]]

corresponding to a tadpole ä
diagram. Out[186]= -
Π2 (q2 - m2 )
The scaling variable Μ is
suppressed in FeynCalc.
5. One-Loop Calculations 64

This calculates the tadpole In[187]:= a0 = OneLoop[q, a0]

diagram.

T
Out[187]= A0 (m2 )

Have A0 written in terms of B0. In[188]:= SetOptions[A0, A0ToB0 ® True];

This calculates the tadpole In[189]:= OneLoop[q, a0]

diagram again. Now the result is
given in terms of B0. Out[189]= m2 B0 (0, m2 , m2 ) + m2

Return to the default. In[190]:= SetOptions[A0, A0ToB0 ® False];

For a most compact result the

factoring option of OneLoop is
set. For a description of all
options of OneLoop see section
5.4.
This is the transversal part of a
photon self energy diagram with
a fermion loop.
AF
Ù d 4 q [q2 - m2f ]-1 [(q - k)2 - m2f ]-1
ie2 / ((2Π)4 (1 - D))

tr[ (m f + /q - /k) ΓΝ (q
=
/ + m f ) ΓΝ ]

-[e2 (k2 + 6m2f B0 (0, m2f , m2f )-

-3(k2 +
2m2f )B0 (k2 , m2f , m2f ))]/ (36Π2 )
In[191]:= SetOptions[OneLoop, Factoring ® True];

In[192]:= OneLoop[ q, (I elˆ2)/(16 Piˆ4)/(1 - D) *

FeynAmpDenominator[
PropagatorDenominator[q, mf],
PropagatorDenominator[q - k, mf] ] *
DiracTrace[(mf + DiracSlash[q - k]) .
DiracMatrix[mu] .
(mf + DiracSlash[q]) . DiracMatrix[mu]]
] /. ScalarProduct[k, k] ® k2 /.
(mfˆ2) ® mf2

el2 (-k2 + 6 mf2 - 6 A0 (mf2) + 3 (k2 + 2 mf2) B0 (k2, mf2, mf2))

Out[192]=
36 Π2

Note that in this example, where the dimension is entered explicitly as a parameter (D), the option Dimension
of OneLoop must also be set to D (this is the default).
DR
¢
5.3 Generic Diagrams for W ® fi¯
f j with OneLoop

As an example for calculating triangle diagrams the result for two generic one-loop diagrams of the decay W
® fi f¯¢j for massless fermions given in [9] is verified with FeynCalc.
For the two diagrams different approaches are taken. In the first one FeynCalc introduces standard matrix el-
ements, i.e., that part of the diagram containing polarization dependencies. In the other approach the set of
standard matrix elements is defined by the user before FeynCalc calculates the diagrams. The last possibility is
usually preferable, since the choices of FeynCalc for the standard matrix elements may have physical significance
only by accident.
5. One-Loop Calculations 65

T
Figure 2: Two generic diagrams for the decay of W ® f i f¯j¢ , generated by FeynArts.

This defines a function for In[193]:= gc[i_] := g[i, "-"] DiracMatrix[7] +

abbreviation purposes: g[i, "+"] DiracMatrix[6];
gci = g-i Ω- + g+i Ω+ . ScalarProduct[p1, p1] = 0;
Set the pi on-shell and
(p1 × p2 ) = k2 / 2, where k denotes
the momentum of the W .

The analytical expression for the

generic diagram is:

∆m1 = i(2Π)-4 Ù (2ΠΜ)4-D d D q

[(q2 - m2 ) (q + p1 )2 (q - p2 )2 ]-1
u(p1 ) ΓΝ (g-1 Ω- + g+1 Ω+ ) (q
/¶(g-3 Ω- + g+3 Ω+ ) (q/ -
/ + /p)

p/2 ) ΓΝ (g-2 Ω- + g+2 Ω+ ) v(p2 )

Translated into the usual notation

the result reads:
AF ScalarProduct[p2, p2] = 0;
ScalarProduct[p1, p2] = k2/2;
MakeBoxes[g[i_, j_], TraditionalForm] :=
SubsuperscriptBox[g, i, j];
In[194]:= wff1 = OneLoop[ q, I/(2 Pi)ˆ4
FeynAmpDenominator[
PropagatorDenominator[q, m],
PropagatorDenominator[q + p1],
PropagatorDenominator[q - p2]] *
Spinor[p1] . DiracMatrix[nu] . gc[1] .
DiracSlash[q + p1] .
DiracSlash[Polarization[k]] .
gc[3] . DiracSlash[q - p2] .
DiracMatrix[nu] . gc[2] .
Spinor[p2] ] /. (mˆ2) ® m2

I(4 B0 (0, 0, m2) - 2 B0 (k2, 0, 0) -

(1 - 2B0 (k2 , 0, 0) + 1
2k2C0 (0, 0, k2 , 0, m2 , 0) + Out[194]= -
16 Π2
2k2 C1 (k2 , 0, 0, 0, 0, m2 ) +
2 k2 C0 (0, 0, k2, 0, m2, 0) - 2 m2 C0 (0, 0, k2, 0, m2, 0) -
4C00 (k2 , 0, 0, 0, 0, m2 )
( g+1 g+2 g+3 u(p1 ) /¶ Ω+ v(p2 ) + 4 PaVe(0, 0, {0, k2, 0}, {m2, 0, 0}) - 1)
g-1 g-2 g-3 u(p1 ) /¶ Ω- v(p2 )))/ (16Π2 )
Ig+1 g+2 g+3 üj(p1) . (Γ × ¶(k)) . Γ6 . j(p2)ü +
DR
g-1 g-2 g-3 üj(p1) . (Γ × ¶(k)) . Γ7 . j(p2)üMM
The remaining Dirac structure
is wrapped with the head

which displays like ü × × × ü.

StandardMatrixElement,
5. One-Loop Calculations 66

This reduces the result to scalar In[195]:= wff1a = PaVeReduce[wff1] // Simplify

integrals.

T
1
Out[195]=

II - 2 (2 k2 + m2) B0 (0, 0, m2) + (3 k2 + 2 m2) B0 (k2, 0, 0) +

16 k2 Π2

2 IC0 (k2, 0, 0, 0, 0, m2) (k2 + m2)2 + k2MM

Ig(1, +) g(2, +) g(3, +) üj(p1) . (Γ × ¶(k)) . Γ6 . j(p2)ü +

g(1, -) g(2, -) g(3, -) üj(p1) . (Γ × ¶(k)) . Γ7 . j(p2)üMM

With this command you can In[196]:= var = Select[Variables[wff1a],
extract the standard matrix
elements.

Here the
StandardMatrixElements
are set to some abbreviations.
In this way you can generate a
Fortran file.
With replacements you can adapt
the result to your other Fortran
code.
Show the content of the file.
AF (Head[#]===StandardMatrixElement)&]

Out[196]= {üj(p1) . (Γ × ¶(k)) . Γ6 . j(p2)ü,

üj(p1) . (Γ × ¶(k)) . Γ7 . j(p2)ü}

In[197]:= Set @@ {var, {ma[1], ma[2]} }

In[198]:= Write2["wff1a.for", vert = wff1a /.

g[i_, "+"] ® gp[i] /.
g[i_, "-"] ® gm[i], FormatType ®
FortranForm];

In[199]:= !!wff1a.for

vert = (((3*k2 + 2*m2)*B0(k2,Null,Null) -

& 2*(2*k2 + m2)*B0(Null,m2,Null) +
& 2*(k2 + (k2 + m2)**2*
& C0(k2,Null,Null,Null,Null,m2)))*
& (gp(1)*gp(2)*gp(3)*ma(1)+gm(1)*gm(2)*gm(3)*ma(2)))
& /(16D1*k2*Pi**2)
Clean up. In[200]:= DeleteFile["wff1a.for"];
Clear[gc, g, wff1, wff1a, ma];
DR
5. One-Loop Calculations 67

T
StandardMatrixElement[ head of a standard matrix element
expr]
SetStandardMatrixElements[{ set abbreviations for standard matrix elements
{sm1 ® abb1}, {sm2 ®
abb2}, ...}]
SetStandardMatrixElements[{ set abbreviations for standard matrix elements by using
{sm1 ® abb1}, {sm2 ® energy momentum conservation

AF
abb2}, ...}, k2 ® p1 + p2 - k1 ]

A head for identifying standard matrix elements; sm1, sm2 are the standard matrixelements, abb1, abb2 the abbreviations.

The function SetStandardMatrixElements introduces StandardMatrixElement[abb1

] for sm1 . The abbreviations abb1 , abb2 , . . . may be numbers or strings.
For calculating the generic triangle diagram with a non-abelian gauge coupling the standard matrix elements are
set ahead using SetStandardMatrixElements.

In addition to the first example the

option ReduceToScalars
is set to True, which will
In[201]:= r = DiracMatrix[6]; l = DiracMatrix[7];
ScalarProduct[p1, p1] =
ScalarProduct[p2, p2] = 0;
produce directly a result in terms ScalarProduct[p1, p2] = k2/2 ;
of B0 and C0 . SetOptions[ OneLoop,
The other definitions are Factoring ® True, FormatType ®
convenient abbreviations: r for FortranForm,
the right-handed projection ReduceToScalars ® True, WriteOut ® True,
operator Γ6 , l for the left-handed FinalSubstitutions ® {g[i_, "+"] ®
projection operator Γ7 , short gp[i], g[i_, "-"] ® gm[i],
DR
mnemonic functions like mt, fv StandardMatrixElement ® ma} ];
and feynden stand for metric mt = MetricTensor; fv = FourVector;
tensors, four-vectors and feynden[x:{_, _}..] :=
denominators of propagators. FeynAmpDenominator @@
Map[Apply[PropagatorDenominator, #]&,
{x}];

This sets the standard matrix In[202]:= SetStandardMatrixElements[

elements: { ( Spinor[p1] . DiracSlash[Polarization[k]].
M+1 = u(p1 ) /¶1 Ω+ v(p2 ) r . Spinor[p2] ) ® {1},
M-1 = u(p1 ) /¶1 Ω- v(p2 ) ( Spinor[p1] . DiracSlash[Polarization[k]].
l . Spinor[p2] ) ® {2}}];
5. One-Loop Calculations 68

Here is the second generic In[203]:= OneLoop[q, I/(2 Pi)ˆ4 *

diagram. feynden[{q, 0}, {q + p1, m1}, {q - p2,

T
Note that in the result m2}] *
StandardMatrixElement Spinor[p1] . DiracMatrix[nu] .
is replaced by mat, as specified (g[1, "-"] l + g[1, "+"] r) .
in the option DiracSlash[-q] . DiracMatrix[ro] .
FinalSubstitutions of (g[2, "-"] l + g[2, "+"] r) .
OneLoop on the previous page. Spinor[p2] *
g3 ( mt[ro, mu] fv[p1 + 2 p2 - q, nu] -
mt[mu, nu] fv[2 p1 + p2 + q, ro] +
mt[nu, ro] fv[2 q + p1 - p2, mu] ) *
PolarizationVector[k, mu]
] /. (m1ˆ2) ® m12 /. (m2ˆ2) ® m22

As specified above in the options

for OneLoop, a Fortran output
is written into a file.
AF
Out[203]= -
1
(16 k2 Π2 )
(g3 ((2 k2 + m12) B0 (0, 0, m12) +

(2 k2 + m22) B0 (0, 0, m22) -

(k2 + m12 + m22) B0 (k2, m12, m22) + 2 (k2 m12 +

m22 m12 + k2 m22) C0 (k2, 0, 0, m12, m22, 0))

(gp(1) gp)(2) ma(1) + gm(1) gm(2) ma(2)))

In[204]:= !!"wff2.for"

Out[204]= wff2 = -(g3*(-((k2 + m1**2 +

m2**2)*B0(k2,m1**2,m2**2)) +
& (2*k2 + m1**2)*B0(Null,m1**2,Null) +
& (2*k2 + m2**2)*B0(Null,m2**2,Null) +
& 2*(k2*m1**2 + k2*m2**2 + m1**2*m2**2)*
& C0(k2,Null,Null,m1**2,m2**2,Null))*
& (gp(1)*gp(2)*ma(1) + gm(1)*gm(2)*ma(2)))/
& (16D1*k2*Pi**2)
Clean up. In[205]:= DeleteFile["wff2.for"];
DR
DeleteFile /@ FileNames["PaVe*"];
Clear[r, l, mt, fv, feynden, wff2];

5.4 The Options of OneLoop

Several options of OneLoop have already been introduced in the previous section. Here the full list of available
options is briefly discussed. The example in Section 5.6 shows the use of some options.
In the automatic calculation of one-loop amplitudes it does not matter in which order the arguments of
FeynAmpDenominator are given. Therefore the default setting of DenomatorOrder is True. In case you
want to verify a result obtained by hand calculation, you can set this option to False, which will preserve the
order of the propagators as entered. If you want to include the dimension D explicitly in the input, as in the
5. One-Loop Calculations 69

example in Section 5.2, you have to set Dimension ® D.

With the default setting of Dimension you can enter four-dimensional objects to OneLoop, which are automat-

T
ically extended to D dimensions inside OneLoop. In case you want to calculate a finite amplitude, you can set
Dimension ® 4.
The option FinalSubstitutions indicates substitutions that are done at the very end of the calculation, which
may be useful to adapt the output to your Fortran program.
The Factoring option should be used only for relatively small problems, since it may be very time consuming to
factor the result. Unless the result of OneLoop is very short, only the coefficients of StandardMatrixElement
are factored.
FormatType takes InputForm, FortranForm, MacsymaForm or MapleForm as settings. If the option
WriteOut is set to True, the result is written out into a file using Write2 with the setting of FormatType.

loop.

AF
Replacements are done with InitialSubstitutions and FinalSubstitutions. Especially energy mo-
mentum conservation should be included, e.g., InitialSubstitutions ® {k2 ® - k1 + p1 + p3}.
Note that the rules listed in FinalSubstitutions are not applied as one list of rules, but sequentially in a

If IsolateNames is set to c, for example, the result will be given as a c[i] in HoldForm. See Isolate for
more information. The setting of Mandelstam may be, e.g., Mandelstam ® {s, t, u, m1ˆ2 + m2ˆ2 +
2 2
m3ˆ2 + m4ˆ2}, where s + t + u = m1 + m2 + m3 + m4 .
2 2

The option ReduceToScalars should not be set to True when calculating several complicated diagrams in-
volving DΜΝΡ or DΜΝΡΣ . Depending on the computer you are using it may nevertheless work, but it is usually better
to use OneLoopSum with the appropriate options. Note that depending on the setting of the option BReduce also
two-point coefficient functions may remain in the result.
For processes with light external fermions it is best not to neglect the fermion masses everywhere, but to keep
them in the arguments of the scalar Passarino-Veltman functions. This set of masses should be supplied as a list
to the option SmallVariables, see section 5.6.
If WriteOut is set to True, the result is written out into a file composed of the first argument of OneLoop, i.e.,
the name. In which language, i.e., Mathematica, Fortran, Macsyma or Maple the result is written, depends on
the setting of the option FormatType. You may also set WriteOut to a string, which denotes the directory to
write the result files to (actually this string is simply prepended to the file names).
DR
5. One-Loop Calculations 70

T
option name default value

Apart2 True use Apart2 to partial fraction denominators

CancelQP True cancel q × p and q2
DenominatorOrder False order the arguments of FeynAmpDenominator
canonically
Dimension D number of space-time dimensions
Factoring False factor the result
FinalSubstitutions
FormatType
InitialSubstitutions

Mandelstam
OneLoopSimplify

Prefactor
ReduceGamma
ReduceToScalars
AF
IntermediateSubstitutions {}

IsolateNames
{}
InputForm
{}

False
{}
False

1
False
False
substitutions done at the end of the calculation
how to write out the result file
substitutions done at the beginning of the calcula-
tion, i.e., energy momentum conservation
substitutions done at an intermediate stage of the
calculation
use Isolate on the result
indicate the Mandelstam relation
use OneLoopSimplify at the beginning of the
calculation
extra prefactor of the amplitude
insert for Γ6 and Γ7 their definitions
reduce to B0 , C0 , D0
SmallVariables {} a list of masses, which will get wrapped with the
head SmallVariable
WriteOut False write out a result file carrying the name of the op-
tional first argument of OneLoop
WriteOutPaVe False store PaVes in files
compatibility with FeynArts; sum terms multiplied
DR
Sum True
with FeynArts’s SumOver

Options of OneLoop.

5.5 OneLoopSum and Its Options

To sum a list of amplitudes two different methods are provided by OneLoopSum. Either the provided list of
amplitudes is calculated and subsequently summed, or the summation occurs partially before calculation. This
can be specified with the option CombineGraphs.
5. One-Loop Calculations 71

T
OneLoopSum[List[FeynAmp[ calculate a list of amplitudes
GraphName[..., N1], q,
amp1],
FeynAmp[GraphName[...,
N2], q, amp2], ...]]
OneLoopSum[expr] sum already calculated amplitudes

AF
A function for summing one-loop amplitudes.

The input of OneLoopSum is adapted to the output of FeynArts 3 . After saving a list of Feynman di-
agrams (that is, unintegrated amplitudes) created with FeynArts using the function CreateFeynAmp, i.e.
CreateFeynAmp[ins] // PickLevel[Particles] // ToFA1Conventions » filename , you can start a
new Mathematica session 4 , load FeynCalc, get the amplitudes by amps = « filename , calculate the amplitude
with OneLoopSum and finally save the result e.g. as a Fortran file.
To actually use the Fortran file, obviously the constants and functions used, like masses and scalar integrals, have
to be defined. This is discussed in section 5.7.
Instead of supplying a list of not yet calculated amplitudes you can also give the sum of already calculated ones
as argument (expr) to OneLoopSum.
The output of OneLoopSum is typically given as a short expression wrapped in HoldForm. In order to get the
full expression, the function FRH can be applied.

FRH[exp] removes all HoldForm and Hold in exp

DR
A utility function.

3
Actually to version 1 of FeynArts, but the current version 3 provides translation to version 1 syntax (ToFA1Conventions).
The examples given here all use FeynArts version 3,
4
It is not possible to load FeynCalc and FeynArts simultaneously into one Mathematica session because some functions of FeynArts
and FeynCalc have the same name but are in different contexts (name spaces). A more sophisticated approach is provided by the optional
subpackage PHI, which patches FeynArts slightly, allowing the two packages to be loaded simultaneously.
5. One-Loop Calculations 72

T
option name default value

CombineGraphs {} combine amplitudes

Dimension True number of space-time dimensions
ExtraVariables {} list of variables which are bracketed out in the re-
sult like B0, C0, D0 and PaVe
FinalFunction Identity function applied to the result
FinalSubstitutions {} substitutions done at the end of the calculation
FormatType
InitialSubstitutions

Mandelstam
Prefactor
ReduceToScalars
SelectGraphs
WriteOutPaVe
AF
IntermediateSubstitutions {}

IsolateNames
InputForm
{}

KK
{}
1
True
All
False
format used when saving results
substitutions done at the beginning of the calcula-
tion
substitutions done at an intermediate stage in the
calculation
Isolate the result
use the Mandelstam relation
multiply the result by a pre-factor
reduce to scalar integrals
which graphs to select
write out the reduced PaVe

Options of OneLoopSum.

With the default options OneLoopSum calculates each amplitude separately by substituting OneLoop for
FeynAmp. Then each single PaVe is reduced to scalar integrals. The hard final part consists in the simplifi-
cation of the rational coefficients of the scalar integrals. This may involve thousands of factorizations and can
therefore take hours of CPU time. But the algebraic simplifications achieved by putting all coefficients of the
DR
scalar integrals over a common denominator and to factor them, possibly cancelling factors and reducing the
singularity structure, may be very significant. These calculations may need quite a lot of RAM space, therefore
the options of OneLoopSum allow you to split up the task of summing lots of diagrams.
First you can select a certain subclass of diagrams with the option SelectGraphs. You may set, e.g.,
SelectGraphs ® {1, 2, 5, 8}, which selects the amplitudes at positions 1, 2, 5 and 8 of the argument
list of OneLoopSum. The setting SelectGraphs ® {1, 2, 5, 8, {10, 40}} also includes the range of
all amplitudes from position 10 to 40.
With the option CombineGraphs a possibility is given to sum the graphs before calculation. This is especially
useful for combining a graph with its crossed counterpart. In general it makes sense to combine all graphs with
the same propagators before calculation, but for very big sums this may reduce the performance considerably.
The possible settings for CombineGraphs are the same as for SelectGraphs. If you use the FeynArts syntax
5. One-Loop Calculations 73

for the first argument of FeynAmp, i.e. GraphName[..., N1], the last arguments of GraphName for combined
graphs are concatenated and a new GraphName for the summed amplitude is created.

T
By setting the option WriteOutPaVe you can save the result of the reduction of each PaVe in a file for later use.
The names of the corresponding files are generated automatically. In case you use OneLoopSum several times
it recognizes previously saved reductions and loads these results automatically. This may save a considerable
amount of time. Instead of setting the option WriteOutPaVe to an empty string (which means that the files are
written in the current directory), you can specify another directory (a string prepended to the file names).
Note that these options together with the possibility of using OneLoopSum on already calculated graphs gives
you a lot freedom to split up the calculation, which may be necessary in order to avoid memory overflow. It can
also be a good idea to set $VeryVerbose to 1 or 2 for monitoring the calculation.
The option Prefactor may be used to extract global factors. You can, i.e., put SetOptions[OneLoop,

factor 1/ (2s2w ).

5.6
AF
Prefactor ® (2 SWˆ2), which multiplies each single amplitude by 2s 2w , and set simultaneously
SetOptions[OneLoopSum, Prefactor ® 1/(2 SWˆ2). The result of OneLoopSum has then as a global

Box Graphs of e+ e- ® ZH
In this section it is shown how to calculate a sum of amplitudes with OneLoopSum. The input consists of a
one page program with process-dependent definitions. This program reads in a file with unmodified output of
FeynArts for the amplitudes. The Fortran file produced is obtained without any interactive action.
The six standard matrix elements are:

M0 = v(p1 ) /¶ Ω+ u(p2 )
1

M0 = v(p1 ) /¶ Ω- u(p2 )
2

M1 = v(p1 ) k/1 Ω+ u(p2 ) Ε p1

1

M1 = v(p1 ) k/1 Ω- u(p2 ) Ε p1

2

M2 = v(p1 ) k/1 Ω+ u(p2 ) Ε p2

1

M2 = v(p1 ) k/1 Ω- u(p2 ) Ε p2

2
DR
5. One-Loop Calculations 74

T
e W Z e W Z e W Z
Νe G Νe W Νe G
e W H e W H e W H

e W e Z e Z
Z
Νe

AF Νe
e
W
W H e
e e

Z
Z
H
Νe
e W
W
H

Figure 3: Box diagrams of e+ e- ® ZH, generated by FeynArts. G denotes the unphysical charged Higgs.
DR
5. One-Loop Calculations 75

(*Generate the box topologies*)

tops = CreateTopologies[1, 2 -> 2, Adjacencies -> {3},

T
ExcludeTopologies -> {SelfEnergies, WFCorrections, Tadpoles,
Boxes[3]}];

(*Check that the right topologies were generated*)

Paint[tops, ColumnsXRows -> {3, 1}];

(*Insert fields*)
inserttops =
InsertFields[tops, {F[2, {1}], -F[2, {1}]} -> {V[2], S[1]}, Model -> "SM",
GenericModel -> "Lorentz", InsertionLevel -> Particles,

(*Display the graphs*)

(*Generate amplitude*) AF
ExcludeFieldPoints -> {FieldPoint[F, -F, S]}];

graphs = Paint[inserttops, PaintLevel -> {Particles}, AutoEdit -> False,

SheetHeader -> False, Numbering -> False, ColumnsXRows -> {3, 2}];

eezhb = CreateFeynAmp[inserttops, AmplitudeLevel -> Particles];

(*Save amplitude in a format understood by FeynCalc*)

PickLevel[Particles][eezhb] // ToFA1Conventions >> "eezhb.amp";

For completeness here is the input program for generating boxes of e+ e- ® ZH with FeynArts.
DR
5. One-Loop Calculations 76

(*Define the Mandelstam variables and put momenta on - shell*)

SetMandelstam[s, t, u, p1, p2, -k1, -k2, SmallVariable[ME],

T
SmallVariable[ME], MZ, MH];

(*Set the option for the ordering of D0’s*)

SetOptions[PaVeOrder, PaVeOrderList -> {{s, t}, {s, u}, {t, u}}];

(*Set the options for OneLoop*)

SetOptions[OneLoop, Mandelstam -> {s, t, u, MH^2 + MZ^2},
Prefactor -> 1/ALPHA2,
InitialSubstitutions -> {k2 -> p1 + p2 - k1, CW -> MW/MZ,
EL -> Sqrt[4 Pi Sqrt[ALPHA2]]}, SmallVariables -> {ME, ME2}];

AF
(*The option for OneLoopSum introduces abbreviations at the end*)
SetOptions[OneLoopSum, Prefactor -> 2 ALP4PI FLUFAC,
Mandelstam -> {s, t, u, MH^2 + MZ^2},
FinalSubstitutions -> {SW -> Sqrt[SW2], ME -> Sqrt[ME2], MW -> Sqrt[MW2],
MZ -> Sqrt[MZ2], MH -> Sqrt[MH2],
ME2^n_ :> ME^(2 n) /; Head[n] =!= Integer,
MZ2^n_ :> MZ^(2 n) /; Head[n] =!= Integer,
MW2^n_ :> MW^(2 n) /; Head[n] =!= Integer,
MH2^n_ :> MH^(2 n) /; Head[n] =!= Integer,
SW2^n_ :> SW^(2 n) /; Head[n] =!= Integer,
StandardMatrixElement -> MBM}, WriteOutPaVe -> ""];

(*Define the standard matrix elements*)

SetStandardMatrixElements[{Spinor[p1].DiracSlash[
Conjugate[Polarization[k1]]].ChiralityProjector[+1].Spinor[
p2] -> {0, 1},
Spinor[p1].DiracSlash[
Conjugate[Polarization[k1]]].ChiralityProjector[-1].Spinor[
p2] -> {0, 2},
ScalarProduct[Conjugate[Polarization[k1]], p1]*
Spinor[p1].DiracSlash[k1].ChiralityProjector[+1].Spinor[p2] -> {1,
1}, ScalarProduct[Conjugate[Polarization[k1]], p1]*
DR
Spinor[p1].DiracSlash[k1].ChiralityProjector[-1].Spinor[p2] -> {1,
2}, ScalarProduct[Conjugate[Polarization[k1]], p2]*
Spinor[p1].DiracSlash[k1].ChiralityProjector[+1].Spinor[p2] -> {2,
1}, ScalarProduct[Conjugate[Polarization[k1]], p2]*
Spinor[p1].DiracSlash[k1].ChiralityProjector[-1].Spinor[p2] -> {2,
2}}, {k2 -> (p1 + p2 - k1)}];

(*get the amplitudes, which have been written to a file by FeynArts*)

eezhamp = << eezhb.amp;

(*This calculates the amplitudes and sums them up*)

eezhboxes = OneLoopSum[eezhamp, CombineGraphs -> {1, 2, 3, 4, 5, 6}];

(*Here the result is written into a Mathematica file*)

Write2["eezhb.m", EEZHBOXES = FRH[eezhboxes]];

(*Here the result is written into a Mathematica program*)

Write2["eezhb.s", EEZHBOXES = eezhboxes];

(*Here the result is written into a Fortran file*)

Write2["eezhb.for", EEZHBOXES = eezhboxes, FormatType -> FortranForm];

Input program for calculating boxes of e+ e- ® ZH.

5. One-Loop Calculations 77

KK(1)= B0(MH2,MZ2,MZ2)
KK(2)= B0(MZ2,ME2,ME2)

T
KK(3)= B0(MH2,MW2,MW2)
KK(4)= B0(MZ2,0D0,0D0)
KK(5)= B0(MZ2,MW2,MW2)
KK(6)= D0(MH2,ME2,MZ2,ME2,t,u,MZ2,MZ2,ME2,ME2)
KK(7)= D0(MH2,MZ2,ME2,ME2,s,t,MW2,MW2,MW2,0D0)
KK(8)= D0(MH2,MZ2,ME2,ME2,s,u,MW2,MW2,MW2,0D0)
KK(9)= D0(MH2,ME2,MZ2,ME2,t,u,MW2,MW2,0D0,0D0)
KK(10)= C0(MH2,t,ME2,MZ2,MZ2,ME2)
KK(11)= C0(MH2,u,ME2,MZ2,MZ2,ME2)
KK(12)= C0(MZ2,t,ME2,ME2,ME2,MZ2)
KK(13)= C0(MZ2,u,ME2,ME2,ME2,MZ2)
KK(14)= C0(MH2,MZ2,s,MW2,MW2,MW2)
KK(15)= C0(MH2,t,ME2,MW2,MW2,0D0)

KK(25)= B0(u,MW2,0D0)
KK(26)= 2*MH2 - MZ2
KK(27)= MH2 - 5*MZ2
KK(28)= 1 - 2*SW2
KK(29)= MW2 + MZ2
KK(30)= 2*MH2 - MW2
KK(31)= MW2 + 2*MZ2
AF
KK(16)= C0(MH2,u,ME2,MW2,MW2,0D0)
KK(17)= C0(MZ2,t,ME2,0D0,0D0,MW2)
KK(18)= C0(MZ2,t,ME2,MW2,MW2,0D0)
KK(19)= C0(MZ2,u,ME2,0D0,0D0,MW2)
KK(20)= C0(MZ2,u,ME2,MW2,MW2,0D0)
KK(21)= C0(s,ME2,ME2,MW2,MW2,0D0)
KK(22)= B0(t,ME2,MZ2)
KK(23)= B0(u,ME2,MZ2)
KK(24)= B0(t,MW2,0D0)

KK(32)= 4*MW2**2 + 3*MW2*MZ2 - MZ2**2*SW2

KK(33)= 5*MH2*MW2 - 2*MW2**2 + 2*MW2*MZ2 - MH2*MZ2*SW2
KK(34)= MH2 - MW2 + 2*MZ2
KK(35)= 2*MW2**2 + MW2*MZ2 - MZ2**2*SW2
KK(36)= MW2 - MZ2*SW2
KK(37)= MW2 + MZ2*SW2
KK(38)= MH2 + MZ2
KK(39)= 3*MW2 + MZ2*SW2
KK(40)= MH2*MW2 + 4*MW2**2 + 2*MW2*MZ2 - 2*MZ2**2 + MH2*MZ2*SW2
KK(41)= 2*MH2*MW2 - 2*MW2**2 + 4*MW2*MZ2 + MZ2**2*SW2
DR
KK(42)= 4*MH2 - 2*MW2 + 3*MZ2
KK(43)= 2*MW2 - MZ2
KK(44)= MH2*MW2 - 2*MW2**2 - 3*MW2*MZ2 + 2*MZ2**2 - MH2*MZ2*SW2
KK(45)= MH2*MW2 + 4*MW2**2 + 4*MW2*MZ2 + MH2*MZ2*SW2
KK(46)= 5*MW2 + MZ2*SW2
KK(47)= 2*MH2 - MW2 + 2*MZ2
KK(48)= 3*MH2*MW2 + 2*MW2**2 + 6*MW2*MZ2 + MH2*MZ2*SW2
KK(49)= 9*MW2 + MZ2*SW2
KK(50)= 2*MW2 + MZ2
KK(51)= 3*MW2 + 2*MZ2
KK(52)= MW2**2 - MH2*MZ2 + 3*MW2*MZ2 + MZ2**2
KK(53)= 6*MH2*MW2 - 8*MW2**2 - MH2*MZ2*SW2 + MZ2**2*SW2
KK(54)= MH2 - 2*MW2 + MZ2
KK(55)= 4*MH2*MW2 - 4*MW2**2 - 2*MW2*MZ2 - MH2*MZ2*SW2 + MZ2**2*SW2
KK(56)= MH2 - MZ2
KK(57)= 2*MH2 + MZ2
KK(58)= 2*MH2**2 + 4*MH2*MZ2 + MZ2**2
KK(59)= MH2 - 2*MZ2
---> ... 418 lines omitted ...
KK(173)= ALP4PI*FLUFAC*KK(172)
EEZHBOXES = 2*KK(173)

Fortran output file "eezhb.for" generated by OneLoopSum for e+ e- ® ZH.

5. One-Loop Calculations 78

KK[1] = (B0[MH2, MZ2, MZ2]

);

T
KK[2] = (B0[MZ2, SmallVariable[ME2], SmallVariable[ME2]]
);
KK[3] = (B0[MH2, MW2, MW2]
);
KK[4] = (B0[MZ2, 0, 0]
);
KK[5] = (B0[MZ2, MW2, MW2]
);
KK[6] = ( D0[MH2, SmallVariable[ME2], MZ2, SmallVariable[ME2], t, u, MZ2, MZ2,
SmallVariable[ME2], SmallVariable[ME2]]
);
KK[7] = ( D0[MH2, MZ2, SmallVariable[ME2], SmallVariable[ME2], s, t, MW2, MW2, MW2, 0]
);

);

AF
KK[8] = ( D0[MH2, MZ2, SmallVariable[ME2], SmallVariable[ME2], s, u, MW2, MW2, MW2, 0]
);
KK[9] = ( D0[MH2, SmallVariable[ME2], MZ2, SmallVariable[ME2], t, u, MW2, MW2, 0, 0]

KK[10] = (C0[MH2, t, SmallVariable[ME2], MZ2, MZ2, SmallVariable[ME2]]

);
KK[11] = (C0[MH2, u, SmallVariable[ME2], MZ2, MZ2, SmallVariable[ME2]]
);
KK[12] = ( C0[MZ2, t, SmallVariable[ME2], SmallVariable[ME2], SmallVariable[ME2], MZ2]
);
KK[13] = ( C0[MZ2, u, SmallVariable[ME2], SmallVariable[ME2], SmallVariable[ME2], MZ2]
);
KK[14] = (C0[MH2, MZ2, s, MW2, MW2, MW2]
);
KK[15] = (C0[MH2, t, SmallVariable[ME2], MW2, MW2, 0]
);
KK[16] = (C0[MH2, u, SmallVariable[ME2], MW2, MW2, 0]
);
KK[17] = (C0[MZ2, t, SmallVariable[ME2], 0, 0, MW2]
);
KK[18] = (C0[MZ2, t, SmallVariable[ME2], MW2, MW2, 0]
);
KK[19] = (C0[MZ2, u, SmallVariable[ME2], 0, 0, MW2]
);
KK[20] = (C0[MZ2, u, SmallVariable[ME2], MW2, MW2, 0]
);
DR
KK[21] = (C0[s, SmallVariable[ME2], SmallVariable[ME2], MW2, MW2, 0]
);
KK[22] = (B0[t, MZ2, SmallVariable[ME2]]
);
KK[23] = (B0[u, MZ2, SmallVariable[ME2]]
);
KK[24] = (B0[t, 0, MW2]
);
KK[25] = (B0[u, 0, MW2]
);
KK[26] = (2*MH2 - MZ2
);
KK[27] = (MH2 - 5*MZ2
);
KK[28] = (1 - 2*SW2
);
KK[29] = (MW2 + MZ2
);
KK[30] = (2*MH2 - MW2
);
(* .............. 564 lines omitted ..................... *)
KK[173] = (ALP4PI*FLUFAC*HoldForm[KK[172]]
);
EEZHBOXES = 2*HoldForm[KK[173]]

Mathematica output file "eezhb.s" generated by OneLoopSum for e+ e- ® ZH.

5. One-Loop Calculations 79

5.7 Processing Amplitudes

T
Calculating loop integrals will in most cases lead to very large expressions. The same goes for the application
of other algorithms like Dirac tracing algorithms. The systematization and reduction of such expressions is
a process which requires much more human planing, control and intervention than the process leading to the
expressions. However, the computer is still of help. In this section we shall consider a few examples of how one
may proceed, taking advantage of both tools provided by FeynCalc as well as constructing small Mathematica
programs.

Load a store amplitude (see In[206]:= « "eezhb.m"

section 5.6).
Check the "size" of the expression. In[207]:= EEZHBOXES // LeafCount

Expand the expressions, collect

with respect to factors we know
will be overall or "interesting",
simplify what the non-overall
factors multiply.
Check the "size" of the resulting
expression.

Clean up.
AF Out[207]= 10415
In[208]:= eezhoxes = Collect[EEZHBOXES // Expand,
ALP4PI, FLUFAC, _MBM, _D0, _C0, _B0,
If[FreeQ[#, _MBM | _D0 | _C0 | _B0 |
_PaVe], FullSimplify[#], #] &];

In[209]:= eezhoxes // LeafCount

Out[209]= 8881
In[210]:= DeleteFile /@ FileNames["eezhb*"];
DeleteFile /@ FileNames["PaVe*"];

In the example above, notice that instead of simply applying Simplify to the whole expression, some group-
ing is first done and then Simplify is applied to individual terms. This is often advantageous because the
performance of Simplify naturally scales very badly with the size of expressions. We remark that although
OneLoopSum does a decent job in structuring the expression, it can still be reduced somewhat.
In the one-loop calculations considered thus far, amplitudes have been computed. The extra step of computing
the (differential) cross section can, however, also be done with FeynCalc. To demonstrate this we pick a very
simple example, namely the famous Møller cross section. This example also demonstrates that a full calculation
from Feynman rules to cross section can be carried out with FeynArts and FeynCalc 5 .
DR
5
In fact, as we have seen in section 4.5, the calculation of the Feynman rule from the lagrangian can also be automatized with
FeynCalc.
5. One-Loop Calculations 80

(*Construction of topologies*)
tops = CreateTopologies[0, 2 -> 2, Adjacencies -> {3},

T
ExcludeTopologies -> {SelfEnergies, WFCorrections}];

(*Check*)
Paint[tops, ColumnsXRows -> {3, 1}, AutoEdit -> False];

(*Field insertion*)
inserttops =
InsertFields[tops, {F[1, {1}], F[1, {1}]} -> {F[1, {1}], F[1, {1}]},
Model -> "QED", GenericModel -> "QED", InsertionLevel -> Particles];

(*Check*)
treegraphs =

(*Calculate the amplitudes*)

AF
Paint[inserttops, PaintLevel -> {Particles}, AutoEdit -> False,
SheetHeader -> False, Numbering -> False, ColumnsXRows -> {2, 1}];

amps = CreateFeynAmp[inserttops, AmplitudeLevel -> Particles];

(*Save result*)
PickLevel[Classes][amps] // ToFA1Conventions >> "moelleramps.m"

For completeness here is the input program for generating the (leading order) diagrams of Møller scattering with FeynArts.
DR
5. One-Loop Calculations 81

(*Define the Mandelstam variables and put momenta on - shell*)

SetMandelstam[s, t, u, p1, p2, -k1, -k2, ME, ME, ME, ME];

T
(*get the amplitudes, which have been written to a file by FeynArts*)
amps = << moelleramps.m;

(*Sum the graphs and contract Lorentz indices*)

amp = (OneLoopSum[amps, CombineGraphs -> {1, 2}] // FRH) /. D :> Sequence[] //
Contract

(*Square the amplitude,

transform the spin sums into traces and evaluate the traces*)
squaredamp =

kinfac = 1/(64 \[Pi]^2s);

AF
FermionSpinSum[amp ComplexConjugate[amp /. li2 -> li1] // Expand] /.
DiracTrace -> Tr // DiracSimplify //
TrickMandelstam[#, {s, t, u, 4ME^2}] & // Simplify
squaredamp1 =
squaredamp // Contract // PropagatorDenominatorExplicit // Simplify

(*The kinematical factor in the center of mass frame*)

(*The full differential cross section in the center of mass frame expressed \
in terms of Mandelstam variables*)
dcrosssection = 1/4*kinfac*squaredamp1 // Simplify
(*Shift to other variables : Scattering angle and half the CMS energy*)
dc = dcrosssection /. u -> 4ME^2 - s - t /. {s -> 4 \[Omega]^2,
t -> -2 q2(1 - Sqrt[1 - sin[\[Theta]]^2])} /.
q2 -> \[Omega]^2 - ME^2 // Simplify

(*Clean up*)
DeleteFile["moelleramps.m"];

Calculation of the Møller cross section.

DR
Notice that the argument given to FermionspinSum is a product of two amplitudes. These both contain con-
tracted indices; therefore, in one of them, these indices have to be renamed. The functions TrickMandelstam
and PropagatorDenominatorExplicit are described in section 7.
5. One-Loop Calculations 82

T
ComplexConjugate[exp] conjugates the expression exp, operating on fermion lines
FermionSpinSum[exp] constructs traces out of squared amplitudes

Calculation of squares of fermion amplitudes.

AF
DR
6. Advanced Calculations 83

6 Advanced Calculations

T
6.1 QCD with FeynCalc

6.2 ChPT with FeynCalc

6.3 Two-Loop Calculations

6.4 Amplitude and Integral Tables

7 Miscellaneous Functions
7.1

AF
Low Level Dirac Algebra Functions
There are a number of lower level functions for doing Dirac algebra accessible (defined in contexts belongint to
$Path). Some are used by the functions described in section 4.2, some may be useful to perform more controlled
calculations. They are described here also for completeness: DiracGammaCombine DiracGammaExpand
DiracGammaT DiracSigma DiracSigmaExplicit DiracSpinor EpsChisholm ChisholmSpinor

7.2 Functions for Polynomial Manipulations

Unfortunately the built-in Mathematica 2.0 functions Factor, Collect and Together are either not general
enough for the purposes needed in FeynCalc or consume too much CPU time for certain polynomials with
rational coefficients. The FeynCalc extensions Factor2, Collect2 and Combine should be used instead when
manipulating the rational polynomials emerging from OneLoop or PaVeReduce.

Collect2[expr, x] group together powers of terms containing x

DR
Collect2[expr, {x1 , x2 , group together powers of terms containing x 1 , x2 , ...
...}]
Combine[expr] put terms in a sum over a common denominator
Factor2[expr] factor a polynomial in a canonical way

Modifications of Collect, Together and Factor.

7. Miscellaneous Functions 84

This collects f[x] and p[y]. In[211]:= Collect2[ (b - 2) d f[x] + f[x] + c p[y]
The default setting is not to + p[y], {f, y}]

T
expand terms like (b - 2)d.
Out[211]= (1 + (-2 + b) d) f[x] + (1 + c) p[y]

With the setting In[212]:= Collect2[3 B0[pp,m1,m2] (mˆ2 + s) +

ProductExpand ® B0[pp,m1,m2] s,
True the product 3(s + m2 ) gets B0, ProductExpand ® True]
expanded.
2
Out[212]= (3 m + 4 s) B0[pp, m1, m2]

This puts terms over a common

denominator without expanding
the numerator.

Consider a generic polynomial.

Mapping Factor on the

summands shows that no
canonical factorization of
integers in sums takes place.

If a canonical factorization is
AF In[213]:= Combine[(a - b) (c - d)/e + g]

Out[213]=
(a - b) (c - d) + e g
e

In[214]:= test = (a - b) x + (b - a) y

Out[214]= (a - b) x + (-a + b) y

In[215]:= Map[Factor, test]

Out[215]= (a - b) x + (-a + b) y

In[216]:= Map[Factor2, test]

desired, you may use Factor2
instead. Out[216]= (a - b) x - (a - b) y

This is the overall factorization of In[217]:= Factor[test]

Factor.
Out[217]= (-a + b) (-x + y)
DR
Here the convention used by In[218]:= Factor2[test]
Factor2 becomes clear: the
first term in a subsum gets a Out[218]= (a - b) (x - y)
positive prefactor.
7. Miscellaneous Functions 85

T
option name default value

ProductExpand False expand products

An expansion controlling option for Collect2 and Combine.

7.3 An Isolating Function for Automatically Introducing Abbreviations

AF
Isolate[expr]

Isolate[expr, {x1 , x2 ,
...}]
if Length[expr] > 0, substitute an abbreviation
K[i] for expr
substitute abbreviations for subsums free of x 1 , x2 , ...

A function for isolating variables by introducing abbreviations for common subexpressions.

option name default value

DR
IsolateHead K the head of the abbreviations
IsolateSplit 442 a limit beyond which Isolate splits the expres-
sion into two sums

Options for Isolate and Collect2.

Isolate with one argument In[219]:= Isolate[a + b]

introduces a single K[i] as
abbreviation. Out[219]= K[1]
7. Miscellaneous Functions 86

Here f gets isolated with K[1] In[220]:= test = Isolate[(a + b) f + (c + d) f +

and K[2] replacing the e, f]

T
bracketed subsums.
Out[220]= e + f K[1] + f K[2]

Looking at the FullForm In[221]:= FullForm[test]

reveals that the K[i] are given in
HoldForm. Out[221]= Out[221]//FullForm=
Plus[e, Times[f, HoldForm[K[1]]], Times[f, Hold-
Form[K[2]]]]

Asking for K[1] returns its In[222]:= { K[1], test, ReleaseHold[test] }

value, but in test K[1] is
held.

For the term

(b + c (y + z))
a single abbreviation F[2] is
returned.

With the help of an additional

function it is easy to introduce
identical abbreviations for each
subsum.
This trick of selectively
AF
Out[222]= {a + b, e + f K[1] + f K[2],

e + (a + b) f + (c + d) f}

In[223]:= Isolate[a[z] (b + c (y + z)) + d[z] (y +

z), {a, d},
IsolateHead ® F]

Out[223]= d[z] F[1] + a[z] F[2]

In[224]:= ( und[x__] := Isolate[Plus[x],

IsolateHead ® H]/;
FreeQ2[{x}, {a, d}];
(a[z] (b + c (y + z)) + d[z] (y + z))/.
Plus ® und /. und ® Plus
substituting functions for sums is )
also quite useful in special
reordering of polynomials. Out[224]= d[z] H[1] + a[z] H[2]

Here it is clear that H[1] = (y + In[225]:= ReleaseHold[%]

z) is part of H[2].
DR
Out[225]= (y + z) d[z] + a[z] (b + c H[1])

Decreasing the option In[226]:= Isolate[ a - b - c - d - e, IsolateHead

IsolateSplit significantly ® L, IsolateSplit ® 15 ]
forces Isolate to use more
than one L for a - b - c - Out[226]= L[2]
d - e.

This shows the values of the L. In[227]:= {L[2], L[1]}

Out[227]= {-c - d - e + L[1], a - b}

7. Miscellaneous Functions 87

The importance of Isolate is significant, since it gives you a means to handle very big expressions. The use of
Isolate on big polynomials before writing them to a file is especially recommended.

T
A subtle issue of the option IsolateSplit, whose setting refers to the
Length[Characters[ToString[FortranForm[expr]]]], is that it inhibits too many continuation lines in
the Fortran file when writing out expressions involving K[i] with Write2. See Section 7.5 for the usage of
Write2.
You may want to change IsolateSplit when working with big rational polynomials in order to optimize the
successive (FixedPoint) application of functions like Combine[ReleaseHold[#]]&.

7.4 An Extension of FreeQ and Two Other Useful Functions

AF
FreeQ2[expr, {f1 , f2 ,
...}]
NumericalFactor[expr]
PartitHead[expr, h]

Three useful functions.

yields True if expr does not contain any occurrence of f 1 ,
f2 , . . .
gives the numerical factor of expr
returns a list {a, h[b]} with a free of expressions with head
h, and h[b] having head h

FreeQ2 is an extension of In[228]:= FreeQ2[Mˆ2 + mˆ2 B0[pp, m1, m2], {M,

FreeQ, allowing a list as second B0}]
argument.
Out[228]= False
DR
This gives the numerical factor of In[229]:= NumericalFactor[-137 x]
the expression.
Out[229]= -137

The action of PartitHead on In[230]:= PartitHead[f[m] (s - u), f]

a product is to split the product
apart. Out[230]= {s - u, f[m]}

A sum gets separated into In[231]:= PartitHead[sˆ2 + Mˆ2 - f[m], f]

subsums.
2 2
Out[231]= {M + s , -f[m]}
7. Miscellaneous Functions 88

7.5 Writing Out to Mathematica, Fortran, Macsyma and Maple

T
The Mathematica functions Write and Save may on rare occasions create files that cannot be read in again
correctly. What sometimes happens is that, for example, a division operator is written out as the first character of
a line. When the file is loaded again, Mathematica may simply ignore that part of the file before this character.
You can easily work around this bug by editing the file and wrapping the expressions with brackets “( )”. Since
this is a cumbersome procedure for lots of expressions, it has been automatized in Write2 for writing out
expressions. If you want to use Save, you have to check the output file for correctness.
An option can be given to Write2 allowing the output to be written in FortranForm, MacsymaForm or
MapleForm. These facilities are elementary and mostly limited to the type of polynomials usually encountered
in FeynCalc.
The FortranForm option should not be used if the expression to be written out contains a term (-x) n , where

AF
n is a symbol, (which is never produced by FeynCalc, unless you enter it). The Mathematica FortranForm is
also incapable of recognizing some elementary functions like Exp[x]. Therefore if you want to generate more
elaborate Fortran code you may want to use Maple, which provides an optimization option when translating
Maple code to Fortran, or the most sophisticated package for Fortran code generation from computer algebra
systems: Gentran (by B. Gates and H. van Hulzen), which is available in some Macsyma versions. To this end
the Write2 option FormatType may be set to MacsymaForm or MapleForm. You may achieve a rudimentary
optimization by applying Isolate on the expression to be written out. With the option setting FortranForm
and InputForm the function Write2 recognizes variables in HoldForm and writes these out with their defini-
tions first.

Write2[fi, x = y] write the setting x = y into a file fi

Write2[fi, x = y, a = b, write the setting x = y into a file fi
...]

A modification of Write.
DR
option name default value

FormatType InputForm language in which to write the output

D0Convention 0 which convention to use for the scalar integrals

Options for Write2.

7. Miscellaneous Functions 89

With the default setting 0 of D0Convention the arguments of the scalar integrals are not changed when written
into a Fortran program. Another possible setting is 1, which interchanges the fifth and sixth arguments of D0 and

T
writes the mass arguments of A0, B0, C0 and D0 without squares.

InputForm write out in Mathematica form

FortranForm write out in Fortran form
MacsymaForm write out in Macsyma form
MapleForm

AF write out in Maple form

The four possible settings of the option FormatType for Write2.

The output possibilities for the two other computer algebra systems Macsyma and Maple are very limited: square
brackets in Mathematica are changed to round brackets, additional replacements are for MacsymaForm { Pi ®
%pi, I ® %i, = ® : } and for MapleForm { = ® := }.
The reasons to include these interface abilities are to utilize the Fortran optimization possibility of Maple and the
excellent package Gentran for Fortran code generation.

Create a test polynomial. In[232]:= tpol = z + Isolate[Isolate[2 Pi I + f[x]

(a - b), f]]

Out[232]= z + K[2]

The default writes out in In[233]:= Write2["test.m", test = tpol];

Mathematica InputForm.
Show the content of the file. In[234]:= !!test.m
DR
Out[234]= K[1] = a - b
K[2] = 2*I*Pi + f[x]*HoldForm[K[1]]

test = z + HoldForm[K[2]]

This writes a file in Fortran In[235]:= Write2["test.for", test = tpol,

format. FormatType ® FortranForm];
7. Miscellaneous Functions 90

Show the content of the Fortran In[236]:= !!test.for

file.

T
Out[236]= K(1) = a - b
K(2) = (0,2)*Pi + f(x)*K(1)
test = z + K(2)

This writes a file in Macysma In[237]:= Write2["test.mac", test = tpol,

format. FormatType ® MacsymaForm];

Here the Macsyma format can be In[238]:= !!test.mac

seen.

Here we get a file with Maple

conventions.

The Maple conventions are only

slightly different.

7.6 More on Levi-Civita Tensors

AF
Out[238]= test : ( 2*%i*%pi + z + (a - b)*f(x) )$

In[239]:= Write2["test.map", test = tpol,

FormatType ® MapleForm];

In[240]:= !!test.map

Out[240]= test := ( 2*I*Pi + z + (a - b)*f(x) );

EpsEvaluate[expr] evaluate Levi-Civita Eps

A function for total antisymmetry and linearity with respect to Momentum .

DR
This is ¶Μ Ν Ρ Σ (p + q)Σ = ¶Μ Ν Ρ (p+q) . In[241]:= Contract[LeviCivita[m, n, r, s]
FourVector[p + q, s]]

Out[241]= eps[m, n, r, p + q]

In this way linearity is enforced: In[242]:= EpsEvaluate[%]

¶Μ Ν Ρ (p+q) = ¶Μ Ν Ρ p + ¶Μ Ν Ρ q .
Out[242]= eps[m, n, r, p] + eps[m, n, r, q]
7. Miscellaneous Functions 91

This does not evaluate directly to In[243]:= LeviCivita[a, b, c, d] /. d ® c

0.

T
Out[243]= eps[a, b, c, c]

Like this you can always evaluate In[244]:= EpsEvaluate[%]

¶’s.
Out[244]= 0

option name

LeviCivitaSign
AF
EpsChisholm[expr]

A function for the Chisholm identity.

utilize ΓΜ ¶ΜΝΡΣ = +i (ΓΝ ΓΡ ΓΣ - gΝΡ ΓΣ - gΡΣ ΓΝ + gΝΣ ΓΡ )Γ5

default value

-1 sign convention for the ¶-tensor

An option for EpsChisholm.

Use the Chisholm identity for In[245]:= EpsChisholm[LeviCivita[a, b, c, d]

¶a b c d ΓΜ Γa .
DR
DiracMatrix[mu, a] ]

Out[245]= +I (-(g[c, d] ga[mu] ga[b] ga[5]) +

g[b, d] ga[mu] ga[c] ga[5] -
g[b, c] ga[mu] ga[d] ga[5] +
ga[mu] ga[b] ga[c] ga[d] ga[5])
7. Miscellaneous Functions 92

T
Eps[a, b, c, d] internal representation of Levi-Civita tensors, where the
arguments must have head LorentzIndex or Momentum

The internal function for Levi-Civita tensors, see also section 3.4.

This clears $PrePrint. In[246]:= $PrePrint=.

This shows the internal structure.

Contracting ¶Μ Ν Ρ Σ pΣ yields
¶Μ Ν Ρ p .
In the internal representation the
p has the head Momentum
wrapped around it.

7.7
AFIn[247]:= LeviCivita[m, n, r, s]

Out[247]= Eps[LorentzIndex[m], LorentzIndex[n],

LorentzIndex[r], LorentzIndex[s]]

In[248]:= Contract[% FourVector[p, s]]

Out[248]= Eps[LorentzIndex[m], LorentzIndex[n],

LorentzIndex[r], Momentum[p]]

Simplifications of Expressions with Mandelstam Variables

TrickMandelstam[expr, simplifies expr to the shortest form removing s, t or u in each

2 2 2 2
{s, t, u, m1ˆ2 + m2ˆ2 + sum using s + t + u = m1 + m2 + m3 + m4
DR
m3ˆ2 + m4ˆ2}]

For tricky Mandelstam variable substitution.

This is an easy example In[249]:= TrickMandelstam[(s + t - u) (2 mw2 - t -

of simplifications done by u), {s, t, u, 2 mw2}]
TrickMandelstam.
Out[249]= 2 s (mw2 - u)
7. Miscellaneous Functions 93

The result is always given in a In[250]:= TrickMandelstam[Mˆ2 s - sˆ2 + Mˆ2 t - s t

factorized form. + Mˆ2 u - s u, {s, t, u, 2 Mˆ2}]

T
2 2
Out[250]= 2 M (M - s)

7.8 Manipulation of Propagators

AF
FeynAmpDenominatorCombine[expr]

FeynAmpDenominatorSimplify[expr]

FeynAmpDenominatorSimplify[expr,
expands expr w.r.t. to FeynAmpDenominator and combines
products of FeynAmpDenominator into one
FeynAmpDenominator

simplifies each PropagatorDenominator in a canonical way

sl q] includes some translation of momenta

FeynAmpDenominatorSimplify[expr,
sl q1, sl q2] additionally removes 2-loop integrals with no mass scale
FeynAmpDenominatorSplit[expr]
splits every FeynAmpDenominator[a,b, ...] into
FeynAmpDenominator[a]*FeynAmpDenominator[b]
...
FeynAmpDenominatorSplit[expr,
DR
sl q] splits every FeynAmpDenominator[a,b, ...] into a
product of two, one with sl q and other momenta, the other
without sl q
PropagatorDenominatorExplicit[expr]
writes out FeynAmpDenominator[a,b, ...] explicitly
as a fraction

Functions for manipulating propagators.

7. Miscellaneous Functions 94

7.9 Polarization Sums

T
PolarizationSum[mu, nu] -gΜΝ
PolarizationSum[mu, nu, -gΜΝ + kΜ kΝ / k2
k]
PolarizationSum[mu, nu, -gΜΝ - kΜ kΝ n2 / (k × n)2 + (nΜ kΝ + nΝ kΜ )/ (k × n)
k, n]

Polarization sums.

This is the polarization sum for

massive bosons:
S¶Μ ¶*Ν = -gΜΝ + kΜ kΝ / k2 .

Here the polarization sum for

gluons is given; with external
momentum n = p1 - p2 .
AF
In[251]:= PolarizationSum[mu, nu, k]

Out[251]= -g[mu, nu] +

k[mu] k[nu]
k.k

In[252]:= PolarizationSum[mu, nu, k, p1 - p2]

Out[252]= -g[mu, nu] -

(p1.p1 - 2p1.p2 + p2.p2)k[mu]k[nu]
+
(k.p1 - k.p2)2

k[nu] (p1 - p2)[mu] + k[mu] (p1 - p2)[nu]

k.p1 - k.p2
DR
7.10 Permuting the Arguments of the Four-Point Function
The arguments of the Passarino-Veltman four-point function D0 are permuted by FeynCalc into an alphabetical
order. If you want a specific permutation of the 24 possible ones, you can use the function PaVeOrder.
7. Miscellaneous Functions 95

T
PaVeOrder[expr] order the arguments of C0 and D0 in expr canonically.

An ordering function for C0 and D0 .

option name

PaVeOrderList

An ordering option for PaVeOrder.

AF
default value

{}

With the default setting of PaVeOrder a canonical ordering is chosen.

It is sufficient to supply a subset

of the arguments.
order D0 according to {..., a, b, ...

In[253]:= PaVeOrder[D0[me2, me2, mw2, mw2, t, s,

me2, 0, me2, 0],
PaVeOrderList ® {me2, me2, 0, 0}]
}

Out[253]= D0[me2, s, mw2, t, mw2, me2, me2, 0, 0, me2]

This interchanges the f and e. In[254]:= PaVeOrder[D0[a, b, c, d, e, f, m12, m22,

m32, m42],
PaVeOrderList ® {f, e}]
DR
Out[254]= D0[a, d, c, b, f, e, m22, m12, m42, m32]

This shows how to permute In[255]:= PaVeOrder[D0[a, b, c, d, e, f, m12, m22,

several D0 . m32, m42] + D0[me2, me2, mw2, mw2, t,
s, me2, 0, me2, 0], PaVeOrderList ® {
{me2, me2, 0, 0}, {f, e}}]

Out[255]= D0[a, d, c, b, f, e, m22, m12, m42, m32] + D0[me2, s, mw2,

t, mw2, me2, me2, 0, 0, me2]
8. Reference Guide for FeynCalc 96

8 Reference Guide for FeynCalc

T
A0

A0[mˆ2] is the scalar Passarino-Veltman one-point function.

A0[mˆ2] is an abbreviation for A0 (m2 ) = -iΠ-2 Ù d D q (2ΜΠ)4-D [q2 - m2 ]-1 .

A0[0] and
A0[Small[massˆ2]] give 0. The following option can be given:

A0ToB0 True replace A0 (m2 ) by m2 (1 + B0 (0, m2 , m2 ))

A0ToB0

B0

given:

BReduce
2
p)2 - m2 ])-1 .

AF
A0ToB0 is an option for A0. If set to True, A0 (m2 ) is replaced by m2 (1 + B0 (0, m2 , m2 )).

B0[pp,m1 ˆ2,m2 ˆ2] is the scalar Passarino-Veltman two-point function.

B0[pp,m1 ˆ2,m2 ˆ2] is an abbreviation for B0 (p2 , m1 , m2 ) = -iΠ-2 Ù d D q (2ΜΠ)4-D ([q2 -m1 ][(q+
2 2

B0 is symmetric in its second and third argument.

False

reduce B0 in special cases to A0

2

The following options can be

B0Unique False replace B0 (a, 0, a) by (2 + B0 (0, a, a)) and B0 (0, 0, a) by

(1 + B0 (0, a, a)).

B00

B00[pp,m1 ˆ2,m2 ˆ2] is the coefficient of gΜΝ of the tensor integral decomposition of B ΜΝ .
DR

The following option can be given:

BReduce True reduce B00 to B1 and A0

If BReduce is set to True the following simplification holds:

B00 (a, b, c) = 1/ 6(A0 (b) + (B1 (a, b, c)(a - c + b) + a/ 3B0 (a, b, c) + 1/ 6(a + b - c/ 3))).
B0Unique
B0Unique is an option for B0.

Sometimes it is useful to set this option to True, since only then all simplifications between
different B0 occur.
8. Reference Guide for FeynCalc 97

B1

T
B1[pp,m1 ˆ2,m2 ˆ2] is the coefficient of pΜ of the tensor integral decomposition of B Μ .

The following option can be given:

BReduce True reduce B1 to B0 and A0

If a variable of B1 has head Small and at least one other variable does not (and is different
from 0), the variable with head Small is set to 0. If the option BReduce is set to True, B1

simplifies in the following way, where a, b, c are m 2 with no head Small. The same simplifications
are performed if instead of 0 a Small variable is supplied as an argument.
B1 (a, b, c) = 1/ 2(A0 (b) - A0 (b) - (a - c + b)B0 (a, b, c)).

B11
AF
B1 (a, b, b) = -1/ 2B0 (a, b, b).
B1 (a, a, 0) = -1/ 2B0 (a, a, 0) - 1/ 2.
B1 (a, 0, a) = 1/ 2 - 1/ 2B0 (a, 0, m).
B1 (0, 0, a) = -1/ 2B0 (0, 0, a) + 1/ 4.
B1 (0, a, 0) = -1/ 2B0 (0, a, 0) - 1/ 4.

B11[pp,m1 ˆ2,m2 ˆ2] is the coefficient of pΜ pΝ of the tensor integral decomposition of B ΜΝ .

The following option can be given:

BReduce True reduce B11 to B1 and A0

If the option BReduce is set to True, B11 simplifies in the following way, where a, b, c are m 2
with no head Small.
B11 (a, b, c) = 1/ (3a)(A0 (b) - 2(a - c + b)B1 (a, b, c) - aB0 (a, b, c) - 1/ 2(a + b - c/ 3)).
B11 (0, a, a) = 1/ 3B0 (0, a, a).
BReduce
DR
BReduce is an option for B0, B00, B1 and B11, determining whether reductions to lower-order A
and B are done.

The default setting of BReduce is True.

CancelQ2

CancelQ2 is an option for OneLoop. If set to True, cancellation of all q 2 with the first propagator
via q2 ® ((q2 - m2 ) + m2 ) is performed, where q denotes the integration momentum.

With the default True the translation of the integration momentum in the lower order Passarino
Veltman functions is done such that the third mass argument of the 4-point integral is put at position
1.
8. Reference Guide for FeynCalc 98

CancelQP

T
CancelQP is an option for OneLoop. If set to True, cancellation of q × p with propagators is per-
formed, where q denotes the integration momentum.

ChiralityProjector

ChiralityProjector[+1] is an alternative input for Ω + = 12 (1+Γ5 ). ChiralityProjector[-1]

denotes Ω- = 21 (1 - Γ5 ).

C0

AF
ChiralityProjector[1] is identical to DiracMatrix[6]. ChiralityProjector[-1]
is identical to DiracMatrix[7].
DiracGamma[7].
The internal representation is DiracGamma[6] and

See also: DiracMatrix, DiracGamma.

C0[p10 ,p12 ,p20 ,m1 ˆ2,m2 ˆ2,m3 ˆ2] is the scalar Passarino-Veltman three-point function. The first
2
three arguments of C0 are the scalar products p 10 = p1 , p12 = (p1 - p2 )2 , p20 = p2 .


2

C0[p10 ,p12 ,p20 ,m1 ˆ2,m2 ˆ2,m3 ˆ2] is an abbreviation for C0 = -iΠ-2 Ù d D q (2ΜΠ)4-D ([q2 -
2 2 2
m1 ][(q + p1 )2 - m2 ][(q + p2 )2 - m3 ])-1 .
permutations is chosen.

See also: PaVeOrder.

A standard representative of the six equivalent argument

Collect2

Collect2[expr, x] collects together terms which are not free of any occurrence of x.
Collect2[expr, {x1 , x2 , ...}] collects together terms which are not free of x 1 , x2 , . . . .
DR

The following option can be given.

ProductExpand False expand products in expr free of x (x 1 , x2 , ...)

IsolateHead False isolate with respect to {x1 , x2 , ...}
IsolateSplit 442 the limit before Isolate splits

See also: Isolate.

Combine

Combine[expr] puts terms in a sum over a common denominator. Combine is similar to

Together, but works better on certain polynomials with rational coefficients.
8. Reference Guide for FeynCalc 99

The following option can be given:

T
ProductExpand False expand products

CombineGraphs

CombineGraphs is an option for OneLoopSum.

The utilization of this option may speed up FeynCalc. But depending on the available memory
there is a turning point where FeynCalc becomes quite inefficient when forced to calculate too may
complicated diagrams at once.

Contract

Expanding
Factoring

Examples:
AF
Contract[expr] contracts pairs of Lorentz indices in expr.

For the contraction of two Dirac matrices DiracSimplify has to be used.

Contract is not fully expanded. The following options can be given:

EpsContract False

True
False

Contract[ FourVector[p, mu]ˆ2 ] ® p.p.

terminant formula
expand all sums containing Lorentz indices
factor the result canonically

The result of

contract products of Levi-Civita (Eps) tensors via the de-

Contract[ FourVector[p + q, mu] FourVector[p’ + q’, mu] ]//

ExpandScalarProduct ® p.p’ + p.q’ + q.p’ + q.q’.
Contract[ LeviCivita[m, n, r, a] LeviCivita[m, n, r, b], EpsContract ® True
] ® - 6 g[a, b].
Contract[ Pair[ LorentzIndex[mu, Dim], LorentzIndex[mu, Dim] ] ] ® Dim.
Contract[ Pair[ LorentzIndex[mu, D - 4], LorentzIndex[mu] ] ] ® 4.
Contract[ Pair[ LorentzIndex[mu, D - 4], LorentzIndex[mu] ] ] ® 0.
DR
Contract[ Pair[ LorentzIndex[mu, D - 4], LorentzIndex[mu, D - 4] ] ] ®
-4 + D.
Contract[ f[ ___, LorentzIndex[mu], ___ ] MetricTensor[mu, al] ] ® f[
___, LorentzIndex[al], ___ ].
Contract[ f[ ___, LorentzIndex[mu], ___ ] FourVector[p, mu] ] ® f[ ___,
FourVector[p], ___ ].
Contract[ DiracMatrix[mu, Dimension ® D] MetricTensor[mu, al] ] ®
DiracGamma[LorentzIndex[nu]].
Contract[ DiracGamma[LorentzIndex[mu, D-4], D-4] MetricTensor[mu, al] ] ®
0.
8. Reference Guide for FeynCalc 100

If big expressions are contracted and substitutions for the resulting scalar products are made, it
is best not to do these replacements after contraction, but to set the values of the relevant scalar

T
products before invoking Contract; in this way the intermediate expression swell is minimized.

See also: ExpandScalarProduct.

D0

D0[p10 , p12 , p23 , p30 , p20 , p13 , m1 ˆ2, m2 ˆ2, m3 ˆ2, m4 ˆ2] is the scalar Passarino-
2
Veltman four-point function. The first six arguments of D0 are the scalar products p 10 = p1 , p12 =
2 2
(p1 - p2 )2 , p23 = (p2 - p3 )2 , p30 = p3 , p20 = p2 , p13 = (p1 - p3 )2 .

D0[p10 , p12 , p23 , p30 , p20 , p13 , m1 ˆ2, m2 ˆ2, m3 ˆ2, m4 ˆ2] is an abbreviation for D0 =
-iΠ-2 Ù d 4 q ([q2 - m1 ][(q + p1 )2 - m2 ][(q + p2 )2 - m3 ][(q + p3 )2 - m4 ])-1 .

DB0

AF
2

See also: PaVe, PaVeOrder.

D0Convention
2 2 2

D0Convention is an option for Write2. Possible settings are 0 or 1. With the last setting the
fifth and sixth arguments of D0 are interchanged and all (internal) mass arguments of the scalar
Passarino Veltman integrals are given square free.

See also: Write2, D0.

2 2
DB0[p10 , m0 ˆ2, m1 ˆ2] is the derivative ¶B0 (p2 , m0 , m1 )/ ¶p2 of the two-point function B0 .

See also: B0.

DenominatorOrder

DenominatorOrder is an option for OneLoop, if set to True the PropagatorDenominator in

FeynAmpDenominator will be ordered in a standard way.
DR

You may want to set this option to False when checking hand calculations.

Dimension

Dimension is an option for DiracMatrix, DiracSlash, FourVector, MetricTensor,

OneLoop and ScalarProduct.

The setting of Dimension may be 4, dim or dim-4, where dim must be a Mathematica Symbol
.

DiracGamma
8. Reference Guide for FeynCalc 101

DiracGamma[x, optdim] is the head of all Dirac matrices and Feynman slashes p/ (= ΓΜ pΜ ) in the
internal representation.

T
A four-dimensional Dirac matrix ΓΜ is DiracGamma[ LorentzIndex[mu] ], a four-
dimensional Feynman slash is DiracGamma[ Momentum[p] ].
Γ5 is represented as DiracGamma[5], the helicity projectors Γ6 = (1 + Γ5 )/ 2 and Γ7 = (1 - Γ5 )/ 2
as DiracGamma[6] and DiracGamma[7] respectively.
For other than four dimensions an additional argument is necessary: DiracGamma[
LorentzIndex[mu, Dim], Dim ] and DiracGamma[ Momentum[q, Dim], Dim ].

For standard input DiracMatrix and DiracSlash are more convenient. Note that

DiracGamma[exp, Dim] projects out the smaller dimension of the objects exp and Dim. There

DiracMatrix

AF
are special relationships if Dim takes the form D-4, e.g., DiracGamma[ LorentzIndex[mu,
D-4],4 ] ® 0.

DiracMatrix[mu] is an input function for a Dirac matrix. A product of Dirac matrices Γ Μ ΓΝ ΓΡ . . .

is entered as DiracMatrix[ mu, nu, ro, ... ] or equivalently as DiracMatrix[mu] .
DiracMatrix[nu] . DiracMatrix[ro] . ...
Γ5 may be entered as DiracMatrix[5], Γ6 = (1 + Γ5 )/ 2 as DiracMatrix[6] and Γ7 = (1 - Γ5 )/ 2
as DiracMatrix[7]

The following option can be given:

Dimension 4 space-time dimension

Γ5 , Γ6 and Γ7 are defined purely in four dimensions.

See also: DiracGamma, DiracSlash,

ChiralityProjector, $BreitMaison.

DiracOrder

DiracOrder[expr, orderlist] orders the Dirac matrices in expr according to orderlist.

DR
DiracOrder[expr] orders the Dirac matrices in expr alphabetically.

Γ5 , Γ6 and Γ7 are not ordered; use DiracSimplify to push them all to the right. Example:

DiracOrder[ DiracSlash[a, q, a, p] ] ® -2 a.a p.q + 2 a.q gs[a] . gs[p]

+ a.a gs[p] . gs[q].
DiracOrder[ DiracSlash[p], DiracSlash[q], {q,p} ] ® 2 p.q - gs[q] . gs[p].

This function is just the implementation of the anticommutator relation for Dirac matrices.
See also: DiracSimplify.
DiracSimplify

DiracSimplify[expr] simplifies products of Dirac matrices in expr. Double Lorentz in-

dices and four vectors are contracted. The Dirac equation is applied. All DiracMatrix[5],
8. Reference Guide for FeynCalc 102

DiracMatrix[6] and DiracMatrix[7] are moved to the right. The order of the Dirac matrices
is not changed.

T

(p/ - m) u(p) = 0, (p/ + m) v(p) = 0 and u(p)(p/ - m) = 0, v(p)(p/ + m) = 0 are represented by:
DiracSimplify[ (DiracSlash[p] - m) . Spinor[p, m] ] ® 0, DiracSimplify[
(DiracSlash[p] + m) . Spinor[-p,m] ] ® 0, DiracSimplify[ Spinor[p, m] .
(DiracSlash[p] - m ) ] ® 0, DiracSimplify[ Spinor[-p,m] . (DiracSlash[p]
+ m ) ] ® 0

Examples:
DiracSimplify[ DiracMatrix[mu, mu] ] ® 4.
DiracSimplify[ DiracSlash[p, p] ] ® p.p.
DiracSimplify[ DiracMatrix[al, be, al] ] ® -2 ga[be].

ga[be].

AF
DiracSimplify[ DiracMatrix[al, be, al, Dimension®D] ]//Factor

DiracSimplify[ DiracMatrix[6, mu] ] ® ga[mu] . ga[7].

See also: DiracOrder.

DiracSlash
® (2-D)

DiracSimplify[ DiracSlash[p], (DiracSlash[-q]+m), DiracSlash[p] ] ® gs[q]

p.p - 2 gs[p] p.q + p.p m.
DiracSimplify[ DiracMatrix[5, mu] ] ® -ga[mu] . ga[5].

DiracSlash[p] is an input function for a Feynman slash p/ = Γ Μ pΜ . A product of slashes may be

entered by DiracSlash[p, q, ...] or DiracSlash[p], DiracSlash[q], ... .

The following option can be given:

Dimension 4 space-time dimension

The internal representation of a four-dimensional DiracSlash[p] is DiracGamma[

Momemtum[p] ], a D-dimensional DiracSlash[ p, Dimension ® D ] is transformed into
DiracGamma[ Momemtum[p, D], D].

See also: DiracGamma, DiracMatrix.

DR
DiracTrace

DiracTrace[expr] is the head of a Dirac trace. Whether the trace is evaluated depends on the
option DiracTraceEvaluate. The argument expr may be a product of Dirac matrices or slashes
separated by “.”.

The following options can be given:

DiracTraceEvaluate False evaluating the trace

LeviCivitaSign -1 sign convention for the ¶-tensor
Factoring False factor the result
Mandelstam {} if set to {s, t, u, m1 ˆ2 + m2 ˆ2 + m3 ˆ2 + m4 ˆ2},
TrickMandelstam will be used
8. Reference Guide for FeynCalc 103

PairCollect True collect the results with respect to products of Pair

T

Examples:
DiracTrace[ DiracMatrix[al, be] ] ® 4 g[al, be].
DiracTrace[ DiracSlash[p, q] ] ® 4 p.q.
DiracTrace[ DiracMatrix[mu, al, be, mu, Dimension®D] ] ® 4 D g[al, be].
DiracTrace[ DiracMatrix[a, b, c, d, 5] ] ® -4 I Eps[a, b, c, d].
DiracTrace[ MetricTensor[al, be] DiracMatrix[si, al, ro, si] ] ® 16 g[be,
ro].
DiracTrace[ DiracSlash[p - q] . (DiracSlash[q] + m) + DiracSlash[k, 2 p]
] ® 8 k.p + 4 p.q - 4 q.q.
With PP=DiracSlash[p’]; P=DiracSlash[p]; MU=DiracMatrix[mu]; K=DiracSlash[k];

AF
NU=DiracMatrix[nu]: DiracTrace[ (PP+m).MU.(P+K+m).NU.(P+m).NU.(P+K+m).MU/16
]/.mˆ2®m2/.mˆ4®m4 ® 4 m4 + k.p (4 m2 + 2 k.p’) + k.p’ (-4 m2 + 2 p.p) +
k.k (4 m2 - p.p’) - 3 m2 p.p’ + p.p p.p’.
To replace scalar products two possibilities exist: either set the corresponding ScalarProduct
before calculating the trace: ScalarProduct[p, q] = t/2; (DiracTrace[p . q]) ®
2 t, which is preferable, or substitute afterwards: (DiracTrace[ DiracSlash[a, b]
]/.ScalarProduct[a, b]®s/2) ® 2 s.

See also: DiracMatrix, DiracSlash, ScalarProduct, TrickMandelstam.

DiracTraceEvaluate
DiracTraceEvaluate is an option for DiracTrace. If set to False,DiracTrace remains
unevaluated.

The resaon for this option is that OneLoop needs traces in unevaluated form.
Eps
Eps[a, b, c, d] is the head of the totally antisymmetric four-dimensional epsilon (Levi-Civita)
tensor. The a, b, c, d must have head LorentzIndex or Momentum.

All entries are transformed to four dimensions.

For user-friendly input of an

Eps just with LorentzIndex’ use LeviCivita.

For ¶ΜΝΡΣ qΣ the compact notation

DR
¶ΜΝΡq is used, i.e.: Eps[LorentzIndex[mu], LorentzIndex[nu], LorentzIndex[ro],
Momentum[q]].

Eps is just a head not having any functional properties. In order to exploit
linearity (¶ΜΝΡ(p+q) ® ¶ΜΝΡp + ¶ΜΝΡq ) and the total antisymmetric property of the Levi-Civita tensor
use EpsEvaluate.
EpsChisholm
EpsChisholm[expr] substitutes for a gamma matrix contracted with a Levi Civita tensor (Eps)
the Chisholm identity: ΓΜ ¶ΜΝΡΣ = +i (ΓΝ ΓΡ ΓΣ - gΝΡ ΓΣ - gΡΣ ΓΝ + gΝΣ ΓΡ )Γ5 .

With the option LeviCivitaSign the sign of the right hand side of the equation above can be
altered. The following option can be given:


8. Reference Guide for FeynCalc 104

LeviCivitaSign -1 sign convention

T
EpsContract

EpsContract is an option for Contract specifying whether Levi-Civita tensors Eps will be con-
tracted, i.e., products of two Eps are replaced via the determinant formula.

EpsEvaluate

EpsEvaluate[expr] applies total antisymmetry and linearity (with respect to Momentum) to all

AF
Levi-Civita tensors (Eps) in expr.

EvaluateDiracTrace

EvaluateDiracTrace[expr] evaluates DiracTrace in expr.

Expanding

Expanding is an option for Contract specifying whether expansion will be done in Contract.
If set to False, not all Lorentz indices might get contracted.

ExpandScalarProduct

ExpandScalarProduct[expr] expands scalar products in expr.

Example:
DR

ExpandScalarProduct[ ScalarProduct[ p-q,r+2 s ] ] ® p.r + 2 p.s - q.r -

2 q.s.

At the interal level ExpandScalarProduct expands actually everything with head Pair.

Since a four-vector has head Pair internally also, ExpandScalarProduct[ FourVector[p -

2 q, mu] ] ® p[mu] - 2 q[mu].

Factor2

Factor2[expr] factors a polynomial in a standard way. Factor2 works better than Factor on
polynomials involving rationals with sums in the denominator.

In general it is better to use Factor2 in Mathematica 2.0.

8. Reference Guide for FeynCalc 105

Factoring

T
Factoring is an option for Contract, DiracTrace, DiracSimplify and OneLoop. If set to
True the result will be factored, using Factor2.

FeynAmp

FeynAmp[name, amp, q] is the head of the Feynman amplitude given by FeynArts. The first
argument name is for bookkeeping, amp is the analytical expression for the amplitude, and q is
the integration variable. In order to calculate the amplitute replace FeynAmp by OneLoop. In the

FeynAmpDenominator

Example:
2
AF
output of FeynArts name has the head GraphName.

See also: GraphName, Guide to FeynArts.

FeynAmpDenominator[ PropagatorDenominator[...], PropagatorDenominator[...],

...] is the head of the denominators of the propagators, i.e., FeynAmpDenominator[x] is the
representation of 1/ x.

2
1/ ([q2 -m1 ][(q+p1 )2 -m2 ]) is represented as FeynAmpDenominator[ PropagatorDenominator[q,m1],
PropagatorDenominator[q+p1,m2] ].

See also: PropagatorDenominator.

FeynAmpList

FeynAmpList[info ... ]FeynAmp[ ... ], FeynAmp[ ... ], ...] is the head of a list
of FeynAmp in the result of FeynArts.

See also: Guide to FeynArts.

DR
FeynCalcForm

FeynCalcForm[expr] changes the printed output of expr to an easy to read form. The default
setting of $PreRead is $PreRead = FeynCalcForm, which forces to display everything after
applying FeynCalcForm.

Small, Momentum and LorentzIndex are set to Identity by FeynCalcForm. PaVe are

abbreviated. The action of FeynCalcForm is: DiracMatrix[al] ® ga[al].

DiracSlash[p] ® gs[p].
FeynAmpDenominator[ PropagatorDenominator[q,m1], PropagatorDenominator[q+p,m2]
] ® 1/(qˆ2 - m1ˆ2) ((p + q)ˆ2 - m2ˆ2).
FourVector[p, mu] ® p[mu].
8. Reference Guide for FeynCalc 106

FourVector[p-q, mu] ® (p - q)[mu].

GellMannMatrix[a] ® la[a].

T
GellMannTrace[x] ® tr[x].
DiracTrace[x] ® tr[x].
LeviCivita[a, b, c, d] ® eps[a, b, c, d].
MetricTensor[mu, nu] ® g[mu nu].
Momentum[ Polarization[p] ] ® ep[p].
Conjugate[PolarizationVector[k, mu]] ® ep(*)[k, mu].
PolarizationVector[p, mu] ® ep[p][mu].
ScalarProduct[p, q] ® p.q.
Spinor[p, m] ® u[p, m].
Spinor[-p, m] ® v[p, m].

AF
QuarkSpinor[p, m] ® u[p, m].
QuarkSpinor[-p, m] ® v[p, m].
SU3F[i, j, k] ® f[i, j, k].

FinalSubstitutions

FinalSubstitutions is an option for OneLoop and OneLoopSum. All substitutions given to

this opton will be performed at the end of the calculation.

Example: FinalSubstitutions ® {mwˆ2 ® mw2, B0 ® B0R}.

FourVector

FourVector[p, mu] is the input for a four vector p Μ .

FourVector[p, mu] is directly transformed to the internal representation: Pair[Momentum[p],

LorentzIndex[mu]]. The following option can be given:

Dimension 4 space-time dimension

See also: LorentzIndex, Momentum, Pair.

DR
FreeQ2

FreeQ2[expr, {form1, form2, ...}] yields True if expr does not contain any occurrence of
f orm1, f orm2, . . . . FreeQ2[expr, form] is the same as FreeQ[expr, {form1, form2, ...}].

Stephen Wolfram pointed out that you can use alternatively FreeQ[expr, form1 || form2 ||
...].

GellMannMatrix

GellMannMatrix[a] is the Gell-Mann matrix Λa . A product of Gell-Mann matri-

ces may be entered as GellMannMatrix[a, b, ...] or as GellmannMatrix[a] .
8. Reference Guide for FeynCalc 107

GellMannMatrix[b] . .... GellMannMatrix[1] denotes the unit-matrix in color space.

T

See also: SU3Delta , SU3F, GellMannTrace.

GellMannTrace

GellMannTrace[expr] calculates the trace of expr. All color indices should occur twice and expr
must be a product of SU3F, SU3Delta and GellMannMatrix.

The Cvitanovic algorithm is used. Examples: [GellMannTrace[GellMannMatrix[i.i]]

® 16. GellMannTrace[GellMannMatrix[a . b . c] SU3F[a, b, c]] ® 48 I.

GellMannTrace[GellMannMatrix[a . c . e . d] SU3F[a, b, e] SU3F[b, c, d]]
® 0. GellMannTrace[GellMannMatrix[1]] ® 3.

GraphName

under consideration.

InitialSubstitutions
AF
GraphName[a, b, c, d] is the first argument of FeynAmp given by FeynArts. It may be used
also as first argument of OneLoop. The arguments a, b, c, d indicate information of the graph

InitialSubstitutions is an option for PaVeReduce and OneLoop. All substitutions hereby

indicated will be performed at the beginning of the calculation. Energy momentum conservation
may be especially indicated in the setting.

Example: InitialSubstitutions ® {CWˆ2 ® 1 - SWˆ2, k2 ® - k1 + p1 + p2

}.

Isolate

Isolate[expr, {x1 , x2 , ... }] substitutes K[i] for all subsums in expr which are free of any
DR
occurrence of x1 , x2 , ..., if Length[expr]>0.
Isolate[expr] substitutes an abbreviation K[i] in HoldForm for expr, if Length[expr]>0.

The following options can be given:

IsolateHead K the head of the abbreviations

IsolateSplit 442 a limit beyound which Isolate splits the expression in
two sums

IsolateSplit is the maximum of the characters of the FortranForm of the expression being
isolated by Isolate. The default setting inhibits Write2 from producing too many continuation
8. Reference Guide for FeynCalc 108

lines when writing out in FortranForm. The result of Isolate can always be recovered by

MapAll[ ReleaseHold, result ]. Example: Isolate[a[z] (b+c) + d[f] (x+y),

T
{a,d} ] ® a[z] K[1] + d[f] K[2].

See also: Write2.

IsolateHead

IsolateHead is an option for Isolate.

IsolateSplit

K
AF
IsolateSplit is an option for Isolate.

K[i] are abbreviations which may result from PaVeReduce, depending on the option
IsolateHead. The K[i] are returned in HoldForm and may be recovered by ReleaseHold.

LeptonSpinor

LeptonSpinor[p, mass] specifies a Dirac spinor. Which of the spinors u, v, u or v is under-

stood, depends on the sign of the mass argument and the relative position of DiracSlash[p]:
LeptonSpinor[p, mass] is that spinor which yields mass*LeptonSpinor[p, mass]
if the Dirac equation is applied to DiracSlash[p] . LeptonSpinor[p, mass] or
LeptonSpinor[p, mass] . DiracSlash[p].
If a spinor is multiplied by a Dirac matrix or another spinor, the multiplication operator "." must be
DR
used.

See also: DiracSimplify.

LeviCivita

LeviCivita[mu, nu, ro, si] is an input function for the totally antisymmetric Levi-Civita ten-
sor.

LeviCivita[mu, nu, ro, si] transforms to the internal representation Eps[ LorentzIndex[mu],
LorentzIndex[nu], LorentzIndex[ro],
LorentzIndex[si] ]. For simplification of Levi-Civita tensors use EpsEvaluate.

See also: Eps, EpsEvaluate.

8. Reference Guide for FeynCalc 109

LeviCivitaSign

T
LeviCivitaSign is an option for DiracTrace. The possible settings are (+1) or (-1). This op-
tion determines the sign convention of the result of tr( Γ a Γb Γc Γd Γ5 ).

LorentzIndex

LorentzIndex[mu, optdim] is the head of Lorentz indices. The internal representation of a four-
dimensional Μ is LorentzIndex[mu]. For other than four dimensions enter LorentzIndex[mu,
dim].

MacsymaForm

Mandelstam
AF
LorentzIndex[mu, 4] simplifies to LorentzIndex[mu].

MacsymaForm is an option for FormatType in Write2.

See also: Write2, MapleForm.

Mandelstam is an option for DiracTrace, OneLoop and TrickMandelstam. A typical setting

is Mandelstam ® {s, t, u, m1ˆ2 + m2ˆ2 + m3ˆ2 + m4ˆ2}, which stands for s + t + u =
2 2 2 2
m1 + m 2 + m 3 + m 4 .

MapleForm

MapleForm is an option for Write2.

See also: Write2, MacsymaForm.

DR

MetricTensor

MetricTensor[mu, nu] is the input for a metric tensor g ΜΝ .

The following option can be given:

Dimension 4 space-time dimension

See also: Contract, LorentzIndex, Pair.

Momentum
8. Reference Guide for FeynCalc 110

Momentum[p, optdim] is the head of a momentum in the internal representation. A four-

dimensional momentum p is represented by Momentum[p]. For other than four dimensions an

T
extra argument must be given: Momentum[q, dim].

Momentum[p, 4] is automatically transformed to Momentum[p].

NumericalFactor

NumericalFactor[expr] gives the numerical factor of expr.

OneLoop

DenominatorOrder
Dimension
FinalSubstitutions
Factoring
InitialSubstitutions
Mandelstam
Prefactor
CancelQ2
AF
OneLoop[name, q, amplitude] calculates the one-loop Feynman diagram amplitude. The ar-
gument q denotes the integration variable, i.e., the loop momentum.

The following options can be given:

ReduceToScalars False
False
True
{}
False
{}
{}
1
True
reduce to B0 , C0 , D0
order the entries of FeynAmpDenominator
dimension of integration
substitutions done at the end of the calculation
factor the result
substitutions done at the beginning of the calculation
indicate the Mandelstam relation
additional prefactor of the amplitude
cancel q2
CancelQP False cancel q × p
ReduceGamma False eliminate Γ6 and Γ7
SmallVariables {} a list of masses, which will get wrapped around the head
Small
WriteOut True write out a result file name.m

Energy momentum conservation may be given as rule of InitialSubstitutions.

DR

OneLoopResult

OneLoopResult[name] is the variable in the result file written out by OneLoop to which the cor-
responding result is assigned. name is constructed from the first argument of OneLoop.

OneLoopSum

OneLoopSum[ FeynAmp[...], FeynAmp[...], ... ] calculates a list of Feynman ampli-

tudes by replacing FeynAmp step by step by OneLoop and sums the result.
8. Reference Guide for FeynCalc 111

The following options can be given:

T
CombineGraphs {} which amplitudes to sum before invoking OneLoop
FinalSubstitutions {} substitutions done at the end of the calculation
IsolateHead K Isolate the result
Mandelstam {} use the Mandelstam relation
Prefactor 1 multiply the result by a pre-factor
ReduceToScalars True reduce the summed result to scalar integrals
SelectGraphs All which amplitudes to select
WriteOutPaVe False write out the reduced PaVe
Possible settings for CombineGraphs and SelectGraphs are lists of integers. For indicating a
range of graphs also a list {i, j} instead of a single integer may be provided.
Pair

AF
Pair[a, b] is the head of a special pairing used in the internal representation. The arguments a
and b may have heads LorentzIndex or Momentum. If both a and b have head LorentzIndex,
the metric tensor is understood. If a and b have head Momentum, a scalar product is meant. If one of
a and b has head LorentzIndex and the other head Momentum, a Lorentz vector pΜ is understood.

Pair has only one functional definition: any integers multiplied with a or b will be pulled out.
See also: FourVector, LorentzIndex, MetricTensor, ExpandScalarProduct,
ScalarProduct.

PairCollect
PairCollect is an option for Contract.

See also: Pair, ScalarProduct, Momentum.

PaVe

PaVe[i, j, ..., plist, mlist] denotes the Passarino-Veltman integrals. The length of the mass
list mlist indicates if a one-, two-, three- or four-point integral is understood. The first set of
Μ Ν
DR
arguments i, j, . . . signifies that the coefficient of p i p j , . . . of the tensor integral decomposition is
Μ Ν
meant, where p0 p0 = gΜΝ . Joining plist and mlist gives the same conventions as for A0, B0, C0 and
D0.

For the corresponding arguments of PaVe the special cases A0, B0, C0, D0, B1, B00, B11 are
returned.
PaVeOrder

PaVeOrder[expr] brings all arguments of C0 and D0 into a canical order.

The following option can be given:

8. Reference Guide for FeynCalc 112

PaVeOrderList {} order according to a list of arguments

T
PaVeOrderList

PaVeOrderList is an option for PaVeOrder allowing to specify a specific order of the D0 func-
tions.

Possible settings are a sublist of the arguments of a D0, or a list of such lists.

PaVeReduce

PaVeReduce[expr] reduces Passarino-Veltman integrals PaVe to scalar integrals B0, C0 and D0,

Mandelstam


AF
depending on the option BReduce eventually also A0, B1, B00 and B11.

The class of invariant Passarino-Veltman integrals which can be currently reduced consists of all
coefficients of the Lorentz invariant decomposition of B Μ , BΜΝ , CΜ , CΜΝ , CΜΝΡ , DΜ , DΜΝ , DΜΝΡ , DΜΝΡΣ .

The following options can be given:

IsolateHead

See also: BReduce, K, PaVe.

Polarization
False
{}
use Isolate
Mandelstam relation, e.g., {s, t, u, 2 mwˆ2}

Polarization[p, optarg] is the head of a polarization momentum¶(p). Polarization

must always occur inside Momentum. The full internal representation of ¶(p) is Momentum[
Polarization[p] ]. With this notation transversality of polarization vectors is provided.

Polarization[p, -1] stands for the complex conjugate ¶(p) * .

See also: PolarizationVector.

PolarizationSum

PolarizationSum[mu, nu, ...] defines different polarization sums.

DR

PolarizationSum does not calculate any polarization sum, it is just an abbreviation function.

PolarizationSum[mu, nu]= -gΜΝ . PolarizationSum[mu, nu, k]= -gΜΝ + kΜ kΝ / k2 .

PolarizationSum[mu, nu, k, n]= -gΜΝ - kΜ kΝ n2 / (k × n)2 + (nΜ kΝ + nΝ kΜ )/ (k × n), where nΜ

denotes an external four vector.
PolarizationVector

PolarizationVector[p, mu] is an input function for a polarization vector ¶(k) Μ .

Conjugate{PolarizationVector[p, mu]} is the input for ¶*Μ (k). The internal rep-

resentation of PolarizationVector[p, mu] is Pair[ Momentum[Polarization[p]],

8. Reference Guide for FeynCalc 113

LorentzIndex[mu] ]. The internal representation of Conjugate{PolarizationVector[p,

mu]} is Pair[ Momentum[Polarization[p,-1]], LorentzIndex[mu] ].

T

See also: Polarization.

Prefactor

Prefactor is an option for OneLoop and OneLoopSum. If set as option of OneLoop, the am-
plitude is multiplied by Prefactor before calculation; if specified as option of OneLoopSum, it
appears in the final result as a global factor.

A possible setting is 1/ (1 - D) for calculating the transvere part of self energies. The option
Dimension of OneLoop must then be set to D.

ProductExpand

AF
ProductExpand is an option for Collect2 and Combine.

PropagatorDenominator

PropagatorDenominator[q, m] is the denominator of a propagator, i.e., (q 2 - m2 ).

PropagatorDenominator[q] evaluates to PropagatorDenominator[q, 0].

m].
If q is supposed to be D-dimensional enter: PropagatorDenominator[ Momentum[q,D],

PropagatorDenominator must always occur only as an argument of FeynAmpDenominator.

QuarkSpinor

QuarkSpinor[p, mass] specifies a Dirac spinor. Which of the spinors u, v, u or v is under-

stood, depends on the sign of the mass argument and the relative position of DiracSlash[p]:
QuarkSpinor[p, mass] is that spinor which yields mass*QuarkSpinor[p, mass] if the
Dirac equation is applied to DiracSlash[p] . QuarkSpinor[p, mass] or QuarkSpinor[p,
DR
mass] . DiracSlash[p].
If a spinor is multiplied by a Dirac matrix or another spinor, the multiplication operator "." must be
used.

See also: DiracSimplify.

ReduceGamma

ReduceGamma is an option for OneLoop determining whether Γ6 and Γ7 are removed by their
definitions 1/ 2(1 + Γ5 ) and 1/ 2(1 - Γ5 ).

This option may be needed for certain standard matrixelements.

8. Reference Guide for FeynCalc 114

ReduceToScalars

T
ReduceToScalars is an option for OneLoop and OneLoopSum that specifies whether the result
is reduced to scalar integrals.

Depending on the option BReduce the Passarino-Veltman functions B1, B11, B00 and B11 may
also remain.

See also: PaVeReduce.

ScalarProduct

ScalarProduct[p, q] is the input for a scalar product.

Dimension

AF
The following option can be given:

4 space-time dimension

The internal representation is: Pair[ Momentum[p], Momentum[q] ]. Scalar products

may be set, e.g., ScalarProduct[a, b] = c; but a and b must not contain sums.

See also ExpandScalarProduct.

SelectGraphs

SelectGraphs is an option for OneLoopSum. The default setting is All. It may be set to a list
indicating that only a subclass of all graphs supplied to OneLoopSum should be calculated.

SetMandelstam

SetMandelstam[s, t, u, p1 , p2 , p3 , p4 , m1 , m2 , m3 , m4 ] defines the Mandelstam

2 2
variables s = (p1 + p2 )2 , t = (p1 + p3 )2 , u = (p1 + p4 )2 and sets the pi on-shell: pi = mi ,
where the pi satisfy p1 + p2 + p3 + p4 = 0.
DR

If p3 = -k1 and p4 = -k2 , i.e., p1 + p2 = k1 + k2 , the input is: SetMandelstam[s, t, u, p1 ,

p2 , - k1 , - k2 , m1 , m2 , m3 , m4 ]

SetStandardMatrixElements

SetStandardMatrixElements[{sma1 ® abb1}, {sma2 ® abb2}, ... ,enmoconrule ] de-

fines the standard matrix elements sma1, sma2, .. (e.g., Spinor[p1] . DiracSlash[k] .
Spinor[p2]), as StandardMatrixelement[abb1], StandardMatrixelement[abb2], ... .
The last argument enmomcon defines energy momentum conservation; e.g., enmomcon = {k2 ®
p1 + p2 - k1}.

SetStandardMatrixElements should be invoked only once for a whole process. It is

8. Reference Guide for FeynCalc 115

most conveniently used in a separate specification batch file. In this file also the settings of
the scalar products should be done either directly and/or with SetMandelstam before applying

T
SetStandardMatrixElements. It is not necessary to predefine standard matrix elements.

See also: SetMandelstam, StandardMatrixelement.

Small

Small[me] is the head of a small mass me. The effect is that masses with this head are set to zero,
if they occur outside a Passarino-Veltman function.

SmallVariables

Spinor
AF
SmallVariables is an option for OneLoop.

The setting of SmallVariables is a list containing masses which are small compared to others.
If present the photon mass should always be listed.

Spinor[p, mass] specifies a Dirac spinor. Which of the spinors u, v, u or v is understood, de-
pends on the sign of the mass argument and the relative position of DiracSlash[p]: Spinor[p,
mass] is that spinor which yields mass*Spinor[p, mass] if the Dirac equation is applied to
DiracSlash[p] . Spinor[p, mass] or Spinor[p, mass] . DiracSlash[p].
If a spinor is multiplied by a Dirac matrix or another spinor, the multiplication operator "." must be
used.

See also: DiracSimplify.

StandardMatrixElement

StandardMatrixElement[...] is the head of the standard matrix elements. The standard

DR
matrix elements are a basis for the Feynman amplitude which contain the spinor structure and,
eventually, the dependence on the polarization vectors.
If SetStandardMatrixElements has been used to define abbreviations for the non com-
mutative and/or scalar-product structure, the arguments of StandardMatrixElement are
these abbreviations itself. Without invoking SetStandardMatrixElements the arguments of
StandardMatrixElement contain the basis for the amplitude, i.e., the non commutative struc-
ture and/or scalar-product structure.

SU3Delta
8. Reference Guide for FeynCalc 116

SU3Delta[a, b] is the Kronecker ∆ with color indices a and b.

T

SU3Delta[i, i] ® 8.

See also: SU3F, GellMannMatrix, GellMannTrace.

SU3F

SU3F[a, b, c] are the structure constants f abc of SU(3).

Only algebraic properties are implemented.

The following option can be given:

SU3FToTraces True replace f abc by i

4 (tr(Λa Λc Λb) - tr(Λa Λb Λc )).

Tr

SU3FToTraces

AF
See also: SU3Delta, GellMannMatrix, GellMannTrace.

SU3FToTraces is an option for SU3F.

Tr[expr] calculates the Dirac trace of expr directly. Tr is identical to DiracTrace up to the
default setting of DiracTraceEvaluate.

The following options can be given:

DiracTraceEvaluate True evaluating the trace

LeviCivitaSign -1 sign convention for the ¶-tensor
Factoring False factor the result
Mandelstam {} if set to {s, t, u, m1 ˆ2 + m2 ˆ2 + m3 ˆ2 + m4 ˆ2},
TrickMandelstam will be used
PairCollect True collect the results with respect to products of Pair
DR

See also: DiracTrace.

TrickMandelstam

TrickMandelstam[expr, {s, t, u, m1 ˆ2 + m2 ˆ2 + m3 ˆ2 + m4 ˆ2}] simplifies all sums

in expr in such a way that one of the Mandelstam variables s, t or u is eliminated by the rela-
2 2 2 2
tion s + t + u = m1 + m2 + m3 + m4 . The trick is that the resulting sum has the shortest number of
terms.

Example: TrickMandelstam[ s + t + u, {s,t,u,2 mwˆ2} ] ® 2 mwˆ2.

Write2
8. Reference Guide for FeynCalc 117

Write2[channel, val1 = expr1 , val2 = expr2 , ...] writes the settings val1 = expr1 , val2 =
expr2 in sequence followed by a newline, to the specified output channel.

T

The following options can be given:

FormatType InputForm in which language to write out to the result file

DOConvention 0 convention for scalar Passarino Veltman integrals

Other possible settings for FormatForm are FortranForm, MacsymaForm and MapleForm. Be

careful on the ouput when generating Fortran files. There might be problems like powers of ratios
of integers which you have to correct by hand. If the expressions contain variables in HoldForm,

True

False
"/usr/hep/weinberg/"
AF
their values are written out first, if the output language is Mathematica or Fortran.

WriteOut

WriteOut is an option for OneLoop, OneLoopSum.

Possible settings are:

write output into a file name, where name is the first argu-
ment of OneLoop
write no output
write result files in your local directory

WriteOutPaVe

WriteOutPave is an option for OneLoopSum. If set to a string the reduced PaVe are written into
the file indicated.
DR
$BreitMaison

$BreitMaison is a global variable determining whether the Breitenlohner-Maison scheme is used.

The default setting is False, which implies the ”naive” Γ5 prescription: Γ5 is assumed to
anticommute with Dirac matrices in all dimensions. If $BreitMaison is set to True,

Γ5 will anticommute with the four-dimensional part of a Dirac matrix and commute with the
(D-4)-dimensional part. Reset $PrePrint for experimenting with the Breitenlohner-Maison
scheme. $BreitMaison must be set to True before loading FeynCalc. The command is :
FeynCalc‘$BreitMaison = True. Not every operation has been tested thoroughly, there-

fore beware!
8. Reference Guide for FeynCalc 118

$MemoryAvailable

T
$MemoryAvailable is a global variable which is set to an integer n, where n is the available
amount of main memory in MB. The default is 8. It should be increased if possible. The higher
$MemoryAvailable can be, the more intermediate steps do not have to be repeated by FeynCalc.

$VeryVerbose

$VeryVerbose is a global variable with default setting 0. If set to 1, 2, ..., more and more

AF
intermediate comments and informations are displayed during calculations.
DR
8. Reference Guide for FeynCalc 119

T
AF
DR
 T
Bibliography

"FeynArts web site". AF

[1] , Steven Wolfram (2000),
"The Mathematica Book", Fourth edition,
Cambridge University Press,
"http://www.mathematica.com/".
[2] J. Küblbeck, M. Böhm and A. Denner, Comp. Phys. Comm. 60 (1990) 165.

[3] R. D. Drinkard and N. K. Sulinski, “Macsyma: A Program For Computer Algebraic Manipulation (Demon-
strations And Analysis),” NUSC-6401 "SPIRES entry".
[4] E. Yehudai and A. C. K. Hsieh, HIP — Symbolic High-Energy Physics Calculations,
SLAC-PUB- 5576 July 1991.
[5] O. V. Tarasov, “Generalized recurrence relations for two-loop propagator integrals with arbitrary masses,”
Nucl. Phys. B 502 (1997) 455 "arXiv:hep-ph/9703319".
[6] R. Mertig and R. Scharf, “TARCER: A mathematica program for the reduction of two-loop propagator
integrals,” Comput. Phys. Commun. 111 (1998) 265 "arXiv:hep-ph/9801383".
[7] J. Gasser and H. Leutwyler, “Chiral Perturbation Theory: Expansions In The Mass Of The Strange Quark,”
Nucl. Phys. B 250 (1985) 465.
DR
[8] G. ’t Hooft and M. J. Veltman, “Scalar One Loop Integrals,” Nucl. Phys. B 153 (1979) 365.
[9] A. Denner, Techniques for the Calculation of Electroweak Radiative Corrections at the One-Loop Level
and Results for W -Physics at LEP200, to appear in Fortschritte der Physik 1992, 41 and references therein.
[10] R. Mertig, M. Böhm, and A. Denner, Comp. Phys. Comm. 64 (1991) 345.
[11] Comp. Phys. Comm 77 (1993) 286-298
[12] G. J. van Oldenborgh, FF – a package to evaluate one-loop Feynman diagrams, Comp. Phys. Comm. 66
(1991) 1.
Z. Phys. C 46 (1990) 425,
"Scanned version from KEK".

120
Bibliography 121

[13] T. Hahn and M. Perez-Victoria, “Automatized one-loop calculations in four and D dimensions,” Comput.
Phys. Commun. 118 (1999) 153 "arXiv:hep-ph/9807565".

T
[14] P. Breitenlohner and D. Maison, Commun. Math. Phys. 52 (1977) 11.
[15] C. P. Martin and D. Sanchez-Ruiz, renormalization with a non-anticommuting gamma(5),” Nucl. Phys. B
572 (2000) 387 [arXiv:hep-th/9905076].
[16] P.Cvitanovic, Phys. Rev. D 14 (1976) 1536.
[17] A.P. Kryukov and A.Ya. Rodionov, Comp. Phys. Comm. 48 (1988) 327.
[18] Matthias Jamin and E. Lautenbacher, TRACER, A Mathematica Package for Γ-Algebra in Arbitrary Di-

AF
mensions, preprint Technische Universität München, TUM-T31-20/91.
[19] S. Wolfram, MACSYMA Tools for Feynman Diagram Calculations, Proceedings of the 1979 MACSYMA
Users Conference.
DR