FeynCalc 3.0 Manual

Tools for Feynman diagram calculations

Rolf Mertig

August 26, 1998

Copyright ©1998 
Mertig Research & Consulting
Oosterpark 77
NL-1092 AT Amsterdam
http://www.mertig.com

This notebook describes features of FeynCalc 3.0.5.1

Table of Contents

You can select the Cell bracket of this "Table of Contents" section and copy it to a new notebook which should be saved in the same directory as this one.
One possibility to jump back from a hyperlink is to use the "<<Back" button from the Help Browser.

Short Overview

Load FeynCalc

A0

Amplitudes

AnomalousDimension

Anti5

AntiCommutator

AntiQuarkField

Apart1

Apart2

Apart3

B00

B0

B11

B1

BackgroundGluonVertex

C0

Calc

CA

Cases2

CF

ChangeDimension

ChargeConjugationMatrixInv

ChargeConjugationMatrix

ChiralityProjector

Chisholm

Collect2

Combine

CommutatorExplicit

Commutator

ComplexConjugate

ComplexIndex

Contract

Convolute

CovariantD

D0

DataType

DeclareNonCommutative

DeltaFunction

DeltaFunctionPrime

Dimension

DiracGammaCombine

DiracGammaExpand

DiracGamma

DiracGammaT

DiracMatrix

DiracOrder

DiracReduce

DiracSigmaExplicit

DiracSigma

DiracSimplify

DiracSimplify2

DiracSlash

DiracTrace

DiracTrick

DotSimplify

EpsChisholm

EpsEvaluate

Epsilon

Eps

ExpandPartialD

ExpandScalarProduct

Explicit

ExplicitPartialD

Factor2

FAD

FCE

FCI

FermionSpinSum

FeynAmpDenominatorCombine

FeynAmpDenominator

FeynAmpDenominatorSimplify

FeynAmpDenominatorSplit

FeynAmp

FeynCalc2FORM

FeynCalcExternal

FeynCalcInternal

FeynRule

FieldStrength

FORM2FeynCalc

FourDivergence

FourLaplacian

FourVector

FreeQ2

FromTFi

FRH

FunctionalD

FVD

FV

GAD

GammaEpsilon

GammaExpand

GA

GhostPropagator

GHP

GaugeField

GluonGhostVertex

GluonPropagator

GluonVertex

GSD

GS

Hill

HypergeometricAC

HypergeometricIR

HypergeometricSE

HypExplicit

Integrate2

Integrate3

IntegrateByParts

InverseMellin

Isolate

Kummer

Lagrangian

LCD

LC

LeftPartialD

LeftRightPartialD

LeftRightPartialD2

LeviCivita

LorentzIndex

Map2

MetricTensor

MomentumCombine

MomentumExpand

Momentum

MTD

MT

Nielsen

NTerms

OneLoop

OneLoopSimplify

OPEDelta

OPEi, OPEj, OPEk, OPEl, OPEm, OPEn, OPEo

OPESumExplicit

OPESum

OPESumSimplify

Pair

PartialD

PaVe

PaVeOrder

PaVeReduce

PlusDistribution

Polarization

PolarizationSum

PolarizationVector

PowerSimplify

PropagatorDenominatorExplicit

PropagatorDenominator

QuantumField

QuarkField

QuarkGluonVertex

QuarkPropagator

RightPartialD

RussianTrick

ScalarProduct

ScalarProductCancel

SD

SelectFree

SelectNotFree

Series2

SimplifyDeltaFunction

SimplifyPolyLog

SOD

Solve2

SO

SPD

Spinor

SpinorUBar

SpinorU

SpinorVBar

SpinorV

SplittingFunction

SP

SumP

SumS

SumT

SUNDelta

SUND

SUNF

SUNIndex

SUNSimplify

SUNT

SUNTrace

Symmetrize

Tdec

Tensorfunction

TFi

TIDL

TID

ToDistribution

ToHypergeometric

ToLarin

ToTFi

TrickMandelstam

Trick

Tr

Twist2GluonOperator

Twist2QuarkOperator

Uncontract

UnDeclareNonCommutative

Write2

Evaluation time and memory usage

Short Overview

FeynCalc 3.0 is a Mathematica 3.0 package for algebraic calculations in high energy physics. Tools are provided for Lorentz index contraction, Dirac algebra manipulation, color factor calculation, automatic Feynman rule derivation, general noncommutative algebra as well as various look-up tables for Feynman parameter integrals, convolutions and Feynman rules. Furthermore special translation facilities are provided to change the FeynCalc syntax to and from FORM syntax. Optimized FORTRAN generation is possible by using Isolate  and Write2.

The more important functions for input of objects like (p^μ),(γ^ν),(g^(μ ν)), (ε^(μ ν ρ σ)), etc. (abbreviations in parentheses) are:
DiracMatrix (GA), DiracSlash (GS), FourVector (FV), LeviCivita (LC), MetricTensor (MT),  Spinor, SUNDelta, SUNF, ScalarProduct (SP).

The more important functions for manipulations are:

Contract, Tr, DiracSimplify, DiracTrick, Calc, Convolute, FeynRule , Integrate2 , FeynCalc2FORM ,PaVeReduce ,SimplifyPolyLog , SUNSimplify , Isolate , Collect2 , OneLoopSimplify , Series2 , ScalarProductCancel

FeynCalc 3.0 is still compatible with FeynArts 2.2 if the FeynArts function ToFA1Convention is used on the generated amplitudes. The functions OneLoop and OneLoopSum for calculation of Standard Model (like) 1-loop diagrams still work in FeynCalc 3.0 but they have not been developed much further compared to the FeynCalc 1.0 version. While OneLoop and OneLoopSum still work fine for selfenergy, triangle and box diagrams not too complicated the reader should be aware of the package FORMCalc which is more effective for the adventurous researcher calculating thousands of diagrams involving four external gauge bosons. Notice however that FORMCalc does not reduce the Passarino-Veltman integrals to scalar integrals. Also FORMCalc is limited to the 't Hooft Feynman gauge. FeynCalc 3.0 provides the possibility to reduce Passarino-Veltman integrals to scalar integrals algebraically by the function PaVeReduce .

On a Pentium II 300 Mhz computer with 64 MB of RAM running Mathematica 3.0 for Linux this noteboook needs about 11 minutes to evaluate and less than 16 MB of memory.

FeynCalc automatically loads any tarcer*.mx file from the  HighEnergyPhysics directory. 
For a description of TARCER see hep-ph/9801383 or the published version in Computer Physics Communications 111 (1998) 265-273.

For more detailed information concerning FeynCalc functions you can investigate most of the source code in the FeynCalc directory in the HighEnergyPhysics directory. The location of the HighEnergyPhysics directory is stored upon installation in the fc.m file and you can get its value from the global variable $FeynCalcDirectory. A complete list of FeynCalc objects is stored in the variable $FeynCalcStuff. Not all functions are documented in this notebook. Some are either very special ones (e.g. for tools for 2-loop QCD diagrams originating in twist-2 OPE) or still experimental.

The (γ^5)scheme used in OneLoop is the naive one, i.e., {(γ^5),(γ^μ))=0 in 4 and D dimensions. See also ToLarin

The metric used is the one from Bjorken and Drell (+---).

For suggestions please email the author: Rolf@Mertig.com.
Notice that usually no support is given. However, especially if you find bugs, send a repeatable clear example to the above email address.

Load FeynCalc

absolutestarttime=AbsoluteTime[]

This defines typesetting rules for q1 and q2:

q1/:MakeBoxes[q1,fmt_]:=SubscriptBox["q","1"];

q2/:MakeBoxes[q2,fmt_]:=SubscriptBox["q","2"];

Load FeynCalc:

<<HighEnergyPhysics`fc`

loading TARCER tarcer23.mx

FeynCalc 3.0.5.1. Type ?FeynCalc for help or visit www.mertig.com

loading TARCER tarcer23.mx

FeynCalc 3.0.5.0. Type ?FeynCalc for help or visit www.mertig.com

A0

Description

A0[m^2] isthePassarino-Veltmanone-point  integral  (Subscript[A, 0.])

Options[A0]

See also:  B0, C0, D0, PaVe.

Examples

By default any (Subscript[A, 0]) is expressed in terms of (Subscript[B, 0])'s.

A0[m^2]

A0[m^2,A0ToB0->False]

According to the rules of dimensional regularization (Subscript[A, 0])(0) is set to 0.

A0[0]

A0[SmallVariable[M^2]]

Amplitudes

Description

Amplitudes[name] is a database of Feynman amplitudes.
Gauge -> 1 means   `t Hooft Feynman gauge; Polarization -> 0 gives
unpolarized OPE-type   amplitudes, Polarization -> 1 the polarized ones.

Options[Amplitudes]

See also:  FeynAmp.

Examples

This is the amplitude of a gluon selfenergy diagram.

Amplitudes["se1g1"]

Explicit[%]

This is the amplitude for graph 6.2 from the paper Z.Phys C 70:637-654, 1996.

FeynAmp[q1,q2,	EpsEvaluate[Trick[Explicit[Amplitudes["gg2"]]]]]

AnomalousDimension

Description

AnomalousDimension[name] is a database of anomalous dimensions of twist-2 
operators.

Options[AnomalousDimension]

See also:  SplittingFunction.

Examples

Polarized case

SetOptions[ AnomalousDimension,Polarization->1]

(Subscript[γ, NS,qq ]^((0) ))polarized

AnomalousDimension[gnsqq0]

(Subscript[γ, S,qg ]^((0) ))polarized

AnomalousDimension[gsqg0]

(Subscript[γ, S,gq ]^((0) ))polarized

AnomalousDimension[gsgq0]

(Subscript[γ, S,gg ]^((0) ))polarized

AnomalousDimension[gsgg0]

(Subscript[γ, PS,qq ]^((0) ))polarized

AnomalousDimension[gpsqq1]

(Subscript[γ, NS,qq ]^((1) ))polarized

AnomalousDimension[gnsqq1]

(Subscript[γ, S,qg ]^((1) ))polarized

AnomalousDimension[gsqg1]

(Subscript[γ, S,gq ]^((1) ))polarized

AnomalousDimension[gsgq1]

(Subscript[γ, S,gg ]^((1) ))polarized

AnomalousDimension[gsgg1]

(Subscript[γ, S,gg ]^((1) ))polarized (different representation)

AnomalousDimension[GSGG1]

Check that all odd moments give the same for the two representations of (Subscript[γ, S,gg ]^((1) )).

Table[(%-%%)/.OPEm->ij, {ij,1,17,2}]

Anti5

Description

Anti5[exp] anticommutes all (γ^5)in exp to the right. Anti5[exp, n] anticommutes all (γ^(5 ))n times to the right.
Anti5[exp, -n] anticommutes all (γ^5) n times to the left.

The naive (γ^5)scheme is used.

See also:  DiracOrder, DiracSimplify, DiracTrick.

Examples

DiracMatrix[5,μ]

Anti5[%]

Anti5[%,-1]

DiracMatrix[5,α,β,γ,δ]

Anti5[%,2]

Anti5[%%,Infinity]

Anti5[%,-Infinity]

In the naive γ^5-scheme D-dimensional γ-matrices anticommute with γ^5.

GAD[5,μ]

Anti5[%]

Setting the global variable $FCT to False restores the default typesetting 
rules for the noncommutative multiplication operator Dot[].

$FCT = False;

GAD[5,μ]

Anti5[%]

$FCT = True;

AntiCommutator

Description

AntiCommutator[x, y] = c  defines the anti-commutator of the non commuting 
objects x and y.

See also:  Commutator, CommutatorExplicit, DeclareNonCommutative, DotSimplify.

Examples

This declares a and b as  noncommutative variables.

DeclareNonCommutative[a,b]

AntiCommutator[a,b]

CommutatorExplicit[%]

CommutatorExplicit[AntiCommutator[a+b,a-2b ]]

DotSimplify[AntiCommutator[a+b,a-2b ]]

DeclareNonCommutative[c,d,(OverTilde[c]),(OverTilde[d])]

Defining {c,d} = z results in replacements of c.d by z-d.c.

AntiCommutator[c,d] = z

DotSimplify[ d . c .  d ]

AntiCommutator[(OverTilde[d]),(OverTilde[c])] = (OverTilde[z])

DotSimplify[ (OverTilde[d]) . (OverTilde[c]) .  (OverTilde[d]) ]

UnDeclareNonCommutative[a,b,c,d,(OverTilde[c]),(OverTilde[d])]

AntiCommutator[c,d]=.

AntiCommutator[(OverTilde[d]),(OverTilde[c])]=.

AntiQuarkField

Description

AntiQuarkField is the name of a fermionic field. AntiQuarkField is just a 
name with no functional properties. Only typeset rules are attached.

See also:  QuantumField, QuarkField.

Examples

AntiQuarkField

Apart1

Description

Apart1[expr, x] is equivalent to Apart[expr, x], but it is faster than Apart 
if explicit complex numbers (I's) are in exp.

See also:  Apart2, Apart3.

Examples

t = 1/4*(1 - x)^4*x*(21 + 13*x + 3*x^2) - 
1/24*11*I*Pi*(1 - x)^4*x*(21 + 13*x + 3*x^2) + 
((1 - x)^4*x^2*(21 + 13*x + 3*x^2))/(36*(-1 + x)^4) - 
(I*Pi*(1 - x)^4*x^2*(21 + 13*x + 3*x^2))/
(12*(-1 + x)^4) - (7*(1 - x)^4*x^3*(21 + 13*x + 3*x^2))/ (48*(-1 + x)^4) + (3*I*Pi*(1 - x)^4*x^3*
(21 + 13*x + 3*x^2))/(8*(-1 + x)^4) + 
(11*(1 - x)^4*x^4*(21 + 13*x + 3*x^2))/(24*(-1 + x)^4) - 
(3*I*Pi*(1 - x)^4*x^4*(21 + 13*x + 3*x^2))/
(4*(-1 + x)^4) - (49*(1 - x)^4*x^5*(21 + 13*x + 3*x^2))/
(144*(-1 + x)^4) + (11*I*Pi*(1 - x)^4*x^5*
(21 + 13*x + 3*x^2))/(24*(-1 + x)^4) + 
1/4*(1 - x)^4*x*(21 + 13*x + 3*x^2)*Zeta2 + 
11/24*(1 - x)^4*x*(21 + 13*x + 3*x^2)*Log[x] + 
1/4*I*Pi*(1 - x)^4*x*(21 + 13*x + 3*x^2)*Log[x] + 
((1 - x)^4*x^2*(21 + 13*x + 3*x^2)*Log[x])/
(12*(-1 + x)^4) - (3*(1 - x)^4*x^3*(21 + 13*x + 3*x^2)*
Log[x])/(8*(-1 + x)^4) + 
(3*(1 - x)^4*x^4*(21 + 13*x + 3*x^2)*Log[x])/
(4*(-1 + x)^4);

Timing[a1=Apart1[t,x];]

Timing[a2=Apart[t,x];]

a1-a2//Expand

Clear[t,a1,a2]

Apart2

Description

Apart2[expr] partial fractions FeynAmpDenominators (and FAD's).

See also:  FAD, FeynAmpDenominator.

Examples

FAD[{q,m},{q,M},q-p]

Apart2[%]

InputForm[FCE[%]]

Apart3

Description

Apart3[expr, x] is equivalent to Map2[Factor2, Collect2[Apart1[expr,x],x]].

See also:  Apart1.

Examples

t=1/4 (1-x)^4 x (21+13 x+3 x^2)-11/24 I π (1-x)^4 x (21+13 x+3 x^2)+((1-x)^4 x^2 (21+13 x+3 x^2))/(36 (-1+x)^4)-(I π (1-x)^4 x^2 (21+13 x+3 x^2))/(12 (-1+x)^4)-(7 (1-x)^4 x^3 (21+13 x+3 x^2))/(48 (-1+x)^4)+(3 I π (1-x)^4 x^3 (21+13 x+3 x^2))/(8 (-1+x)^4)+(11 (1-x)^4 x^4 (21+13 x+3 x^2))/(24 (-1+x)^4)-(3 I π (1-x)^4 x^4 (21+13 x+3 x^2))/(4 (-1+x)^4)-(49 (1-x)^4 x^5 (21+13 x+3 x^2))/(144 (-1+x)^4)+(11 I π (1-x)^4 x^5 (21+13 x+3 x^2))/(24 (-1+x)^4)+1/4 (1-x)^4 x (21+13 x+3 x^2) Zeta2+11/24 (1-x)^4 x (21+13 x+3 x^2) Log[x]+1/4 I π (1-x)^4 x (21+13 x+3 x^2) Log[x]+((1-x)^4 x^2 (21+13 x+3 x^2) Log[x])/(12 (-1+x)^4)-(3 (1-x)^4 x^3 (21+13 x+3 x^2) Log[x])/(8 (-1+x)^4)+(3 (1-x)^4 x^4 (21+13 x+3 x^2) Log[x])/(4 (-1+x)^4);

Timing[a1=Apart3[t,x];]

Timing[a2=Apart[t,x];]

a1-a2//Expand

Clear[t,a1,a2]

B00

Description

B00[pp,(Subscript[m, 1]^2),(Subscript[m, 2]^2)] is the Passarino - Veltman (Subscript[B, 00])-function, i.e., the coefficient function of g^(μν). All arguments are scalars and have dimension  mass(^2).

Options[B00]

See also:  B0, B1, PaVe.

Examples

Remember that SP[p] is a short hand input for ScalarProduct[p,p], i.e. p^2.

SP[p]

B00[SP[p],m^2,M^2]

B00[SP[p],m^2,m^2]

B00[SP[p],m^2,M^2,BReduce->False]

B00[0,m^2,m^2]

B00[SmallVariable[M^2],m^2,m^2]

B0

Description

B0[p^2,(Subscript[m, 1]^2),(Subscript[m, 2]^2)] is the Passarino - Veltman two-point integral (Subscript[B, 0]). All arguments are scalars and have dimension mass^2.
If the option   BReduce is set to True certain B0's are reduced to A0's.
Setting the option   B0Unique to True simplifies B0[a,0,a] and B0[0,0,a].

Options[B0]

See also:  B1, B00, B11, PaVe.

Examples

B0[SP[p,p],m^2,m^2]

SetOptions[B0,B0Unique->True,B0Real->True];

B0[0,0,m^2]

B0[m^2,0,m^2]

B0[0,m^2,m^2]

B11

Description

B11[pp,(Subscript[m, 1]^2),(Subscript[m, 2]^2)] is the Passarino - Veltman (Subscript[B, 11])-function, i.e., the coefficient function of p^μp^ν. All arguments are scalars and have dimension  mass(^2).

Options[B11]

See also:  B0, B00, B1, PaVe.

Examples

Remember that SP[p] is a short hand input for ScalarProduct[p,p], i.e. p^2.

SP[p]

B11[SP[p],m^2,M^2]

B11[SP[p],m^2,m^2]

SetOptions[B11,BReduce->False]

B11[SP[p],m^2,M^2]

SetOptions[B11,BReduce->True]

B11[0,m^2,m^2]

B11[SmallVariable[M^2],m^2,m^2]

B1

Description

B1[p^2,(Subscript[m, 1]^2),(Subscript[m, 2]^2)] is the Passarino - Veltman (Subscript[B, 1])-function. All arguments are scalars and have dimension mass^2.

Options[B1]

See also:  B0, B00, B11, PaVe, PaVeReduce.

Examples

B1[SP[p],m^2,M^2]

B1[SP[p],m^2,M^2,BReduce->False]

SetOptions[B1,BReduce->True];

B1[SP[p],m^2,m^2]

B1[m^2,m^2,0]

B1[0,0,m^2]

B1[pp,SmallVariable[(Subscript[m, e]^2)],(Subscript[m, 2]^2)]

B1[SmallVariable[(Subscript[m, e]^2)],SmallVariable[(Subscript[m, e]^2)],0]

BackgroundGluonVertex

Description

BackgroundGluonVertex[{p,μ,a}, {q,ν,b}, {k,λ,c}] or 
BackgroundGluonVertex[ p,μ,a ,  q,ν,b ,  k,λ,c ] yields the   3-gluon vertex in the background field gauge, where the first set of   arguments corresponds to the external background field. 
BackgroundGluonVertex[{p,μ,a}, {q,ν,b}, {k,λ,c},   {s,σ,d}]  or
BackgroundGluonVertex[{μ,a}, {ν,b},   {λ,c}, {σ,d}] or  
BackgroundGluonVertex[p,μ,a ,    q,ν,b ,  k,λ,c ,  s,σ,d] or  
BackgroundGluonVertex[   μ,a ,  ν,b ,  λ,c ,  σ,d ] yields the  4-gluon vertex,   with {p,μ,a} and {k,λ,c} denoting the external background  fields. 
The gauge, dimension  and the name of the coupling constant are  determined  by the options Gauge, Dimension and CouplingConstant.
The  Feynman rules are  taken from L.Abbot NPB 185 (1981), 189-203;  except that all momenta are incoming. Note that   Abbots coupling constant convention is consistent with the default setting of   GluonVertex.

Options[BackgroundGluonVertex]

See also:  GluonVertex.

Examples

BackgroundGluonVertex[{p,μ,a},{q,ν,b},{k,λ,c}]

BackgroundGluonVertex[{p,μ,a},{q,ν,b},{k,λ,c},{s,σ,d}]

BackgroundGluonVertex[{p,μ,a},{q,ν,b},{k,λ,c},Gauge->α]

BackgroundGluonVertex[{p,μ,a},{q,ν,b},{k,λ,c},{s,σ,d},Gauge->α]

C0

Description

C0[p10, p12, p20, m1^2, m2^2, m3^2] is the scalar Passarino - Veltman (Subscript[C, 0])function.  The convention for the arguments is that if the denominator of  the integrand has the form ([q^2-m1^2] [(q+p1)^2-m2^2] [(q+p2)^2-m3^2]), the  first three arguments of C0 are the scalar products p10 = p1^2, p12 =  (p1-p2).(p1-p2), p20 = p2^2.

See also:  B0, D0, PaVe, PaVeOrder.

Examples

C0[a,b,c, m12,m22,m32]

C0[b,a,c,m32,m22,m12]//PaVeOrder

PaVeOrder[C0[b,a,c,m32,m22,m12],PaVeOrderList->{c,a}]

Calc

Description

Calc[exp] performs several basic simplifications. 
Calc[exp] is the same as 
DotSimplify[DiracSimplify[Contract[DiracSimplify[Explicit[ 
SUNSimplify[Trick[exp],  Explicit->False] ]]]]]

See also:  DiracSimplify, DiracTrick, Trick.

Examples

This calculates γ^μ(Subscript[γ, μ]) in 4 dimensions and (Subscript[g, ν]^ν) in D dimensions.

Calc[{GA[μ,μ], MTD[ν,ν]}]

This simplifies (Subscript[f, abc]) (Subscript[f, abe]).

Calc[SUNF[a,b,c] SUNF[a,b,e]]

FV[p+r,μ] MT[μ,ν] FV[q-p,ν]

Calc[%]

GluonVertex[p,1,q,2,-p-q,3]

Calc[% FVD[p,li1] FVD[q,li2] FVD[-p-q,li3]]

CA

Description

CA is one of the Casimir operators of SU(N) (CA = N).

See also:  CF, SUNSimplify.

Examples

CA

SUNSimplify[CA,SUNNToCACF->False]

SUNN

Cases2

Description

Cases2[expr, f] returns a list of all objects in expr with head f.
Cases2[expr,f] is equivalent to Cases2[{expr},f[___],Infinity]//Union.
Cases2[expr, f, g, ...] or Cases2[expr, {f,g, ...}] is equivalent to 
Cases[{expr},f[___] | g[___] ...] .

Examples

Cases2[f[a]+f[b]^2+f[c,d],f]

Cases2[Sin[x] Sin[y-z]+g[y],Sin,g]

Cases2[Sin[x] Sin[y-z]+g[x]+g[a,b,c],{Sin,g}]

Cases2[DiracSlash[p].DiracSlash[q]+ScalarProduct[p,p],Dot]

CF

Description

CF is one of the Casimir operators of SU(N) (CF = (N^2-1)/(2 N)).

See also:  CA, SUNSimplify.

Examples

CF

SUNSimplify[CF, SUNNToCACF -> False]

SUNN

SUNSimplify[CF, SUNNToCACF ->True]

ChangeDimension

Description

ChangeDimension[exp, dim] changes all LorentzIndex and Momenta in exp to 
dimension dim (and also Levi-Civita-tensors, Dirac slashes and Dirac 
matrices).

See also:  LorentzIndex, Momentum, DiracGamma, Eps.

Examples

Remember that LorentzIndex[μ, 4]  is simplified to LorentzIndex[μ]   and Momentum[p, 4] to Momentum[p]. Thus the fullowing objects are defined in   four dimensions.

{LorentzIndex[μ], Momentum[p]}

ChangeDimension[%, D]

%//InputForm

This changes all non-4-dimensional objects to 4-dimensional ones.

ChangeDimension[%%, 4] // InputForm

Consider the following list of 4- and D-dimensional object.

{GA[μ,ν] MT[μ,ν], GAD[μ,ν] MTD[μ,ν] f[D]}

DiracTrick[Contract[%]]

DiracTrick[Contract[ChangeDimension[%%,n]]]

Any explicit occurence of D (like in f(D)) is not replaced by 
ChangeDimension.

SetOptions[LeviCivita,Dimension->D];

The option Dimension of Eps must be changed too, since with the default 
setting Dimension->4 the arguments of Eps are automatically changed to 4 
dimensions.

SetOptions[Eps,Dimension->D];

a1 = LeviCivita[μ,ν,ρ,σ]

a2 = ChangeDimension[a1,4]

Contract[a1^2]  // Factor2

Contract[a2^2]

SetOptions[Eps,Dimension->4];

Clear[a1,a2];

ChargeConjugationMatrixInv

Description

ChargeConjugationMatrixInv is the inverse of  ChargeConjugationMatrix.
It is substituted immediately by -ChargeConjugationMatrix.

See also:  ChargeConjugationMatrix.

Examples

ChargeConjugationMatrix.DiracMatrix[μ].ChargeConjugationMatrixInv

Calc[%]

ChargeConjugationMatrix.DiracGamma[5].ChargeConjugationMatrixInv

Calc[%]

ChargeConjugationMatrix.ChargeConjugationMatrixInv

%//Calc

ChargeConjugationMatrixInv^2

ChargeConjugationMatrix

Description

ChargeConjugationMatrix denotes the charge conjugation matrix C.

See also:  ChargeConjugationMatrixInv.

Examples

ChargeConjugationMatrix.DiracMatrix[μ].ChargeConjugationMatrixInv

Calc[%]

ChargeConjugationMatrix.DiracGamma[5].ChargeConjugationMatrixInv

Calc[%]

ChargeConjugationMatrix^2

ChiralityProjector

Description

ChiralityProjector[+1] denotes 1/2(1+(γ^5)).
ChiralityProjector[-1] denotes 1/2(1+(γ^5)).

See also:  DiracGamma, DiracMatrix, FCI.

Examples

{ChiralityProjector[+1],ChiralityProjector[-1]}

FCI[%]

DiracSimplify[%,DiracSubstitute67->True]

Chisholm

Description

Chisholm[x] substitutes products of three Dirac matrices or slashes by the 
Chisholm identity.

See also:  EpsChisholm.

Examples

Chisholm[GA[α,β,μ,ν]]

t1=DiracMatrix[μ,ν,ρ]

t2 =Chisholm[t1]

The $MU$ variables are unique indices.

Calc[t1.t1]

t3 =Chisholm[t1]

Calc[t2.t3]

t4=DiracSlash[a,b,c]

Chisholm[t4]

a1=GA[μ,ν,ρ,σ,τ,κ]

a2 =Chisholm[a1]

a3 =Chisholm[a1]

Check that both a1.a1 and a2.a3 give the same.

Calc[a1.a1]

Calc[a2.a3]

Clear[t1,t2,t3,t4,a1,a2,a3]

Collect2

Description

Collect2[expr, x] collects together terms which are not free of any 
occurrence of x. 
Collect2[expr, {x1, x2, ...}]  (or also Collect2[expr, x1, x2,  ...]) 
collects together terms which are not free of any occurrence  of x1, x2, .... 
The coefficients are put over a common denominator.  If expr is expanded 
before collecting depends on the option  Factoring, which may be set to 
Factor, Factor2, or any other function, which is applied to the coefficients. 
If expr is already expanded with respect to x (x1,x2, ...), the  option 
Expanding can be set to False.

Options[Collect2]

See also:  Isolate.

Examples

Collect2[ t1=a+ra+k^2 f[a]-k f[a]+x/2-y/w,a]

Collect2[t1,a,Factoring->False]

Collect2[t1,a,Factoring->Factor]

Collect2[2a (b-a) (h-1) - b^2 (ea - c) +b^2, {a,b}]

Collect2[Expand[(a-b-c-d)^5],a,IsolateNames->L]

ReleaseHold[%]

Clear[t1,L]

Collect2[Expand[(a-b-c)^3],a,Factoring->fun]

% /. fun->FactorTerms

Combine

Description

Combine[expr]puts terms in a sum over a common denominator,and cancels 
factors in the result. Combine is similar to Together, but accepts the option 
Expanding and works usually better than Together for polynomials involving 
rationals with sums in the denominator.

Options[Combine]

See also:  Factor2.

Examples

Combine[ (a-b) (c-d)/e + g ]

Here the result from Together where the numerator is automatically 
expanded.

Together[ (a-b) (c-d)/e + g ]

If the option Expanding  is set to True, the result of Combine is the same as 
Together, but uses a slightly different algorithm.

Combine[((a-b) (c-d))/e+g,Expanding->True]

CommutatorExplicit

Description

CommutatorExplicit[exp] substitutes any Commutator and AntiCommutator  in exp by their definitions.

See also:  Calc, DotSimplify.

Examples

DeclareNonCommutative[a,b,c,d]

Commutator[a,b]

CommutatorExplicit[%]

AntiCommutator[a-c,b-d]

CommutatorExplicit[%]

CommutatorExplicit[%%]//DotSimplify

UnDeclareNonCommutative[a,b,c,d]

Commutator

Description

Commutator[x, y] = c  defines the commutator between the non-commuting 
objects x and y.

See also:  AntiCommutator, CommutatorExplicit, DeclareNonCommutative, DotSimplify.

Examples

DeclareNonCommutative[a,b,c,d]

Commutator[a,b]

CommutatorExplicit[%]

DotSimplify[Commutator[a+b,c+d]]

UnDeclareNonCommutative[a,b,c,d]

Verify the Jacobi identity.

χ=Commutator;  DeclareNonCommutative[x,y,z];

χ[x,χ[y,z]]+χ[y,χ[z,x]]+χ[z,χ[x,y]]

DotSimplify[%]

Clear[χ]

UnDeclareNonCommutative[x,y,z]

ComplexConjugate

Description

ComplexConjugate[expr] complex conjugates expr. 
It operates on fermion lines, i.e., products of Spinor[..] .DiracMatrix[..] . Spinor[..], and changes all 
occuring LorentzIndex[mu] into LorentzIndex[ComplexIndex[mu]].
For taking the spin sum (i.e. constructing the traces) use 
FermionSpinSum. 
WARNING: In expr should be NO explicit I's in denominators!

See also:  ComplexIndex, FermionSpinSum, LorentzIndex.

Examples

ComplexConjugate[MetricTensor[μ,ν]]

InputForm[%]

GA[μ,ν,5]

ComplexConjugate[%]

SUNTrace[SUNT[a,b,c]]

ComplexConjugate[%]

ComplexConjugate[SUNF[a,b,c]]

ComplexConjugate[MetricTensor[μ,ν]]//FCE//InputForm

SpinorUBar[k1,m].GA[λ].SpinorU[p1,m]

ComplexConjugate[%]

Notice that SpinorUBar and SpinorU are only input functions. Internally they   are converted to Spinor objects (which display as φ).

ComplexIndex

Description

ComplexIndex is the head of a "complex conjugate index", which is 
understood as just another index.

See also:  LorentzIndex.

Examples

LorentzIndex[μ]

ComplexConjugate[%]

%//InputForm

FourVector[p,μ]

ComplexConjugate[%]

%//InputForm

ComplexConjugate[%]

Contract

Description

Contract[expr] contracts pairs of Lorentz indices of metric tensors, 
four-vectors and (depending on the optionEpsContract) of Levi-Civita tensors 
in expr. For the contraction of Dirac matrices with each other use 
DiracSimplify.  Contract[exp1, exp2] contracts (exp1*exp2), where exp1 and 
exp2 may be larger products of sums of  metric tensors and 4-vectors.

Options[Contract]

See also:  Pair, DiracSimplify, MomentumCombine.

Examples

MetricTensor[μ,ν] FourVector[p,μ]

Contract[%]

FourVector[p,μ]DiracMatrix[μ]

Contract[%]

MetricTensor[μ,μ]

The default dimension for MetricTensor is 4.

Contract[%]

A short way to enter D-dimensional metric tensors is given by MTD.  The "." as multiplication operator  is not necessary  but just convenient  for typesetting.

MTD[μ,ν] . MTD[μ,ν]

Contract[%]

MTD[μ,ν] . MTD[μ,ν]

FourVector[p,μ] FourVector[q,μ]

Contract[% ]

FourVector[p-q,μ] FourVector[a-b,μ]

Contract[%]

LeviCivita[μ,ν,α,σ] FourVector[p,σ]

Contract[%]

LeviCivita[μ,ν,α,β] LeviCivita[μ,ν,α,σ]

Contract[%]

SetOptions[Eps,Dimension->D];LCD[μ,ν,α,β] LCD[μ,ν,α,σ]

Contract[%]//Factor2

SetOptions[Eps,Dimension->4];

Convolute

Description

Convolute[f, g, x] convolutes f(x) and g(x), i.e., 
(∫_0^1)(Subscript[dx, 1]) (∫_0^1)(Subscript[dx, 2]) δ(x - (Subscript[x, 1]) (Subscript[x, 2])) f((Subscript[x, 1])) g((Subscript[x, 2])) .
Convolute[f, g] is equivalent to Convolute[f, g, x].
Convolute[exp,   {x1, x2}] assumes that exp is polynomial in x1 and x2.
Convolute uses   table-look-up and does not do any integral calculations, only linear   algebra.

Options[Convolute]

See also:  PlusDistribution.

Examples

Convolute[1,1]

Convolute[x,x]

Convolute[1,x]

Convolute[1,1/(1-x)]

Convolute[1,PlusDistribution[1/(1-x)]]

Convolute[1/(1-x),x]

Convolute[1/(1-x),1/(1-x)]

Convolute[1,Log[1-x]]

Convolute[1,x Log[1-x]]

Convolute[1/(1-x),Log[1-x]]

Convolute[1/(1-x),x Log[1-x]]

Convolute[Log[1-x]/(1-x),x]

Convolute[1,x Log[x]]

Convolute[Log[1-x],x]

Convolute[1/(1-x),Log[x]/(1-x)]

Convolute[1,Log[x]]

Convolute[x, x Log[x]]

Convolute[1/(1-x),Log[x]]

Convolute[1,Log[x]/(1-x)]

Convolute[1/(1-x),x Log[x]]

Convolute[Log[x]/(1-x),x]

Convolute[1,x Log[x]]

Convolute[Log[x],x]

Convolute[1/(1-x),Log[1-x]/(1-x)]

CovariantD

Description

CovariantD[μ, a, b] is the covariant derivative for a bosonic field.
CovariantD[μ] is the covariant derivative for a fermionic field.
CovariantD[OPEDelta, a, b]  is a short form for
CovariantD[mu,a,b]*FourVector[OPEDelta, mu].
CovariantD[{OPEDelta, a, b},   {n}] yields the product of m operators., where n is an integer.
CovariantD[OPEDelta, a, b, {m, n}] gives the expanded form of
CovariantD[OPEDelta, a, b]^m up to order
g^n for the gluon, where n is an   integer and g the couplingconstant indicated by the setting of the option   CouplingConstant.
CovariantD[OPEDelta, {m, n}] gives the expanded form of
CovariantD[OPEDelta]^m up to order g^n of the fermionic field.

Options[CovariantD]

Possible settings of PartialD are: 
LeftPartialD, LeftRigthPartialD, RightPartialD.
The default setting of QuantumField is GaugeField.

See also:  LeftPartialD, LeftRightPartialD, RightPartialD.

Examples

CovariantD[μ]

CovariantD[μ,a,b]

CovariantD[μ,Explicit->True]

The first argument of CovariantD is intepreted as type LorentzIndex, except for OPEDelta, which is type Momentum.

CovariantD[OPEDelta]

CovariantD[OPEDelta,a,b]

CovariantD[OPEDelta,a,b,Explicit->True]

CovariantD[OPEDelta,Explicit->True]

CovariantD[OPEDelta,a,b,{2}]

This gives m times (Subscript[(∂^→), Δ]), the partial derivative (Subscript[(∂^→), μ ])contracted with (Δ^μ).

CovariantD[OPEDelta,a,b,{OPEm,0}]

The expansion up to first order in the coupling constant  (Subscript[g, s]) (thesumistheFeynCalcOPESum).

CovariantD[OPEDelta,a,b,{OPEm,1}]

The expansion up to second order in the (Subscript[g, s]).

CovariantD[OPEDelta,a,b,{OPEm,2}]

CovariantD[OPEDelta,a,b]^OPEm

CovariantD[OPEDelta,{OPEm,2}]

CovariantD[OPEDelta,Explicit->True]//InputForm

CovariantD[μ,a,b,Explicit->True]//InputForm

D0

Description

D0[ p10, p12, p23, p30, p20, p13,  m1^2, m2^2, m3^2, m4^2 ] is the 
Passarino-Veltman (Subscript[D, 0]) function. The convention for the arguments is that if the denominator of  the integrand has the form ([q^2-m1^2] [(q+p1)^2-m2^2] [(q+p2)^2-m3^2]  [(q+p3)^2-m4^2] ), the first six arguments of D0 are the 
scalar products  p10 = p1^2, p12 = (p1-p2)^2, p23 = (p2-p3)^2, p30 = p3^2, p20 = p2^2, p13 =  (p1-p3)^2.

See also:  B0, C0, PaVe, PaVeOrder.

Examples

D0[p10,p12,p23,p30,p20,p13,m1^2,m2^2,m3^2,m4^2]

PaVeOrder[D0[p10,p12,p23,p30,p20,p13,m1^2,m2^2,m3^2,m4^2],PaVeOrderList->{p13,p20}]

PaVeOrder[%]

DataType

Description

DataType[exp, type] = True   defines the object exp to have data-type type.
DataType[exp1, exp2, ..., type] defines the objects exp1, exp2, ...to have 
data-type type. The default setting is DataType[__, _] := False. To assign a 
certain data-type, do, e.g., DataType[x, PositiveInteger] = True.

See also:  DeclareNonCommutative.

Examples

NonCommutative is just a data-type.

DataType[f,g, NonCommutative] = True;

t=f.g-g.(2a).f

Since "f "and "g" have DataType NonCommutative the function DotSimplify 
extracts only "a" out of the noncommutative product.

DotSimplify[t]

DataType[m,odd]=DataType[a,even]=True;

ptest1[x_]:=x/.(((-1))^(n_))/;DataType[n,odd]:>-1;

ptest2[x_]:=x/.(((-1))^(n_))/;DataType[n,even]:>1;

t=(-1)^m+(-1)^a+(-1)^z

ptest1[t]

ptest2[%]

Clear[ptest1,ptest2,t,a,m];

DataType[m,ganzeZahl]=True;

f[x_]:=x/.{(-1)^p_/;DataType[p,ganzeZahl]:>1};

test=(-1)^m+(-1)^n x

f[test]

Clear[f,test];

DataType[f,g, NonCommutative] = False;

DataType[m,odd]=DataType[a,even]=False;

Certain FeynCalc objects have DataType PositiveInteger set to True.

DataType[OPEm,PositiveInteger]

PowerSimplify uses the DataType information.

PowerSimplify[ (-1)^(2OPEm)]

PowerSimplify[ (- SO[q])^OPEm]

DeclareNonCommutative

Description

DeclareNonCommutative[a, b, ...] declares a,b, ... to be  non-commutative, 
i.e., DataType[a,b, ..., NonCommutative] is set to  True.

See also:  DataType, UnDeclareNonCommutative.

Examples

DeclareNonCommutative[x]

As a side effect of DeclareNonCommutative x is declared to be of data type NonCommutative.

DataType[x,NonCommutative]

DeclareNonCommutative[y,z]

DataType[a,x,y,z,NonCommutative]

UnDeclareNonCommutative[x,y,z]

DataType[a,x,y,z,NonCommutative]

DeltaFunction

Description

DeltaFunction[x] is the Dirac delta-function δ(x).

See also:  Convolute, DeltaFunctionPrime, Integrate2, SimplifyDeltaFunction.

Examples

DeltaFunction[1-x]

Integrate2[DeltaFunction[1-x] f[x],{x,0,1}]

Integrate2[DeltaFunction[x] f[x],{x,0,1}]

Integrate2[DeltaFunction[1-x] f[x],{x,0,1}]

Convolute[DeltaFunction[1-x],x]

DeltaFunctionPrime

Description

DeltaFunctionPrime[1-x] is the derivative of the Dirac δ-function.

See also:  Convolute, DeltaFunction, Integrate2.

Examples

DeltaFunctionPrime[1-x]

Integrate2[DeltaFunctionPrime[1-x] f[x],{x,0,1}]

Integrate2[DeltaFunctionPrime[1-x] x^2,{x,0,1}]

Dimension

Description

Dimension is an option of several functions and denotes the space-time 
dimension. Possible settings are:  4, n, d, D, ...  (the variable does not 
matter, but it should have head Symbol).

DiracGammaCombine

Description

DiracGammaCombine[exp] is (nearly) the inverse operation to DiracGammaExpand.

See also:  DiracGamma, DiracGammaExpand, DiracMatrix, DiracSimplify, DiracSlash, DiracTrick.

Examples

DiracGammaCombine[GS[p] + GS[q]]

InputForm[%]

DiracGammaCombine[2 GS[p] - 2  GS[q]]

InputForm[%]

DiracGammaExpand[%%]

DiracGammaExpand

Description

DiracGammaExpand[exp] expands all DiracGamma[Momentum[a+b+..]] in exp into (DiracGamma[Momentum[a]] + DiracGamma[Momentum[b]] + ...).

See also:  DiracGamma, DiracGammaCombine, DiracMatrix, DiracSimplify, DiracSlash, DiracTrick.

Examples

t=DiracGamma[Momentum[q]] . DiracGamma[Momentum[p-q]]

Momentum is the head of p-q, i.e., it is treated as one four-momentum.

InputForm[t]

With DiracGammaExpand the Momentum[p-q] gets expanded.

DiracGammaExpand[t]

The inverse operation is DiracGammaCombine.

InputForm[DiracGammaCombine[DiracGammaExpand[t]]]

InputForm[DiracGammaExpand[t]]

In order to do non-commutative expansion use DiracSimplify.

DiracSimplify[t]

Clear[t]

DiracGamma

Description

DiracGamma[x, dim] is the head of all Dirac matrices and slashes (in the internal   representation). Use DiracMatrix (or GA, GAD) and DiracSlash (or GS, GSD) for   manual (short) input. 
DiracGamma[x, 4] simplifies to DiracGamma[x].
DiracGamma[5] isγ^5. 
DiracGamma[6] is (1+γ^5)/2.
DiracGamma[7] is (1-γ^5)/2.

See also:  DiracGammaExpand, DiracMatrix, DiracSimplify, DiracSlash, DiracTrick.

Examples

DiracGamma[5]

DiracGamma[LorentzIndex[α]]

γ·q denotes q/ (= γ^μ(Subscript[q, μ])).

DiracGamma[Momentum[q]]

DiracGamma[Momentum[q]] . DiracGamma[Momentum[p-q]]

DiracGamma[Momentum[q,D],D]

a1=GS[p-q].GS[p]

a2=DiracGammaExpand[a1]

a3=GAD[μ].GSD[p-q].GSD[q].GAD[μ]

a4=DiracTrick[a3]

a5=DiracSimplify[a4]

Clear[a1,a2,a3,a4,a5]

DiracGammaT

Description

DiracGammaT[x] denotes the transpose of DiracGamma[x].  
Transpose[DiracGammaT[x]] gives DiracGamma[x]. Note that x must have Head LorentzIndex or Momentum.

See also:  DiracGamma.

Examples

DiracGammaT[LorentzIndex[μ]]

Transpose[%]

GS[p]//FCI//Transpose

DiracMatrix

Description

DiracMatrix[μ] denotes a Dirac γ matrix with Lorentz index  μ.
DiracMatrix[μ,ν ..] is a product of γ matrices with  Lorentz indices μ, ν, etc.
DiracMatrix[5] is (γ^5).
DiracMatrix[6] is 1/2 +  (γ^5)/2.
DiracMatrix[7] is 1/2 -  (γ^5)/2.

See also:  DiracGammaExpand, DiracGamma, DiracSimplify, DiracSlash, DiracTrick, GA, GAD, GS, GSD.

Examples

DiracMatrix[μ]

DiracMatrix[μ].DiracMatrix[ν]

DiracMatrix[α]//InputForm

DiracMatrix[μ]//FCE

%//InputForm

GAD[μ]

%//FCI//InputForm

GA[μ,ν,ρ]

DiracOrder

Description

DiracOrder[expr] orders the Dirac matrices in expr alphabetically. 
DiracOrder[expr,orderlist] orders the Dirac matrices in expr according to 
orderlist.

See also:  DiracSimplify, DiracTrick.

Examples

t1 = GA[β,α]

DiracOrder[t1]

This is a string of Dirac matrices in D dimensions.

t2=GAD[μ,ν,μ]

DiracOrder[t1]

t3=GA[5,μ,ν]

By default γ^5 ismovedtothe right.

DiracOrder[t3]

t4=GA[6,μ,7]

DiracOrder[t4]

t5=GA[α,β,δ]

This orders the γ^αγ^βγ^δ in reverse order.

DiracOrder[t5,{δ,β,α}]

DiracOrder[%]

Clear[t1,t2,t3,t4,t5]

DiracReduce

Description

DiracReduce[exp] reduces all four-dimensional Dirac matrices in exp to the 
standard basis (S,P,V,A,T) using the Chisholm identity (see Chisholm). In the 
result the basic Dirac structures are wrapped with a head  DiracBasis. I.e.,
S corresponds to DiracBasis[1],  
P : DiracBasis[DiracMatrix[5]],
V: DiracBasis[DiracMatrix[mu]], 
A: DiracBasis[DiracMatrix[mu, 5]], 
T: DiracBasis[DiracSigma[DiracMatrix[mu, nu]]]. 
By default DiracBasis is substituted to Identity. Notice that the result of 
DiracReduce is given in the FeynCalcExternal - way, i.e.,evtl. you may have to use FeynCalcInternal on the result.

Options[DiracReduce]

See also:  DiracSimplify.

Examples

t1 = GA[μ,ν]

DiracReduce[t1]

t2 = DiracMatrix[μ,ν,ρ]

DiracReduce[t2]

t3 = DiracMatrix[μ,ν,ρ,σ]

t4 = DiracReduce[t3]

t5 =Calc[DiracSimplify[DiracSigmaExplicit[t4.t4]]]

Calc[t4.t4]

Clear[t1,t2,t3,t4]

DiracSigmaExplicit

Description

DiracSigmaExplicit[exp] inserts in exp for all  DiracSigma its definition. 
DiracSigmaExplict is also an option of DiracSimplify.

See also:  DiracSigma.

Examples

DiracSigma[GA[α],GA[β]]

DiracSigmaExplicit[%]

DiracSigma

Description

DiracSigma[a, b] stands for i/2*(a . b - b . a) in 4 dimensions.  a and b must have Head DiracGamma, DiracMatrix or DiracSlash. Only antisymmetry is implemented.

See also:  DiracSigmaExplicit.

Examples

t1 = DiracSigma[GA[α],GA[β]]

DiracSigmaExplicit[t1]

t2 = DiracSigma[GA[β],GA[α]]

t3 = DiracSigma[GS[p],GS[q]]

DiracSigmaExplicit[t3]

Clear[t1,t2,t3]

DiracSimplify

Description

DiracSimplify[expr]   simplifies products of Dirac matrices in expr and 
expands non-commutative products. Double Lorentz indices and four vectors are contracted. The Dirac equation is applied.
All DiracMatrix[5], DiracMatrix[6] and DiracMatrix[7] are moved to the right. The order of the other Dirac matrices is not changed.

Options[DiracSimplify]

See also:  Calc, DiracGammaExpand, DiracSimplify.

Examples

This is a string of Dirac matrices in four dimensions.

t1=GA[μ,ν,μ]

DiracSimplify[t1]

This is a string of Dirac matrices in D dimensions.

t2=GAD[μ,ν,μ]

DiracSimplify[t1]

t3=GA[5,μ,ν]

By default γ^5 ismovedtothe right.

DiracSimplify[t3]

t4=GA[6,μ,7]

DiracSimplify[t4]

t5=GS[a+b] . GS[p].GS[p].GS[c+d]

Contrary to DiracTrick DiracSimplify does non-commutative expansion.

DiracSimplify[t5]

DiracTrick[t5]

t6 = SpinorVBar[p] . GS[p] . SpinorUBar[q]

DiracSimplify[t6]

GAD@@Join[{μ},Table[(Subscript[ν, i]),{i,6}],{μ}]

DiracSimplify[%]

With the option DiracCanonical an alphabetic ordering is done.

DiracSimplify[GA[ν,μ],DiracCanonical->True]

Setting InsideDiracTrace->True assumes that a trace is still to be   taken (later).

DiracSimplify[GA[μ,ν,ρ,σ],InsideDiracTrace->True]

DiracSimplify[GA[μ,ν,ρ],InsideDiracTrace->True]

Clear[t1,t2,t3,t4,t5,t6]

DiracSimplify2

Description

DiracSimplify2[exp] simplifies the Dirac structure but leaves any (γ^5) untouched.

See also:  DiracSimplify.

Examples

GAD[μ,ν,μ,5,α,β,α]

DiracSimplify2[%]

DiracSlash

Description

DiracSlash[p] is the contraction p^μ(Subscript[γ, μ]) (FourVector[p, μ] DiracMatrix[μ]).  Products of those can be   entered in the form DiracSlash[p1, p2, ...].

Options[DiracSlash]

See also:  DiracGammaExpand, DiracGamma, DiracMatrix, DiracSimplify, DiracTrick, GS, GSD.

Examples

This is q/  (= γ^μ(Subscript[q, μ])).

DiracSlash[q]

DiracSlash[p].DiracSlash[q]

DiracSlash[p,q]

GS[p]

DiracSlash[q]//InputForm

DiracSlash[q,Dimension->n]//InputForm

DiracTrace

Description

DiracTrace[expr] is the head of Dirac Traces. Whether the trace is  evaluated depends on the option DiracTraceEvaluate. Direct trace evaluation is 
performed by Tr. The argument expr may be a product of Dirac matrices or 
slashes separated by the Mathematica Dot ".".

Options[DiracTrace]

For comments regarding γ^5schemes see the notes for Tr.

See also:  Tr.

Examples

DiracTrace[GA[μ,ν]]

DiracTrace[GA[μ,ν,ρ,σ]]

% /. DiracTrace->Tr

DiracTrace[GA[μ,ν,ρ,σ,5],DiracTraceEvaluate->True]

DiracTrace[GA[μ,ν,ρ,σ,δ,τ,5],DiracTraceEvaluate->True]

DiracTrace[GS[p,q,r,s]]

DiracTrace[GA[μ,ν],DiracTraceEvaluate->True,FCE->True]

%//InputForm

DiracTrick

Description

DiracTrick[exp] contracts  γ-matrices with each other and performs   several simplifications (no expansion, use Calc or DiracSimplify for this).

Options[DiracTrick]

See also:  Calc, DiracGammaExpand, DiracSimplify.

Examples

This is a string of Dirac matrices in four dimensions.

t1=GA[μ,ν,μ]

DiracTrick[t1]

This is a string of Dirac matrices in D dimensions.

t2=GAD[μ,ν,μ]

DiracTrick[t2]

t3=GA[5,μ,ν]

By default γ^5 ismovedtothe right.

DiracTrick[t3]

t4=GA[6,μ,7]

DiracTrick[t4]

t5=GS[a+b] . GS[p].GS[p].GS[c+d]

DiracTrick[t5]

Calc[t5]

GAD@@Join[{μ},Table[(Subscript[ν, i]),{i,6}],{μ}]

DiracTrick[%]

DotSimplify

Description

DotSimplify[expr] expands and reorders noncommutative terms in expr.  
Simplifying relations may be specified by the option DotSimplifyRelations or by Commutator and AntiCommutator definitions. 
Whether expr is expanded noncommutatively depends on the option Expanding.

Options[DotSimplify]

See also:  AntiCommutator, Commutator, Calc.

Examples

t1=GA[μ].(2 GS[p]-GS[q]).GA[ν]

DotSimplify[t1]

DeclareNonCommutative[a,b,c]

t2=a.(b-z c).a

DotSimplify[t2]

Commutator[a,c]=1

DotSimplify[t2]

Commutator[a,c]=.

DotSimplify[t2]

AntiCommutator[b,a]=c

DotSimplify[t2]

AntiCommutator[b,a]=.

DotSimplify[t2,DotSimplifyRelations->{a.c->1/z}]

DeclareNonCommutative[x]

DotSimplify[x.x.x]

DotSimplify[x.x.x,DotPower->False]

UnDeclareNonCommutative[a,b,c,x]

EpsChisholm

Description

EpsChisholm[expr] substitutes for a gamma matrix contracted with a Levi 
Civita tensor (Eps) the Chisholm identity.

See also:  Chisholm.

Examples

Chisholm[GA[μ,ν,ρ,σ]]

EpsChisholm[%]

EpsEvaluate

Description

EpsEvaluate[expr] applies total antisymmetry and linearity (w.r.t. 
Momentum's)  to all Levi-Civita tensors (Eps') in expr.

See also:  Contract, Eps, LeviCivita, Trick.

Examples

Trick[LeviCivita[μ,ν,ρ,σ] FourVector[p+q,σ]]

EpsEvaluate[%]

InputForm[%]

Epsilon

Description

Epsilon is (n-4), where n is the space-time dimension. Epsilon stands for a small positive number.

See also:  Series2.

Examples

Epsilon

Epsilon has no functional properties, but some upvalues are changed:

{Re[Epsilon] > -4,Re[Epsilon] > -3,Re[Epsilon] > -2,Re[Epsilon] > -1,Re[Epsilon] > 0}

Eps

Description

Eps[a, b, c, d] is the head of the totally antisymmetric ϵ -   (Levi-Civita) tensor. The a,b, ... may have head LorentzIndex, Momentum or   Integer. In case of integers the Levi-Civita tensor is evaluated immediately.

Options[Eps]

See also:  EpsEvaluate, LC, LCD, LeviCivita.

Examples

Eps[LorentzIndex[μ],LorentzIndex[ν],LorentzIndex[ρ],LorentzIndex[σ]]

Eps[Momentum[p],LorentzIndex[ν],LorentzIndex[ρ],LorentzIndex[σ]]

Eps[b,a,c,d]//InputForm

Eps[0,1,2,3]

Eps[1,0,2,3]

SetOptions[Eps,Dimension->4];

a1 =Eps[LorentzIndex[μ,D],LorentzIndex[ν,D],LorentzIndex[ρ,D],LorentzIndex[σ,D]]

Contract[a1a1]

SetOptions[Eps,Dimension->D];

a2 =Eps[LorentzIndex[μ,D],LorentzIndex[ν,D],LorentzIndex[ρ,D],LorentzIndex[σ,D]]

Contract[a2a2]//Factor2

g5 = -I/24 LCD[μ,ν,ρ,α] .  GAD[μ,ν,ρ, α]//FCI

g5p = -I/24 LCD[μ',ν',ρ',α'] . 
 GAD[μ',ν', ρ',α']//FCI

g52 = Calc[g5 . g5p]//Factor2

g52/.D->4

Clear[a1,a2,g5,g5p]

ExpandPartialD

Description

ExpandPartialD[exp] expands all products of QuantumField's and partial differentiation operators in exp and applies Leibniz rule.

See also:  ExplicitPartialD, LeftPartialD, LeftRightPartialD, RightPartialD.

Examples

RightPartialD[μ].QuantumField[A,LorentzIndex[μ]].QuantumField[A,LorentzIndex[ν]]

ExpandPartialD[%]

%//InputForm

LeftRightPartialD[μ].QuantumField[A,LorentzIndex[ν]]

ExpandPartialD[%]

QuantumField[A,LorentzIndex[μ]].(LeftRightPartialD[OPEDelta]^2).QuantumField[A,LorentzIndex[ρ]]

ExpandPartialD[%]

8  LeftRightPartialD[OPEDelta]^3

ExplicitPartialD[%]

ExpandPartialD[%]

LeviCivita[μ,ν,ρ,τ] RightPartialD[α,μ,β,ν]

ExpandPartialD[%]

ExpandScalarProduct

Description

ExpandScalarProduct[expr]  expands scalar products of sums of momenta in expr.  ExpandScalarProduct does not use Expand on expr.

See also:  Calc.

Examples

SP[p,p-q]

ExpandScalarProduct[%]

FV[p-q,μ]

ExpandScalarProduct[%]

SP[p-q,q-r]//FCI

%/.Pair->ExpandScalarProduct

Explicit

Description

Explicit is an option for FieldStrength, GluonVertex, SUNF, and 
Twist2GluonOperator. 
If set to True the full form of the operator is inserted. Explicit[exp] 
inserts explicit expressions of GluonVertex and Twist2GluonOperator in exp. SUNF's are replaced by SUNTrace objects.

See also:  GluonVertex, Twist2GluonOperator.

Examples

GluonVertex[p,μ,a, q,ν,b,r,ρ,c]

Explicit[%]

Twist2GluonOperator[p,μ,a,ν,b]

Explicit[%]

FieldStrength[μ,ν,a]

Explicit[%]

ExplicitPartialD

Description

ExplicitPartialD[exp] inserts in exp the definition for LeftRightPartialD[z] 
(and LeftRightPartialD2[z]).

See also:  ExpandPartialD, LeftRightPartialD, LeftRightPartialD2.

Examples

ExplicitPartialD[ LeftRightPartialD[μ] ]

ExplicitPartialD[ LeftRightPartialD2[μ] ]

ExplicitPartialD[ LeftRightPartialD[OPEDelta] ]

16 LeftRightPartialD[OPEDelta]^4

Factor2

Description

Factor2[poly] factors a polynomial in a standard way. Factor2 works 
(sometimes) better than Factor on polynomials  involving rationals with sums in the denominator. Factor2 uses Factor internally and is in general slower 
than Factor. There are four possible settings of the option Method (0,1,2,3). 
In general Factor will work faster than Factor2.

Options[Factor2]

See also:  Collect2.

Examples

t1=(a-x)(b-x)

t2={Factor2[t1], Factor[t1]}

t3=Expand[(a-b)(a+b)]

Factor[t3]

Factor2[t3]

Factor2[t3,FactorFull->True]

Clear[t1,t2,t3]

FAD

Description

FAD  is the FeynCalc external form of FeynAmpDenominator and denotes an inverse propagator.
FAD[q, q-p, ...] is 1/(q^2 (q-p)^2 ...). 
FAD[{q1,m}, {q1-p,m}, q2, ...]  is  1/( (q1^2 - m^2) ( (q1-p)^2 - m^2 ) q2^2 
... ).  
Translation into FeynCalc internal form is performed by FeynCalcInternal.

See also:  FAD, FCE, FCI, FeynAmpDenominator, FeynAmpDenominatorSimplify, PropagatorDenominator.

Examples

FAD[q,p-q]

FAD[p,{p-q,m}]

FAD[q,p-q]//FCI//FCE//InputForm

FAD[q,p-q]//FCI//InputForm

FAD[p] FAD[p-q] // FeynAmpDenominatorCombine//InputForm

FCE

Description

FCE[exp] translates exp from the internal FeynCalc representation to a short form.

FCE is equivalent to FeynCalcExternal.

See also:  FeynCalcExternal, FCI, FeynCalcInternal.

Examples

FCE[{DiracGamma[5],DiracGamma[Momentum[p]]}]

%//InputForm

{GA[μ],GAD[ρ],GS[p],SP[p,q],MT[α,β],FV[p,μ]}

%//InputForm

%//FCI

%//InputForm

FCE[%]//InputForm

FCI

Description

FCI[exp] translates exp into the internal FeynCalc (datatype-)representation.

FCI is equivalent to FeynCalcInternal.

See also:  FeynCalcExternal, FeynCalcInternal, FCE.

Examples

{GA[μ],GAD[ρ],GS[p],SP[p,q],MT[α,β],FV[p,μ]}

%//InputForm

%//FCI

%//InputForm

FCE[%]//InputForm

FermionSpinSum

Description

FermionSpinSum[x] constructs the Traces out of squared ampliudes.

Options[FermionSpinSum]

See also:  ComplexConjugate, DiracTrace, Tr.

Examples

t=Spinor[k1,m].DiracSlash[p].GA[5].Spinor[p1,m]

Notice that SpinorUBar and SpinorU are only input functions. Internally they   are converted to Spinor objects (which display as φ).

ct=ComplexConjugate[t]

FermionSpinSum[t ct]

% /.DiracTrace->Tr

FeynAmpDenominatorCombine

Description

FeynAmpDenominatorCombine[expr] expands expr with respect to 
FeynAmpDenominator and combines products of FeynAmpDenominator in expr into one FeynAmpDenominator.

See also:  FeynAmpDenominatorSplit.

Examples

t = FAD[q] FAD[q-p]

FeynAmpDenominatorCombine[%]//FCE//InputForm

FeynAmpDenominatorSplit[%]//FCE//InputForm

FeynAmpDenominator

Description

FeynAmpDenominator[ PropagatorDenominator[ ... ], PropagatorDenominator[ ... ], ...] is the head of the denominators of the propagators, i.e., FeynAmpDenominator[x] is the representation of 1/x .

See also:  FAD, FeynAmpDenominatorSimplify.

Examples

FeynAmpDenominator[PropagatorDenominator[p,m]]

FeynAmpDenominator[PropagatorDenominator[p,m],	PropagatorDenominator[p-q,m]]

t=FeynAmpDenominator[PropagatorDenominator[p,m]];

InputForm[t//FCI]

InputForm[t//FCE]

Clear[t];

FeynAmpDenominatorSimplify

Description

FeynAmpDenominatorSimplify[exp]  tries to simplify each PropagatorDenominator in a canonical way. FeynAmpDenominatorSimplify[exp, q1] simplifies all FeynAmpDenominator's in exp in a canonical way,  including some translation of momenta. FeynAmpDenominatorSimplify[exp, q1, q2] additionally removes integrals with no mass scale.

FDS can be used as an alias.

FDS

See also:  OneLoopSimplify.

Examples

The cornerstone of dimensional regularization is that ∫d^nk f(k)/k^(2m) = 0 .

FeynAmpDenominatorSimplify[f[k] FAD[k,k],k]

This brings 1/((k-(Subscript[p, 1]))^2 (k-(Subscript[p, 2]))^2) into a standard form.

FeynAmpDenominatorSimplify[FAD[k-(Subscript[p, 1]),k-(Subscript[p, 2])],k]

t=FeynAmpDenominatorSimplify[FAD[k-(Subscript[p, 1]),k-(Subscript[p, 2])] SPD[k,k],k]

r=SPC[t,k,FDS->True]

OneLoopSimplify[r,k]

FDS[FAD[k-p1,k-p2]SPD[k,OPEDelta]^2,k]

Clear[t,r]

FeynAmpDenominatorSplit

Description

FeynAmpDenominatorSplit[expr] splits all FeynAmpDenominator[a,b, ...] in expr into FeynAmpDenominator[a]*FeynAmpDenominator[b] ... .
FeynAmpDenominatorSplit[expr, q1] splits all FeynAmpDenominator in expr into a product of two, one containing q1 and other momenta, the second without q1.

See also:  FeynAmpDenominatorCombine.

Examples

t=FAD[q1,q1-p,q1-q2,q2,q2-p]//FCI

t//Head

FeynAmpDenominatorSplit[t]

%//FCE//InputForm

FeynAmpDenominatorSplit[t,q1]//FCE//InputForm

FeynAmpDenominatorCombine[%]//FCE//InputForm

Clear[t]

FeynAmp

Description

FeynAmp[q, amp] is the head of a Feynman amplitude. amp denotes the 
analytical expression for the amplitude and q is the integration variable. 
FeynAmp[q1, q2, amp] denotes a two-loop amplitude.

FeynAmp has no functional properties and serves just as a head. There are 
however special typesetting rules attached.

See also:  Amplitudes.

Examples

Cell["This is a 1-loop gluon selfenergy amplitude.", 
  "Text"]

FeynAmp[q,GV[p,μ,a, q-p,α,c, -q,β,e] GP[p-q, α,c, ρ,d]GV[-p,ν,b, p-q,ρ,d, q,σ,f]  GP[q, β,e, σ,f]]

This is a generic 2-loop amplitude.

FeynAmp[(Subscript[q, 1]),(Subscript[q, 2]),anything goes]

FeynCalc2FORM

Description

FeynCalc2FORM[expr] displays expr in FORM syntax. 
FeynCalc2FORM[file, x] writes x in FORM syntax to a file.
FeynCalc2FORM[file, x==y] writes x=y to a file in FORM syntax.

See also:  FORM2FeynCalc.

Options[FeynCalc2FORM]

Examples

MT[μ,ν]FV[p,ρ]  y^2/d

FeynCalc2FORM[%];

LC[α,β,δ,ρ]

FeynCalc2FORM[%];

DiracTrace[GA[μ,ν,ρ,σ]]

FeynCalc2FORM[%];

DiracTrace[GA[μ,ν]]DiracTrace[GA[μ,ρ]]

FeynCalc2FORM[%];

FeynCalc2FORM["fc2ftest.f",MT[μ,ν]FV[p,μ]];

TableForm[ReadList["fc2ftest.f",String]]

t=Tr[GA[μ,ν,ρ,σ].GS[p,q]]

FeynCalc2FORM["fc2ftest.f",L ==t];

TableForm[ReadList["fc2ftest.f",String]]

If[FileNames["fc2ftest.f"],DeleteFile["fc2ftest.f"]];

FeynCalcExternal

Description

FeynCalcExternal[exp] translates exp from the internal FeynCalc 
representation to a shorthand form.

See also:  FeynCalcInternal.

Examples

FeynCalcExternal[DiracGamma[5]]

%//InputForm

{GA[μ],GAD[ρ],GS[p],SP[p,q],MT[α,β],FV[p,μ]}

%//InputForm

%//FeynCalcInternal

%//InputForm

FeynCalcExternal[%]//InputForm

FeynCalcInternal

Description

FeynCalcInternal[exp] translates exp into the internal FeynCalc  (abstract 
data-type) representation.

See also:  FeynCalcExternal, FCI, FCE.

Examples

{GA[μ],GAD[ρ],GS[p],SP[p,q],MT[α,β],FV[p,μ]}

%//InputForm

%//FeynCalcInternal

%//InputForm

FeynCalcExternal[%]//InputForm

FCI[{SD[a,b],SUND[a,b,c],SUNF[a,b,c],FAD[q],LC[μ,ν,ρ,σ]}]

%//InputForm

FeynRule

Description

FeynRule[lag, {fields}] derives the Feynman rule corresponding to the field 
configuration fields of the lagrangian lag.

Options[FeynRule]

FeynRule does  not calculate propagator Feynman rules.

The option ZeroMomentumInsertion can be used for twist-2 and higher twist operators.

See also:  Lagrangian.

Examples

gou = Lagrangian["ogu"]

gop = Lagrangian["ogp"]

Explicit[gop]

Cases2[%,QuantumField]//InputForm

2-gluon Feynman rules (unpolarized)

fi = {QuantumField[GaugeField,{μ},{a}][p],
        QuantumField[GaugeField,{ν},{b}][q]}

f2u=FullSimplify /@ Factor2[FeynRule[gou,fi,ZeroMomentumInsertion->False]]

2-gluon Feynman rules (polarized)

fi={QuantumField[GaugeField,{μ},{a}][p],QuantumField[GaugeField,{ν},{b}][q]}

f2p=FullSimplify/@Factor2[FeynRule[gop,fi,ZeroMomentumInsertion->False]]

Factor2[Calc[f2p/.p->-q]]

Compare with the Feynman rule tabulated in Twist2GluonOperator.

Twist2GluonOperator[q,{μ,a},{ν,b},	Polarization->1,Explicit->True]

quark-quark Feynman rule (unpolarized)

qo =Lagrangian["oqu"]

This is the list of the fermionic fields, with p and q are flowing into the vertex.

qf = {QuantumField[QuarkField][p],
      QuantumField[AntiQuarkField][q]}

For non-zero momentum insertion it is essential to let the partial derivative 
operator act on both sides. This can be achieved by setting the option 
PartialD to LeftRightPartialD.

n2 =FeynRule[qo,qf,ZeroMomentumInsertion->False,PartialD->LeftRightPartialD]

PowerSimplify[%]

For q  =-p this reduces to the zero-momentum insertion Feynman rule.

Calc[n2/.q->-p]

This can also be derived directly.

FeynRule[qo,Reverse[qf],ZeroMomentumInsertion->True]

quark-quark -gluon Feynman rule (unpolarized)

qo=Lagrangian["oqu"]

qgf = {QuantumField[QuarkField][p],
       QuantumField[AntiQuarkField][q],  
       QuantumField[GaugeField,{μ},{a}][r]}

n3=FeynRule[qo,qgf,ZeroMomentumInsertion->False,PartialD->LeftRightPartialD]

Trick[OPESumSimplify[Trick[Calc[n3/.r->-p-q]]]]

Twist2QuarkOperator[{p},{q},{r,μ,a},Polarization->0]

quark-quark -gluon Feynman rule (polarized)

qp=Lagrangian["oqp"]

qgf = {QuantumField[QuarkField][p],
       QuantumField[AntiQuarkField][q],  
       QuantumField[GaugeField,{μ},{a}][r]}

n3=FeynRule[qp,qgf,ZeroMomentumInsertion->False,PartialD->LeftRightPartialD]

Trick[OPESumSimplify[Trick[Calc[n3/.r->-p-q]]]]

Twist2QuarkOperator[{p},{q},{r,μ,a},Polarization->1]

quark-quark -gluon-gluon Feynman rule (unpolarized)

qo=Lagrangian["oqu"]

qggf = {QuantumField[QuarkField][p],
        QuantumField[AntiQuarkField][q], 
        QuantumField[GaugeField,{μ},{a}][r],
        QuantumField[GaugeField,{ ν},{b}][s]}

n4=FeynRule[qo,qggf,ZeroMomentumInsertion->True]

t4=Twist2QuarkOperator[{p},{q},{r,μ,a},{s,ν,b},Polarization->0]

Calc[(n4-t4)/.OPEm->5/.s->-p-q-r/.D->4]

In general equality can be shown by Timing[Factor2[
 FCE[Calc[ChangeDimension[FCE[OPESumExplicit[n4-t4]],4]/.s->-p-q-r]]]]
 but it is a little bit slow ...

QCD vertices

fii={QuantumField[GaugeField,{μ},{a}][p],     QuantumField[GaugeField,{ν},{b}][q],     QuantumField[GaugeField,{ρ},{c}][r]}

g3=FeynRule[Lagrangian["QCD"],fii]

GluonVertex[{p,μ,a},{q,ν,b},{r,ρ,c},Explicit->True]

Calc[g3-ChangeDimension[%,4]]

fi4 ={QuantumField[GaugeField,{μ},{a}][p],               QuantumField[GaugeField,{ν},{b}][q],               QuantumField[GaugeField,{ρ},{c}][r],    	      QuantumField[GaugeField,{σ},{d}][s]}

g4 =FeynRule[Lagrangian["QCD"],fi4]

GluonVertex[{p,μ,a},{q,ν,b},{r,ρ,c},{s,σ,d},Explicit->True]

Calc[g4-ChangeDimension[%,4]]

Clear[f2p,f2u,f3,f32,fi,fi4,fii,g3,g4,gop,gou,n3,nf3,np2,npf3,p33,pf3,pn3,pqo,qf,qgf,qo,t4]

FieldStrength

Description

FieldStrength[μ, ν, a] is the field strength tensor 
(∂_μ)(Subscript[A, ν]^a)-(∂_ν)(Subscript[A, μ]^a)+(Subscript[g, s]) (Subscript[A, μ]^b1)(Subscript[A, ν]^c1) f^(ab1c1). 
FieldStrength[μ, ν]   is the field strength tensor (∂_μ)(Subscript[A, ν]^)-(∂_ν)(Subscript[A, μ]^).
The name of the field (A) and the coupling constant (g)  can be set   through the options or by additional arguments.
The first two indices are   interpreted as type LorentzIndex, except OPEDelta, which is converted to   Momentum[OPEDelta].

Options[FieldStrength]

See also:  QuantumField.

Examples

FieldStrength[μ,ν]

FieldStrength[μ,ν,a]

FieldStrength[μ,ν,Explicit->True]

FieldStrength[μ,ν,a,Explicit->True]

InputForm[FieldStrength[μ,ν,Explicit->True]]

InputForm[FieldStrength[μ,OPEDelta,Explicit->True]]

FieldStrength[μ,ν,a,CouplingConstant->-Gstrong,Explicit->True]

FORM2FeynCalc

Description

FORM2FeynCalc[expr] translates the FORM expr into FeynCalc notation. 
FORM2FeynCalc[file]  translates the FORM expresssions in file into FeynCalcnotation. FORM2FeynCalc[file, x1, x2, ...] reads in a file in  FORM-format and translates the assignments for the variables a, b, ... into FeynCalc syntax. If the option Set is True,  the variables x1, x2 are assigned to the  right hand sides defined in the FORM - file.

See also:  FeynCalc2FORM.

Options[FORM2FeynCalc]

Examples

FORM2FeynCalc["p.q + 2*x m^2"]

%//InputForm

Functions are automatically converted right, but bracketed expressions need to be substituted explicitly.

FORM2FeynCalc["x +f(z)+ log(x)^2+[li2(1-x)]",Replace->{"[li2(1-x)]"->"PolyLog[2,1-x]"}]

%//InputForm

FORM2FeynCalc["x + [(1)]*y "]

FORM2FeynCalc["p(mu)*q(nu)+d_(mu,nu)"]

%//InputForm

FORM2FeynCalc["p(mu)*q(nu)+d_(mu,nu)",Replace->{mu->μ,nu->ν}]

FORM2FeynCalc["i_*az*bz*aM^2*D1*[(1)]*b_G1 * ( 4*eperp(mu,nu)*avec.bvec*blam \n\n)"]

FourDivergence

Description

FourDivergence[exp, FourVector[p, mu]] calculates the partial derivative of exp w.r.t. p(mu). FourDivergence[exp, FourVector[p, mu], FourVector[p,nu],  ...]gives the multiple derivative.

See also:  RussianTrick.

Examples

t=ScalarProduct[p,q]

FourDivergence[t,FourVector[q,μ]]

t=ScalarProduct[p-k,q]

FourDivergence[t,FourVector[k-p,μ]]

Clear[t]

FourLaplacian

Description

FourLaplacian[exp, p, q] is ∂/∂(Subscript[p, μ]) ∂/∂(Subscript[q, μ]) exp.

Options[FourLaplacian]

See also:  FourDivergence, RussianTrick.

Examples

SP[q,q]

FourLaplacian[%,q,q]

SOD[q]^OPEmFAD[q,q-p]//FCI

FourLaplacian[%,q, q]

FourVector

Description

FourVector[p, μ] is the four-dimensional vector p with Lorentz index  μ. 
A vector with space-time Dimension D is obtained by supplying the option Dimension -> D.

See also:  FV, FVD, Pair.

Examples

FourVector[p,μ]

FourVector[p-q,μ]

InputForm[FourVector[p,μ]]

InputForm[FourVector[p,μ,Dimension->D]]

InputForm[FCE[FourVector[p,μ]]]

There is no special function to expand momenta in FourVector. 
Since FourVector is turned into Pair internally ExpandScalarProduct may be used.

ExpandScalarProduct[FourVector[p-q,μ]]

FreeQ2

Description

FreeQ2[expr, {form1, form2, ...}] yields True if expr does not contain any occurence of form1, form2, ... and False otherwise. 
FreeQ2[expr, form] is the same as FreeQ[expr, form].

See also:  SelectFree, SelectNotFree.

Examples

FreeQ2[x+f[x]+y, {a,x}]

FreeQ2[x+f[x]+y,{a,b}]

FreeQ2[x, y]

FreeQ2[f[x], f]

FromTFi

Description

FromTFi[expr, q1, q2, p] translates the TFi notatation from the TARCER package to the usual FeynCalc notation.  See TFi for details on the conventions.

See also:  TFi, ToTFi.

Examples

FAD[q1,q1-p,{q2,M},{q2-p,m},q1-q2]//ToTFi

FromTFi[TFi[D,SPD[p,p],SOD[p],{{1,0},{1,M},{1,0},{1,m},{1,0}}],q1,q2,p]

FromTFi[TFi[D,SPD[p,p],SOD[p],{0,1},{{1,m},{1,M},{1,0},{1,m},{1,0}}],q1,q2,p]

FRH

Description

FRH[exp_] := FixedPoint[ReleaseHold, exp], i.e., FRH removes all HoldForm and Hold in exp.

See also:  Isolate.

Examples

Hold[1-1 - Hold[2-2]]

FRH[%]

Isolate[Solve[x^3-x-1==0],x,IsolateNames->H]

FRH[H[3]]

FunctionalD

Description

FunctionalD[expr, {QuantumField[name, {μ}, {a}][p], ...}] calculates the functional derivative of expr with respect to the field list (with  incoming momenta p, etc.) and does the fourier transform.
FunctionalD[expr, {QuantumField[name, {μ},{a}], ...}] calculates the  functional derivate and does partial integration but omits the x-space delta  functions.

FunctionalD is a low level function used in FeynRule.

See also:  FeynRule, QuantumField.

Examples

Instead of the usual δϕ(x)/δϕ(y)=δ^(D)(x-y) the arguments and the δ function are omitted, i.e., for the  program for simplicity: δϕ/δϕ=1

FunctionalD[QuantumField[ϕ],QuantumField[ϕ]]

FunctionalD[QuantumField[ϕ]^2,QuantumField[ϕ]]

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) -(Subscript[(∂^→), μ]).

FunctionalD[QuantumField[PartialD[μ],ϕ],QuantumField[ϕ]]

S[ϕ] =1/2∫ d^Dx [ (∂_μ)ϕ(x)  ∂^μϕ(x)-m^2ϕ(x)  ϕ(y)]

s[ϕ]=(QuantumField[PartialD[μ],ϕ].QuantumField[PartialD[μ],ϕ]-m^2 QuantumField[ϕ].QuantumField[ϕ])/2

FunctionalD[s[ϕ],QuantumField[ϕ]]

S[A] = -∫ d^Dx  1/4  (Subscript[F, a]^(μν))(x)  (Subscript[F, μνa])(x)

First approach

F1=FieldStrength[μ,ν,a,{A,b,c},1,Explicit->True]

F2=FieldStrength[μ,ν,a,{A,d,e},1,Explicit->True]

S[A]=-1/4F1.F2

In order to derive the equation of motion the functional derivative of S with respect to (Subscript[A, σ]^g)has to be set to zero. Bearing in mind that for FeynCalc we have to be  precise as to where which operators (coming from the substitution of the  derivative of the δ function) act:,  act with the functional  derivative operator on the first field strength:

0 = (δS)/(δ(Subscript[A, σ]^g)(y))=-2/4∫d^Dx  (δ/(δ(Subscript[A, σ]^g)(y)) (Subscript[F, μνa])(x)) (Subscript[F, a]^(,μν))(x)

See what happens with just(δS[A])/(δ(Subscript[A, σ]^g)).

Ag=QuantumField[A,{σ},{g}]

t1=FunctionalD[F1,Ag]

In order to minimize the number of dummy indices, replace b -> c.

t1 = t1 /. b->c

Instead of inserting the definition for the second (Subscript[F, a]^(μν)), introduce a QuantumField object with antisymmetry built into the Lorentz  indices:

F/: QuantumField[pard___,F,β_,α_,s_]:=-QuantumField[pard,F,α,β,s]/;!OrderedQ[{β,α}]

QuantumField[F,{μ,ν},{a}]

%/.{μ:>ν,ν:>μ}

t2=Contract[ExpandPartialD[-1/2 t1.QuantumField[F,LorentzIndex[μ],LorentzIndex[ν],SUNIndex[a]]]]/.Dot->Times

t3 = t2 /. ν->μ

t4=FCE[t3]/. SUNF[a,c,g]->-SUNF[g,c,a]

Since the variational derivative vanishes t4 implies that  0 =  (Subscript[D, μ])(Subscript[F, g]^(μσ)) .

Second approach

It is of course also possible to do the functional deriviate on the S[A] with both field strength tensors inserted.

S[A]

r1=
FunctionalD[S[A],Ag]

This is just funcional derivatves and partial integration and simple contraction of indices. No attempt is made to rename dummy indices (since this is difficult in general ...).

With a general replacement rule only valid for commuting fields the color indices can be canonicalized a bit more. The idea is to use the commutative properties of the vector fields, and canonicalize the color indices by a trick. This function will work on any commuting product of fields.

Clear[symfun];

symfun[z_,fieldname_Symbol]:=Expand[SUNSimplify[FixedPoint[Collect2[DotSimplify[#1/.Times->Dot]/.(((qi___).QuantumField[par1___,fieldname,li1_,sui1_].QuantumField[par2___,fieldname,li2_,sui2_].qf___ )any_):>((qi.QuantumField[par1,A,li1,sui2].QuantumField[par2,fieldname,li2,sui1].qf )(any/.{sui1:>sui2,sui2:>sui1}))/;(!(FreeQ2[any,{sui1,su2}]))&&!(OrderedQ[{sui1,sui2}])/.Dot->Times,QuantumField]&,z,42]]]

r2 = symfun[r1,A]

r3=r2/.ν->μ

Inspection reveals that still terms are the same. Gather the terms with  two f 's:

twof=Select[r3,Count[#,SUNF[__]]===2&]

twofnew=(twof[[1]]+(twof[[2]]/.{b:>c,c:>b}))/.{a:>c,c:>a}

r4 = r3-twof+twofnew

Check that this is now indeed the same as the t4 result from the first attempt.

t4

w0=RightPartialD[μ].FieldStrength[μ,σ,g,{A,a,b},1]+QuantumField[A,LorentzIndex[μ],SUNIndex[c]]FieldStrength[μ,σ,a,{A,b,d},1]SUNF[g,c,a]

w1=Explicit[w0]

w2=ExpandPartialD[w1]/.Dot->Times

dif1 = w2-r4

dif2=symfun[dif1,A]

quod erat demonstrandum

Unset[s[ϕ]];Unset[S[A]];
Clear[Ag,F1,F2,t1,t2,t3,t4,F,r1,r2,r3,symfun,twof,twofnew,w0,w1,w2,dif1,dif2,dif3]

Examples of funcional differentiation as used in FeynRule

This is a part of the QCD Lagrangian.

(Gstrong*QuantumField[GaugeField, LorentzIndex[li1],         SUNIndex[si2]][] .       QuantumField[GaugeField, LorentzIndex[li2],         SUNIndex[si4]][] .       QuantumField[PartialD[LorentzIndex[li1]], GaugeField,         LorentzIndex[li2], SUNIndex[si1]][]*     SUNF[SUNIndex[si1], SUNIndex[si2], SUNIndex[si4]])/4

FunctionalD[%, {QuantumField[GaugeField,{μ},{a}][p],     QuantumField[GaugeField,{ν},{b}][q],     QuantumField[GaugeField,{ρ},{c}][r]}]

Calc[%//Calc]//Factor

FVD

Description

FVD[p, μ] is the D-dimensional vector p with Lorentz index μ.

See also:  FCE, FCI, FV, FourVector, Pair.

Examples

FVD[p,μ]

FVD[p-q,μ]

FVD[p,μ]//InputForm

FCI[FVD[p,μ]]//InputForm

There is no special function to expand momenta in FVD.

ExpandScalarProduct[FVD[p-q,μ]]

InputForm[%]

FV

Description

FV[p, μ] is the four-dimensional vector p^μ.

See also:  FCE,FCI, FVD, FourVector, Pair.

Examples

FV[p,μ]

FV[p-q,μ]

FV[p,μ]//InputForm

FCI[FV[p,μ]]//InputForm

There is no special function to expand momenta in FV; ExpandScalarProduct does the job.

ExpandScalarProduct[FV[p-q,μ]]

InputForm[%]

GAD

Description

GAD[μ] can be used as input for a D-dimensional (Subscript[γ, μ]) and is transformed into DiracGamma[LorentzIndex[μ,D],D] by   FeynCalcInternal (=FCI).GAD[μ,ν, ...] is a short form for   GAD[μ].GAD[ν]. ... .

See also:  DiracMatrix, GA, GS.

Examples

GAD[μ]

GAD[μ,ν]-GAD[ν,μ]

InputForm[FCI[GAD[μ]]]

GAD[μ,ν,ρ,σ]

InputForm[GAD[μ,ν,ρ,σ]]

GAD[α].(GSD[p]+m).GAD[β]

GammaEpsilon

Description

GammaEpsilon[exp] gives a series expansion of Gamma[exp] in Epsilon up to order 6 (where EulerGamma is neglected).

See also:  GammaExpand, Series2.

Examples

If the argument is of the form (1+a Epsilon) the result is not calculated but tabulated.

GammaEpsilon[1+a Epsilon]

GammaEpsilon[1-Epsilon/2]

For other arguments the expansion is calculated.

GammaEpsilon[Epsilon]

GammaEpsilon[x]

GammaExpand

Description

GammaExpand[exp] rewrites Gamma[n + m] in exp (where n has Head Integer).

See also:  GammaEpsilon.

Examples

GammaExpand[Gamma[2 + Epsilon]]

GammaExpand[Gamma[-3+Epsilon]]

GammaExpand[Gamma[1 + Epsilon]]

GA

Description

GA[μ] can be used as input for a 4-dimensional (Subscript[γ, μ]) and is transformed into DiracGamma[LorentzIndex[μ]] by   FeynCalcInternal (=FCI).GA[μ,ν, ...] is a short form for   GA[μ].GA[ν]. ... .

See also:  DiracMatrix, GAD, GS.

Examples

GA[μ]

GA[μ,ν]-GA[ν,μ]

InputForm[FCI[GA[μ]]]

GA[μ,ν,ρ,σ]

InputForm[GA[μ,ν,ρ,σ]]

GA[α].(GS[p]+m).GA[β]

GhostPropagator

Description

GhostPropagator[p, a, b] gives the ghost propagator where "a" and "b"   are the color indices. GhostPropagator[p] omits the (Subscript[δ, ab]).

See also:  GHP, GluonPropagator, GluonGhostVertex.

Examples

GhostPropagator[p,a,b]

GhostPropagator[p]

GhostPropagator[p,1,2]

GhostPropagator[-k,3,4]// FCE//InputForm

GHP

Description

GHP[p, a, b] gives the ghost propagator where "a" and "b" are the   color indices. GHP[p] omits the (Subscript[δ, ab]).

See also:  GhostPropagator, GluonPropagator, GluonGhostVertex.

Examples

GHP[p,a,b]

GHP[p]

GHP[p,1,2]

InputForm[FCE[GHP[-k,3,4]]]

GaugeField

Description

GaugeField is a just a name. No functional properties are associated with it. 
GaugeField is used as default setting for the option QuantumField of FieldStrength.

See also:  FieldStrength, QuantumField.

Examples

GaugeField

QuantumField[GaugeField,LorentzIndex[μ],SUNIndex[a]]

GluonGhostVertex

Description

GluonGhostVertex[{p,mu,a}, {q,nu,b}, {k,rho,c}] or 
GluonGhostVertex[ p,mu,a , q,nu,b ,  k,rho,c ] yields the Gluon-Ghost vertex. 
The first argument represents the gluon and the third argument the outgoing ghost field (but incoming four-momentum). The dimension  and the name of the coupling constant are determined by the options Dimension and CouplingConstant.

See also:  GluonVertex.

Options[GluonGhostVertex]

Examples

GluonGhostVertex[{p,μ,a},{q,ν,b},{k,ρ,c}]

%//InputForm

GluonGhostVertex[p,1,q,2,k,3]

GluonPropagator

Description

GluonPropagator[p, {mu, a}, {nu, b}] or  
GluonPropagator[p,  mu, a ,  nu,   b ] yields the gluon propagator.  
GluonPropagator[p, {mu}, {nu}] or   GluonPropagator[p, mu, nu] omits the SUNDelta. The gauge and the dimension    is determined by the option Gauge and Dimension. 
The following settings of   Gauge are possible:  
1                                    :  the Feynman  gauge
α                                 :  the general covariant gauge
{Momentum[n] ,1}   :   axial gauge.

GP can be used as an abbreviation of GluonPropagator.

GP

Options[GluonPropagator]

See also:  GluonVertex, GhostPropagator, GluonGhostVertex.

Examples

GluonPropagator[p,μ,a,ν,b]

GluonPropagator[p,μ,a,ν,b,Gauge->α]

GluonPropagator[p,μ,a,ν,b,Gauge->{Momentum[n],1}]

GluonPropagator[p,μ,ν]

This is a convenient way to enter amplitudes by hand (GP is an abbreviation GluonPropagator).

GP[p,1,2]

GP[-k,3,4]//FCE//InputForm

GluonPropagator[p,μ,a,ν,b,CounterTerm-> 1]

GluonPropagator[p,μ,a,ν,b,CounterTerm-> 2]

GluonPropagator[p,μ,a,ν,b,CounterTerm-> 3]

GluonPropagator[p,μ,a,ν,b,CounterTerm-> 4]

GluonPropagator[p,μ,a,ν,b,CounterTerm-> 5]

GluonVertex

Description

Note: All momenta are flowing into the vertex.

GluonVertex[{p,mu,a}, {q,nu,b}, {k,la,c}] or GluonVertex[p,mu,a ,  q,nu,b , k,la,c ] yields the 3-gluon vertex.  
GluonVertex[{p,mu}, {q,nu}, {k,la}] yields the 3-gluon vertex without color structure and the  coupling constant.  
GluonVertex[{p,mu,a}, {q,nu,b}, {k,la,c}, {s,si,d}]  or 
GluonVertex[{mu,a}, {nu,b}, {la,c}, {si,d}] or
GluonVertex[p,mu,a ,  q,nu,b ,  k,la,c ,  s,si,d] or 
GluonVertex[ mu,a ,  nu,b ,  la,c ,  si,d ]  yields the  4-gluon vertex. 
The dimension  and the name of the coupling constant are determined by the options Dimension and CouplingConstant.

GV can be used as an abbreviation of GluonVertex.

GV

Options[GluonVertex]

See also:  GluonGhostVertex, GluonPropagator.

Examples

GluonVertex[{p,μ,a},{q,ν,b},{r,ρ,c}]

GluonVertex[{p,μ,a},{q,ν,b},{r,ρ,c}]//Explicit

GluonVertex[{p,μ},{q,ν},{r,ρ}]

GluonVertex[{p,μ},{q,ν},{r,ρ}]//Explicit

GluonVertex[{p,μ,a},{q,ν,b},{r,ρ,c},{s,σ,d}]

A very convenient way to enter diagrams by hand is to label each line hitting a vertex by a number and put this number after the inflowing momentum.

GV[p,1,q,2,r,3]

GV[p,1,q,2,r,3,s,4]

GSD

Description

GSD[p] can be used as input for a D-dimensional p / (=γ.p = (Subscript[γ, μ])p^μ) and is transformed into DiracGamma[Momentum[p,D],D] by FeynCalcInternal   (=FCI).
GSD[p,q, ...] is a short form for GSD[p].GSD[q]. ... .

See also:  DiracGamma, DiracSlash, GA, GAD.

Examples

GSD[p]

GSD[p]//FCI//InputForm

GSD[p,q,r,s]

GSD[p,q,r,s]//InputForm

GSD[q].(GSD[p]+m).GSD[q]

GS

Description

GS[p] can be used as input for a 4-dimensional p / (=γ.p = (Subscript[γ, μ])p^μ) and is transformed into DiracGamma[Momentum[p]] by FeynCalcInternal   (=FCI).
GS[p,q, ...] is a short form for GS[p].GS[q]. ... .

See also:  DiracGamma, DiracSlash, GA, GAD.

Examples

GS[p]

GS[p]//FCI//InputForm

GS[p,q,r,s]

GS[p,q,r,s]//InputForm

GS[q].(GS[p]+m).GS[q]

Hill

Description

Hill[x,y] gives the Hill identity with arguments x and y. The returned object is 0.

See also:  SimplifyPolyLog.

Examples

Hill[a,b]

% /. a:> .123 /. b:> .656 // Chop

Hill[x,x y]//PowerExpand//SimplifyPolyLog//Expand

% /. x:> .34/. y-> .6//N//Chop

HypergeometricAC

Description

HypergeometricAC[n][exp] analytically continues Hypergeometric2F1 functions in exp. The second argument  n refers to the equation number (n) in chapter 
2.10 of "Higher Transcendental Functions" by Ergelyi, Magnus, 
Oberhettinger, Tricomi. In case of eq. (6) (p.109) the last line is returned for HypergeometricAC[6][exp], while the first equality is given by 
HypergeometricAC[61][exp]. ((2.10.1) is identical to eq. (9.5.7) of "Special Functions & their Applications" by N.N.Lebedev).

Options[HypergeometricAC]

See also:  HypExplicit, HypergeometricIR, HypergeometricSE, ToHypergeometric.

Examples

These are all transformation rules currently built in.

HypergeometricAC[1][Hypergeometric2F1[α,β,γ,z]]

HypergeometricAC[2][Hypergeometric2F1[α,β,γ,z]]

HypergeometricAC[3][Hypergeometric2F1[α,β,γ,z]]

HypergeometricAC[4][Hypergeometric2F1[α,β,γ,z]]

HypergeometricAC[6][Hypergeometric2F1[α,β,γ,z]]

HypergeometricAC[61][Hypergeometric2F1[α,β,γ,z]]

HypergeometricIR

Description

HypergeometricIR[exp, t]  substitutes for all Hypergeometric2F1[a,b,c,z] in exp by its Euler integral reprentation. The factor Integratedx[t, 0, 1] can be omitted by setting the option Integratedx -> False.

See also:  HypergeometricAC, HypergeometricSE, ToHypergeometric.

Options[HypergeometricIR]

Examples

HypergeometricIR[Hypergeometric2F1[a,b,c,z],t]

ToHypergeometric[t^b (1-t)^c (1+t z)^a,t]

HypergeometricIR[%,t]

HypergeometricSE

Description

HypergeometricSE[exp, ν] expresses Hypergeometric functions by their  series expansion in terms of a sum (the Sum is omitted and ν, running  from 0 to ∞, is the summation index).

Options[HypergeometricSE]

See also:  HypergeometricIR.

Examples

HypergeometricSE[Hypergeometric2F1[a,b,c,z],ν]

HypergeometricSE[HypergeometricPFQ[{a,b,c},{d,e},z],ν]

HypExplicit

Description

HypExplicit[exp, ν] expresses Hypergeometric functions in exp by their  definition in terms of a sum (the Sum is omitted and ν is the summation  index).

See also:  HypergeometricIR.

Examples

Hypergeometric2F1[a,b,c,z]

HypExplicit[%,ν]

HypergeometricPFQ[{a,b,c},{d,e},z]

HypExplicit[%,ν]

Integrate2

Description

Integrate2 is like Integrate, but : 
Integrate2[a_Plus, b__] :=   Map[Integrate2[#,   b]&, a] (effectively, more linear algebra is done)
 Integrate2[f[x] DeltaFunction[x],  x]  ⟶ f[0]
 Integrate2[f[x] DeltaFunction[x0-x], x]  ⟶ f[x0]. 
 Integrate2[f[x] DeltaFunction[a + b x], x]  ⟶  Integrate[f[x]  (1/abs[b]) DeltaFunction[a/b + x], x],  where abs[b] ⟶ b, if  b is a Symbol, and if b = -c, then  abs[-c] ⟶ c, i.e., the  variable contained  in b is supposed  to be positive.
 π^2 is replaced by  6 Zeta2. 
Integrate2[1/(1-y),{y,x,1}]  is intepreted as  distribution, i.e. as Integrate2[-1/(1-y)],{y, 0, x}]  ⟶  Log[1-y]. 
Integrate2[1/(1-x),{x,0,1}]  ⟶ 0.

See also:  DeltaFunction, Integrate3, SumS, SumT.

Examples

Integrate2[Log[1+x]Log[x]/(1-x),{x,0,1}]//Timing

Since Integrate2 uses table-look-up methods it is much faster than Mathematica's Integrate.

Integrate2[PolyLog[2,x^2],{x,0,1}]

Integrate2[PolyLog[3,-x],{x,0,1}]

Integrate2[PolyLog[3,1/(1+x)],{x,0,1}]

Integrate2[DeltaFunction[1-x] f[x],{x,0,1}]

Integrate2 does integration in a Hadamard sense, i.e., (∫_0^1)f(x)dx  means acutally expanding the
result of (∫_δ^(1-δ))f(x)dx up do O(δ) and neglecting all δ-dependent terms.
E.g. (∫_δ^(1-δ))1/(1-x)dx= -log(1-x)(Subscript[|, δ]^(1-δ)) = -log(δ)+log(1) => 0.

Integrate2[1/(1-x),{x,0,1}]

In the physics literature sometimes the "+" notation is used. In   FeynCalc the (SubPlus[((1/(1-x)))]) is represented by PlusDistribution[1/(1-x)] or just 1/(1-x) .

Integrate2[PlusDistribution[1/(1-x)],{x,0,1}]

Integrate2[PolyLog[2,1-x]/(1-x)^2,{x,0,1}]

Integrate2[(Log[x] Log[1+x])/(1+x),{x,0,1}]

Integrate2[Log[x]^2/(1-x),{x,0,1}]

Integrate2[PolyLog[2,-x]/(1+x),{x,0,1}]

Integrate2[Log[x] PolyLog[2,x],{x,0,1}]

Integrate2[x PolyLog[3,x],{x,0,1}]

Integrate2[(Log[x]^2 Log[1-x])/(1+x),{x,0,1}]

Integrate2[PolyLog[2,((x (1-z)+z) (1-x+x z))/z]/(1-x+x z),{x,0,1}]

Apart[Integrate2[x^(OPEm-1) PolyLog[3,1-x],{x,0,1}],OPEm]

DataType[OPEm,PositiveInteger]

Integrate2[x^(OPEm-1) DeltaFunction[1-x],{x,0,1}]

This is the polarized non-singlet spin splitting function whose first moment vanishes.

tt=SplittingFunction[PQQNS]

Integrate2[tt,{x,0,1}]//Timing

Integrate2[DeltaFunction[1-x] f[x],{x,0,1}]

Integrate3

Description

Integrate3 contains the integral table used by Integrate2. Integration is performed in a distributional sense.

See also:  Integrate2.

Examples

Integrate3[x^OPEm Log[x],{x,0,1}]

Integrate3[(x^OPEm Log[x] Log[1-x])/(1-x),{x,0,1}]

Integrate3[DeltaFunctionPrime[1-x],{x,0,1}]

Integrate3[f[x] DeltaFunctionPrime[1-x],{x,0,1}]

Integrate3[1/(1-x),{x,0,1}]

IntegrateByParts

Description

IntegrateByParts[(1-t)^(a Epsilon -1) g[t], deriv, t] does an integration by parts of the definite integral over t from 0 to 1.

Options[IntegrateByParts]

Examples

IntegrateByParts[(1-t)^(a Epsilon-1) g[t],(1-t)^(a Epsilon-1),t]

InverseMellin

Description

InverseMellin[exp, y] performs the inverse Mellin transform of polynomials   in OPEm.
The inverse transforms are not calculated but a table-lookup is  done.
WARNING: do not "trust" the results for the inverse Mellin  transform involving SumT's; there is an unresolved inconsistency here  (related to (-1)^m).

See also:  DeltaFunction, Integrate2, OPEm, SumS, SumT.

Examples

InverseMellin[1/OPEm,y]

InverseMellin[1/(OPEm+3),y]

InverseMellin[1,y]

InverseMellin[1/OPEm^4,y]

InverseMellin[1/OPEm+1,y]

InverseMellin[1/i+1,y,i]

The inverse operation to InverseMellin is done by Integrate2.

Integrate2[InverseMellin[1/OPEm,y],{y,0,1}]

Below is a list of all built-in basic inverse Mellin transforms .

list={1,

1/(OPEm + n),

1/(-opem + n),

PolyGamma[0,OPEm], 

SumS[1,-1+OPEm],

SumS[1,-1+OPEm]/(OPEm-1),

SumS[1,-1+OPEm]/(1-OPEm),

SumS[1,-1+OPEm]/(OPEm+1),

SumS[1,-1+OPEm]/OPEm^2,

SumS[1,-1+OPEm]/OPEm,

SumS[1,-1+OPEm]^2/OPEm,

SumS[2,-1+OPEm],

SumS[2,-1+OPEm]/OPEm,

SumS[3,-1+OPEm],

SumS[1,1,-1+OPEm],

SumS[1,OPEm-1]^2,

SumS[1,2,-1+OPEm],

SumS[2,1,-1+OPEm],

SumS[1, -1 + OPEm]^3, 

SumS[1, -1 + OPEm]*SumS[2, -1 + OPEm], 

SumS[1,1,1,-1+OPEm]

};

SetAttributes[im,HoldAll];	im[z_] := SequenceForm[HoldForm[z]," ≏ ", 		         InverseMellin[z,y]];

im[OPEm^(-3)]

im[OPEm^(-2)]

im[PolyGamma[0,OPEm]]

im[SumS[1,OPEm-1]]

im[SumS[1,OPEm-1]/(OPEm-1)]

im[SumS[1,OPEm-1]/(OPEm+1)]

im[SumS[1,-1+OPEm]/OPEm^2]

im[SumS[1,-1+OPEm]/OPEm]

im[SumS[1,-1+OPEm]^2/OPEm]

im[SumS[2,OPEm-1]]

im[SumS[2,OPEm-1]/OPEm]

im[SumS[3,OPEm-1]]

im[SumS[1,1,OPEm-1]]

im[SumS[1,2,OPEm-1]]

im[SumS[2,1,OPEm-1]]

im[SumS[1,1,1,OPEm-1]]

Clear[im];

Isolate

Description

Isolate[expr] substitutes abbreviations KK[i] for all Plus[...] (sub-sums) in 
expr. The inserted KK[i] have head HoldForm.
Isolate[expr, varlist] substitutes KK[i] for all subsums in expr which are free of any occurence of a member of the list varlist. Instead of KK any other head or a list of names of the abbreviations may be specified with the option IsolateNames.

Options[Isolate]

Examples

Isolate[a+b]

t1=Isolate[(a+b) f + (c+d) f + e,f]

InputForm[t1]

{KK[1], t1, ReleaseHold[t1]}

Isolate[a[z] (b+c (y+z))+d[z] (y+z),{a,d},IsolateNames->F]

??F

Isolate[a-b-c-d-e,IsolateNames->L,IsolateSplit->15]

{L[2],L[1]}

Clear[t1,L]

Kummer

Description

Kummer[i][exp] applies Kummer relation number i (i =1, ... 24, 94,95,96) to all Hypergeometric2F1 in exp.
i = 94 corresponds to eq. 9.131.2,  
i = 95 to eq. 9.132.1 and  
i = 96 to eq. 9.132.2 in Gradsteyn & Ryzhik.

See also:  HypergeometricAC.

Examples

Hypergeometric2F1[a,b,c,z]==Kummer[2][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[3][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[4][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a,b,c,1-z]==Kummer[6][Hypergeometric2F1[a,b,c,1-z]]

Hypergeometric2F1[a,b,a+b+1-c,1-z]==Kummer[6][Hypergeometric2F1[a,b,a+b+1-c,1-z]]

Hypergeometric2F1[a,b,c,1-z]==Kummer[7][Hypergeometric2F1[a,b,c,1-z]]

Hypergeometric2F1[a,b,a+b+1-c,1-z]==Kummer[7][Hypergeometric2F1[a,b,a+b+1-c,1-z]]

Hypergeometric2F1[a,b,c,1-z]==Kummer[8][Hypergeometric2F1[a,b,c,1-z]]

Hypergeometric2F1[a,b,a+b+1-c,1-z]==Kummer[8][Hypergeometric2F1[a,b,a+b+1-c,1-z]]

Hypergeometric2F1[a,b,c,z^(-1)]==Kummer[10][Hypergeometric2F1[a,b,c,z^(-1)]]

Hypergeometric2F1[a,a+1-c,a+1-b,z^(-1)]==Kummer[10][Hypergeometric2F1[a,a+1-c,a+1-b,z^(-1)]]

Hypergeometric2F1[a,b,c,z^(-1)]==Kummer[11][Hypergeometric2F1[a,b,c,z^(-1)]]

Hypergeometric2F1[a,a+1-c,a+1-b,z^(-1)]==Kummer[11][Hypergeometric2F1[a,a+1-c,a+1-b,z^(-1)]]

Hypergeometric2F1[a,b,c,z^(-1)]==Kummer[12][Hypergeometric2F1[a,b,c,z^(-1)]]

Hypergeometric2F1[a,a+1-c,a+1-b,z^(-1)]==Kummer[12][Hypergeometric2F1[a,a+1-c,a+1-b,z^(-1)]]

Hypergeometric2F1[a,b,c,z^(-1)]==Kummer[14][Hypergeometric2F1[a,b,c,z^(-1)]]

Hypergeometric2F1[b+1-c,b,b+1-a,z^(-1)]==Kummer[14][Hypergeometric2F1[b+1-c,b,b+1-a,z^(-1)]]

Hypergeometric2F1[a,b,c,z^(-1)]==Kummer[15][Hypergeometric2F1[a,b,c,z^(-1)]]

Hypergeometric2F1[b+1-c,b,b+1-a,z^(-1)]==Kummer[15][Hypergeometric2F1[b+1-c,b,b+1-a,z^(-1)]]

Hypergeometric2F1[a,b,c,z^(-1)]==Kummer[16][Hypergeometric2F1[a,b,c,z^(-1)]]

Hypergeometric2F1[b+1-c,b,b+1-a,z^(-1)]==Kummer[16][Hypergeometric2F1[b+1-c,b,b+1-a,z^(-1)]]

Hypergeometric2F1[a+1-c,b+1-c,2-c,z]==Kummer[18][Hypergeometric2F1[a+1-c,b+1-c,2-c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[18][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a+1-c,b+1-c,2-c,z]==Kummer[19][Hypergeometric2F1[a+1-c,b+1-c,2-c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[19][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a+1-c,b+1-c,2-c,z]==Kummer[20][Hypergeometric2F1[a+1-c,b+1-c,2-c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[20][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[c-a,c-b,c+1-a-b,1-z]==Kummer[22][Hypergeometric2F1[c-a,c-b,c+1-a-b,1-z]]

Hypergeometric2F1[a,b,c,1-z]==Kummer[22][Hypergeometric2F1[a,b,c,1-z]]

Hypergeometric2F1[c-a,c-b,c+1-a-b,1-z]==Kummer[23][Hypergeometric2F1[c-a,c-b,c+1-a-b,1-z]]

Hypergeometric2F1[a,b,c,1-z]==Kummer[23][Hypergeometric2F1[a,b,c,1-z]]

Hypergeometric2F1[c-a,c-b,c+1-a-b,1-z]==Kummer[24][Hypergeometric2F1[c-a,c-b,c+1-a-b,1-z]]

Hypergeometric2F1[a,b,c,1-z]==Kummer[24][Hypergeometric2F1[a,b,c,1-z]]

Hypergeometric2F1[a,b,c,z]==Kummer[94][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[95][Hypergeometric2F1[a,b,c,z]]

Hypergeometric2F1[a,b,c,z]==Kummer[96][Hypergeometric2F1[a,b,c,z]]

Lagrangian

Description

Lagrangian[oqu]  gives the unpolarized quark operator. Lagrangian[oqp]   gives the polarized quark operator.
Lagrangian["QCD"] gives part of the QCD Lagrangian.

See also:  FeynRule.

Examples

Lagrangian["QCD"]

Twist-2 operator product expansion operators

Lagrangian["ogu"]

Lagrangian["ogp"]

Lagrangian["oqu"]

Lagrangian["oqp"]

LCD

Description

LCD[m,n,r,s] evaluates to D-dimensional LeviCivita[m,n,r,s] by virtue of FeynCalcInternal.
LCD[m,...][p, ...] evaluates to D-dimensional 
LeviCivita[m,...][p,...] 
applying FeynCalcInternal.

You need  to do SetOptions[Eps, Dimension->D] before LCD can be used as D-dimensional Levi-Civita input function.

See also:  LeviCivita, LC.

Examples

SetOptions[Eps,Dimension->D];

LCD[μ,ν,ρ,σ]

%//FCI

%//InputForm

LCD[μ,ν][p,q]

%//FCI//InputForm

Factor2[Contract[LCD[μ,ν,ρ][p] LCD[μ,ν,ρ][q]]]

SetOptions[Eps,Dimension->4]

LC

Description

LC[m,n,r,s] evaluates to 4-dimensional LeviCivita[m,n,r,s] by virtue of applying FeynCalcInternal.
LC[m,...][p, ...] evaluates to 4-dimensional 
LeviCivita[m,...][p,...] applying FeynCalcInternal.

See also:  LeviCivita, LCD.

Examples

LC[μ,ν,ρ,σ]

%//FCI

%//InputForm

LC[μ,ν][p,q]

%//FCI//InputForm

Contract[LC[μ,ν,ρ][p] LC[μ,ν,ρ][q]]

LeftPartialD

Description

LeftPartialD[μ] denotes (Subscript[(∂^←), μ])acting to the left.

See also:  ExpandPartialD, PartialD, LeftRightPartialD, RightPartialD.

Examples

QuantumField[A,LorentzIndex[μ]].LeftPartialD[ν]

ExpandPartialD[%]

InputForm[%]

InputForm[LeftPartialD[μ]]

QuantumField[A,LorentzIndex[μ]].QuantumField[A,LorentzIndex[ν]].LeftPartialD[ρ]

ExpandPartialD[%]

InputForm[%]

LeftRightPartialD

Description

LeftRightPartialD[mu] denotes (Subscript[(∂^↔), μ]), acting to the left and  right.                       
  ExplitPartialD[LeftRightPartialD[μ]] gives 1/2 (RightPartialD[μ] -  LeftPartialD[μ]).

See also:  ExplicitPartialD, ExpandPartialD, PartialD, LeftPartialD, LeftRightPartialD2, RightPartialD.

Examples

LeftRightPartialD[μ]

ExplicitPartialD[%]

LeftRightPartialD[μ].QuantumField[A,LorentzIndex[ν]]

ExpandPartialD[%]

QuantumField[A,LorentzIndex[μ]].LeftRightPartialD[ν].QuantumField[A,LorentzIndex[ρ]]

ExpandPartialD[%]

LeftRightPartialD2

Description

LeftRightPartialD2[mu] denotes (Subscript[(∂^↔), μ]), acting to the left and  right.                       
  ExplitPartialD[LeftRightPartialD2[μ]] gives  (RightPartialD[μ] +  LeftPartialD[μ]).

See also:  ExplicitPartialD, ExpandPartialD, PartialD, LeftPartialD, RightPartialD.

Examples

LeftRightPartialD2[μ]

ExplicitPartialD[%]

LeftRightPartialD2[μ].QuantumField[A,LorentzIndex[ν]]

ExpandPartialD[%]

QuantumField[A,LorentzIndex[μ]].LeftRightPartialD2[ν].QuantumField[A,LorentzIndex[ρ]]

ExpandPartialD[%]

LeviCivita

Description

LeviCivita[μ, ν, ρ, σ] is an input  function for the   totally antisymmetric Levi-Civita tensor.  It evaluates automatically  to the   internal representation Eps[ LorentzIndex[μ],  LorentzIndex[ν],   LorentzIndex[ρ], LorentzIndex[σ]  ]  (or with a second argument   in LorentzIndex for the Dimension, if the option Dimension of LeviCivita is   changed).   LeviCivita[μ, ν ...][ p, ...] evaluates to    Eps[LorentzIndex[μ],  LorentzIndex[ν], ..., Momentum[p], ...].

Options[LeviCivita]

See also:  LC, LCD.

Examples

LeviCivita[α,β,γ,δ]

LeviCivita[μ,ν][OPEDelta,p]

LeviCivita[][p,q,r,s]

LeviCivita[α,β,β,δ]

LeviCivita[μ,ν][OPEDelta,p]//InputForm

t1 = LeviCivita[α,β,γ,ρ].LeviCivita[α,β,γ,ρ]

Contract[t1]

SetOptions[LeviCivita,Dimension->D];SetOptions[Eps,Dimension->D];

Contract[ LeviCivita[α,β,γ,ρ].LeviCivita[α,β,γ,ρ]]//Factor2

SetOptions[LeviCivita,Dimension->4];SetOptions[Eps,Dimension->4];

LC[α,β,γ,δ]

Clear[t1]

LorentzIndex

Description

LorentzIndex[μ] denotes a four dimensional Lorentz index. 
For other   than four dimensions: LorentzIndex[μ, D] or LorentzIndex[n], etc.  LorentzIndex[μ,  4]simplifies to LorentzIndex[μ].

See also:  ChangeDimension, Momentum.

Examples

This denotes a four-dimensional Lorentz index.

LorentzIndex[α]

An optional second argument can be given for a dimension different from 4.

LorentzIndex[α,n]

LorentzIndex[ComplexIndex[α]]

ComplexConjugate[LorentzIndex[μ]]

ComplexConjugate[LorentzIndex[ComplexIndex[β]]]

Setting $LorentzIndices=True displays the dimension as a subindex.

$LorentzIndices=True; LorentzIndex[α,D ]

LorentzIndex[ν,4]

$LorentzIndices = False;

Map2

Description

Map2[f, exp] is equivalent to Map if Nterms[exp] > 0, otherwise Map2[f, exp] gives f[exp].

See also:  NTerms.

Examples

Map2[f,a-b]

Map2[f,x]

Map2[f,{a,b,c}]

Map2[f,1]

MetricTensor

Description

MetricTensor[μ, ν] is the metric tensor. The default dimension is   4.

See also:  FeynCalcExternal, FCE, FCI, MT, MTD.

Examples

MetricTensor[α,β]

Contract[% %]

MetricTensor[α,β,Dimension->n]

Contract[% %]

InputForm[MetricTensor[a,b]]

InputForm[MetricTensor[a,b,Dimension->D]]

InputForm[FCE[MetricTensor[a,b]]]

InputForm[FCE[MetricTensor[a,b,Dimension->D]]]

MomentumCombine

Description

MomentumCombine[expr]  is the inverse operation to MomentumExpand and ExpandScalarProduct. MomentumCombine combines also Pair`s.

See also:  ExpandScalarProduct, Momentum, MomentumExpand.

Examples

Momentum[p]-2  Momentum[q] // MomentumCombine // InputForm

t1=FV[p,μ] + 2 FV[q,μ]

MomentumCombine[t1]

MomentumCombine[t1]//InputForm

MomentumCombine[t1]//ExpandScalarProduct

InputForm[%]

Clear[t1]

MomentumExpand

Description

MomentumExpand[expr] expands Momentum[a+b+ ...] in expr into Momentum[a] + Momentum[b] + ... .

See also:  ExpandScalarProduct, MomentumCombine.

Examples

MomentumExpand[Momentum[p+q]]//InputForm

ScalarProduct[p+q,r]

%//InputForm

MomentumExpand[ScalarProduct[p+q,r]]

%//InputForm

MomentumExpand[ScalarProduct[p+q,r-p]]

%//InputForm

Calc[%]

Momentum

Description

Momentum[p] is the head of a four momentum (p). The internal representation of a four-dimensional p is  Momentum[p]. 
For other than four dimensions: Momentum[p, dim]. Momentum[p, 4] simplifies to Momentum[p].

See also:  DiracGamma, Eps, LorentzIndex, MomentumExpand.

Examples

This is a four dimensional momentum.

Momentum[p]

As an optional second argument the dimension must be specified if it is different from 4.

Momentum[p,D]

The dimension index is supressed in the output.

Momentum[p,d]//InputForm

a1=Momentum[-q]

a1//InputForm

a2 = Momentum[p-q] + Momentum[2q]

a2//InputForm

a2//MomentumExpand//InputForm

a2//MomentumCombine//InputForm

ChangeDimension[Momentum[p],d]//InputForm

Clear[a1,a2]

MTD

Description

MTD[μ,ν] is the metric tensor in D dimensions.

See also:  FeynCalcExternal, FCE, FCI, MetricTensor, MT.

Examples

MTD[α,β]

Contract[MTD[α,β] MTD[α,β]]

MTD[α,β]//InputForm

FCI[MTD[α,β]]//InputForm

FCE[FCI[MTD[μ,ν]]]//InputForm

MT

Description

MT[μ,ν] is the metric tensor in 4 dimensions.

See also:  FeynCalcExternal, FCE, FCI, MetricTensor, MTD.

Examples

MT[α,β]

Contract[MT[α,β] MT[α,β]]

MT[a,b]//InputForm

FCI[MT[a,b]]//InputForm

FCE[FCI[MT[a,b]]]//InputForm

Nielsen

Description

Nielsen[i,j, x] denotes Nielsen's polylogarithm.

Options[Nielsen]

See also:  SimplifyPolyLog.

Examples

Nielsen[1,2,x]

Numerical evaluation is done via N[Nielsen[n_,p_,x_]] :=
(-1)^(n+p-1)/(n-1)!/p! NIntegrate[Log[1-x t]^p   Log[t]^(n-1)/t,{t,0,1}];

N[Nielsen[1,2,.45]]

Some special values are built in.

{Nielsen[1,2,0],Nielsen[1,2,-1],Nielsen[1,2,1/2],Nielsen[1,2,1]}

Nielsen[1,2,x,PolyLog->True]

Nielsen[1,3,x,PolyLog->True]

Nielsen[3,1,x,PolyLog->True]

NTerms

Description

NTerms[x] is equivalent to Length if x is a sum; otherwise NTerms[x] returns 1, except NTerms[0] -> 0.

Examples

NTerms[a-b]

NTerms[a b c]

NTerms[9]

NTerms[0]

OneLoop

Documentation unfinished ....; see also the old FeynCalc documentation at  http://www.mertig.com/oldfc. 

NOTICE:  While OneLoop is restricted to 't Hooft Feynman gauge the   function OneLoopSimplify does not have this restriction (but is slower).
OneLoop handles   selfenergies, vertex and box-graphs (those only up to 3rd rank tensor in  the  integration variable).

 WARNING: If you encounter anomalies: The default setting of $West is True, i.e., the way tr(γ^μγ^νγ^ργ^σγ^τγ^λγ^5) 
iscalculated in D dimensions has changed compared to the old FeynCalc. Keep in mind that the issue of γ^5schemes is tricky.

Description

OneLoop[q, amplitude] calculates the one-loop Feynman diagram amplitude. The argument q denotes the integration variable, i.e., the loop momentum.OneLoop[name, q, amplitude] has as first argument a name of the amplitude.

Options[OneLoop]

See also:  B0, C0, D0, OneLoopSimplify, TID, TIDL.

Examples

SP[k,r] FAD[{k,m} , k - p]//FCI

OneLoop[k,%]

OneLoopSimplify

Description

OneLoopSimplify[amp, q] simplifies the one-loop amplitude amp. The second argument denotes the integration momentum.

Options[OneLoopSimplify]

See also:  OneLoop, TID, TIDL.

Examples

SP[k,r] FAD[{k,m} , k - p]//FCI

OneLoopSimplify[%,k]

OneLoopSimplify[%/.m->0,k]

FAD[k,k, k - (Subscript[p, 1]), k - (Subscript[p, 2])] FVD[k,μ]//FCI

OneLoopSimplify[ %,k]

FCE[%]/.SPD[(Subscript[p, 1])]->0//FCI

OneLoopSimplify[FAD[k-(Subscript[p, 1]),k-(Subscript[p, 2])] SP[k,l]^2,k]

OPEDelta

Description

OPEDelta is a lightlike axial vector as used e.g. in the operator product expansion in QCD.

See also:  Twist2QuarkOperator.

Examples

FourVector[OPEDelta,μ]

Contract[% %]

SP[OPEDelta,OPEDelta]

OPEi, OPEj, OPEk, OPEl, OPEm, OPEn, OPEo

Description

OPEi, etc. are variables with DataType PositiveInteger which are used in functions relating to the operator product expansion.

Examples

OPEi

DataType[OPEi, OPEj,OPEk,OPEl, OPEm, OPEn, OPEo, PositiveInteger]

PowerSimplify[{(-1)^(2OPEi),(-1)^(2OPEj),(-1)^(2OPEk),(-1)^(2OPEl),(-1)^(2OPEm),(-1)^(2OPEn),(-1)^(2OPEo)}]

Re has been changed:

{Re[OPEi]>-3, Re[OPEi]>-2, Re[OPEi]>-1,     Re[OPEi]>0, Re[OPEi]>1}

{Re[-OPEi + OPEm] > 0, Re[-OPEi + OPEm] > 1,Re[-OPEi + OPEm] > 2}

{Re[OPEm]>-3, Re[OPEm]>-2, Re[OPEm]>-1,     Re[OPEm]>0, Re[OPEm]>1}

$Color=True; 	OPEm

$Color=False;

OPESumExplicit

Description

OPESumExplicit[exp] calculates OPESum's.

See also:  OPESum, OPESumSimplify.

Examples

t1=OPESum[A^iB^(m-i-3),{i,0,m-3}]

OPESumExplicit[t1]

t2 = OPESum[a^ib^(j-i)c^(m-j-4),{i,0,j},{j,0,m-4}]

OPESumExplicit[t2]

Clear[t1,t2];

OPESum

Description

OPESum[exp, {i, 0, m}] denotes a symbolic sum.The syntax is the same as for Sum.

See also:  OPESumExplicit, OPESumSimplify.

Examples

t1=OPESum[SO[p]^OPEiSO[k]^(OPEm-OPEi-3),{OPEi,0,OPEm-3}]

OPESumExplicit[t1]

t2 = OPESum[a^ib^(j-i)c^(m-j-4),{i,0,j},{j,0,m-4}]

OPESumExplicit[t2]

Clear[t1,t2]

OPESumSimplify

Description

OPESumSimplify[exp] simplifies OPESum's in exp.

See also:  OPESum, OPESumExplicit.

Examples

OPESum[(-SOD[p])^(OPEi+1) SOD[p-q]^(OPEm-OPEi-2),{OPEi,0,OPEm}]

OPESumSimplify[%]

OPESumSimplify[OPESum[{OPEi,0,OPEm}] a^OPEi]

OPESumSimplify[OPESum[{j,0,i},{i,0,m}] a^(j-i) b^i]

%//InputForm

Pair

Description

Pair[x, y] is the head of a special pairing used in the internal   representation: 
x and y may have heads LorentzIndex or Momentum. If both x   and y have head LorentzIndex, the metric tensor is  understood. If x and y   have head Momentum, a scalar product is  meant. If one of x and y has head   LorentzIndex and the other Momentum, a Lorentz vector p^μ is understood.

See also:  FourVector, FV, FVD, MetricTensor, MT, MTD, ScalarProduct, SP, SPD.

Examples

This represents a four-dimensional metric tensor.

Pair[LorentzIndex[α],LorentzIndex[β]]

This is a D-dimensional metric tensor.

Pair[LorentzIndex[α,D],LorentzIndex[β,D]]

Pair[LorentzIndex[α],Momentum[p]]

Pair[Momentum[q],Momentum[p]]

Pair[Momentum[p],Momentum[p]]

Pair[Momentum[p-q],Momentum[p]]

Pair[Momentum[p],Momentum[p]]^2

Pair[Momentum[p],Momentum[p]]^3

Pair[LorentzIndex[α,n-4],LorentzIndex[β]]//Contract

ExpandScalarProduct[Pair[Momentum[p-q],Momentum[p]]]

Pair[Momentum[-q],Momentum[p]] + Pair[Momentum[q],Momentum[p]]

PartialD

Description

PartialD[μ] denotes the four-dimensional (∂_μ). PartialD is used to denote derivative fields.  PartialD[LorentzIndex[μ,D]] denotes the D-dimensional (∂_μ).

See also:  ExpandPartialD, LeftRightPartialD, RightPartialD.

Examples

QuantumField[A,{μ}].LeftPartialD[ν]

ExpandPartialD[%]

InputForm[%]

PaVe

Description

PaVe[ i,j,... {p10,p12,...},{m1^2, mw^2, ...} ] denotes the invariant (and 
scalar) Passarino-Veltman integrals, i.e. the coefficient functions of the 
tensor integral decomposition.  Joining plist and mlist gives the same conventions as for A0, B0, C0, D0.  Automatic simlifications are performed for the coefficient functions of two-point integrals and for the scalar integrals.

For a more detailed description see the manual (no changes from there  basically):
http://www.mertig.com/oldfc

See also:  PaVeReduce.

Examples

Some of the PaVe's reduce to special cases.

PaVe[0,{a,b,c,d,e,f},{m1,m2,m3,m4}]

PaVe[0,0,{pp},{m^2,M^2}]

PaVeOrder

Description

PaVeOrder[expr] orders the arguments of all D0 in expr in a standard way. 
PaVeOrder[expr, PaVeOrderList -> { {..., s, u, ...}, {... m1^2, m2^2, ...}, ...}] orders the arguments of all D0 in expr according to the specified ordering lists. 
The lists may contain only a subsequence of the D0-variables.

See also:  PaVeReduce.

Examples

PaVeOrder[D0[me2,me2,mw2,mw2,t,s,me2,0,me2,0],PaVeOrderList->{me2,me2,0,0}]

PaVeOrder[D0[me2,me2,mw2,mw2,t,s,me2,0,me2,0],PaVeOrderList->{me2,me2,0,0}]

PaVeOrder[D0[a,b,c,d,e,f,m12,m22,m32,m42]+D0[me2,me2,mw2,mw2,t,s,me2,0,me2,0],PaVeOrderList->{{me2,me2,0,0},{f,e}}]

PaVeReduce

Description

PaVeReduce[expr] reduces all Passarino-Veltman integrals (i.e. all PaVe's) in expr down to scalar A0, B0, C0 and D0.

Options[PaVeReduce]

?WriteOutPaVe

See also:  FRH, PaVeOrder.

Examples

PaVeReduce[PaVe[1,2,{s,m^2,m^2},{m^2,m^2,M^2}],IsolateHead->L]

L[10]

FRH[%]

PaVeReduce[PaVe[2,{SmallVariable[me2],mw2,t},{SmallVariable[me2],0,mw2}],WriteOutPaVe->"pte"]

TableForm[ReadList["ptePaVe2Csmame2mw2tCsmame20mw2.s",String]]

DeleteFile/@FileNames["ptePaVe2Csmame2mw2tCsmame20mw2.s"];

se=SmallVariable[ME2];

d122=PaVeReduce[PaVe[1,2,2,{se,MW2,MW2,se,S,T},{0,se,0,se}],Mandelstam->{S,T,
U,2 MW2},IsolateHead->F]

Write2["fctd122.for",d122res==d122,FormatType->FortranForm];

ReadList["fctd122.for",String]//TableForm

DeleteFile/@FileNames["fctd122.for"];

PlusDistribution

Description

PlusDistribution[1/(1-x)] denotes a distribution (in the sense of the "+" prescription).

See also:  Integrate2.

Examples

PlusDistribution[1/(1-x)]

PlusDistribution[Log[1-x]/(1-x)]

Integrate2[PlusDistribution[1/(1-x)], {x,0,1}]

Integrate2[PlusDistribution[Log[1-x]/(1-x)], {x,0,1}]

Integrate2[PlusDistribution[Log[1-x]^2/(1-x)], {x,0,1}]

PlusDistribution[Log[x (1-x)]/(1-x)]

Polarization

Description

Polarization[k] = Polarization[k, I] is the head of a polarization momentum  with (incoming) momentum k. A slashed polarization vector (e1(k) slash) has 
to be entered as DiracSlash[Polarization[k]]. The internal representation for a polarization vector e1 corresponding to a boson with four momentum k is: 
Momentum[ Polarization[ k, I ] ]. 
With this notation transversality of polarization vectors is provided, i.e. , 
Pair[ Momentum[k], Momentum[ Polarization[k,  I] ] ] yields 0. 
Polarization[k,-I] denotes the complex conjugate polarization. 
Polarization is also an option of various functions related to the operator product expansion.

The setting 0 denotes the unpolarized and 1 the polarized case.

See also:  PolarizationVector.

Examples

Polarization[k]

Polarization[k]//InputForm

Polarization[k]//ComplexConjugate

Polarization[k]//ComplexConjugate//InputForm

DiracSlash[Polarization[k]]

DiracSlash[Polarization[k]]//InputForm

Pair[ Momentum[k], Momentum[ Polarization[k,  I] ] ]

PolarizationSum

Description

PolarizationSum[ mu,nu, ... ] defines (as abbreviations) several polarization sums. The first two arguments are the interpreted as Lorentz indices, all further ones are momenta. PolarizationSum performs no calculations.

Options[PolarizationSum]

See also:  Polarization.

Examples

PolarizationSum[μ,ν]

PolarizationSum[μ,ν,k]

PolarizationSum[μ,ν,k,n]

PolarizationSum[μ,ν,k,(Subscript[p, 1])-(Subscript[p, 2])]

PolarizationVector

Description

PolarizationVector[p, mu] gives a polarization vector.

See also:  Pair, Polarization.

Examples

PolarizationVector[k,μ]

Conjugate[PolarizationVector[k,μ]]

PolarizationVector[k,mu]//InputForm

a1 = PolarizationVector[k,μ] FourVector[k,μ]

Contract[a1]

a2 = PolarizationVector[k-p,μ] FourVector[k,μ]

Contract[a2]

a3 = PolarizationVector[k-p,μ] FourVector[p,μ]

Contract[a3]

PowerSimplify

Description

PowerSimplify[exp]  simplifies (-x)^a to (-1)^a x^a and (y-x)^n to (-1)^n  (x-y)^n; thus assuming that the exponent is an integer (even if it is symbolic). Furthermore (-1)^(a+n) and I^(a+n) are expanded and (I)^(2 m) -> 
(-1)^m and (-1)^(n_Integer?EvenQ m) -> 1 and (-1)^(n_Integer?OddQ m) ->  (-1)^m and (-1)^(-n) -> (-1)^n and Exp[I m Pi] -> (-1)^m.

See also:  DataType, OPEm.

Examples

PowerSimplify[(-1)^(2OPEm)]

PowerSimplify[(-1)^(OPEm+2)]

PowerSimplify[(-1)^(OPEm-2)]

PowerSimplify[I^(2OPEm)]

PropagatorDenominatorExplicit

Description

PropagatorDenominatorExplicit[exp] changes each occurence of PropagatorDenominator[a,b] in exp into 1/(ScalarProduct[a,a]-b^2) and replaces FeynAmpDenominator by Identity.

See also:  FeynAmpDenominator, PropagatorDenominator.

Examples

FAD[{q,m},{q-p,0}]//FCI

PropagatorDenominatorExplicit[%]//FCE

%//InputForm

PropagatorDenominator

Description

PropagatorDenominator[q, m] is a factor of the denominator of a   propagator. If p is supposed to be D-dimensional enter: 
PropagatorDenominator[Momentum[q,  D], m].  
What is meant is  1/(q^2 - m^2).  PropagatorDenominator[p] evaluates to PropagatorDenominator[p, 0].

See also:  FeynAmpDenominator, PropagatorDenominatorExplicit.

Examples

PropagatorDenominator[p,m]

PropagatorDenominator[p]

t1=PropagatorDenominator[q,m]

InputForm[FCI[t1]]

InputForm[ChangeDimension[t1,D]]

PropagatorDenominatorExplicit[t1]

InputForm[%]

Clear[t1]

QuantumField

Description

QuantumField is the head of quantized fields and their derivatives.
QuantumField[par, ftype, {lorind}, {sunind}] denotes a quantum field of type 
ftype with (possible)  Lorentz-indices  lorind and SU(N)-indices sunind. The optional first argument par denotes a partial derivative acting on the field.

See also:  FeynRule, PartialD, ExpandPartialD.

Examples

This denotes a scalar field.

QuantumField[S]

QuantumField[AntiQuarkField]

QuantumField[QuarkField]

This is a field with a Lorentz index.

QuantumField[B,{μ}]

Color indices should be put after the Lorentz ones.

QuantumField[GaugeField,{μ},{a}]

%//InputForm

(Subscript[A, Δ]^a) is a short form for Δ^μ (Subscript[A, μ]^a).

QuantumField[A,{OPEDelta},{a}]

The first list of indices is usually interpreted as type LorentzIndex, except for OPEDelta, which gets converted to type Momentum.

QuantumField[A,{OPEDelta},{a}]//InputForm

Derivatives of fields are denoted as follows.

QuantumField[PartialD[μ],A,{μ}]

QuantumField[PartialD[OPEDelta],S]

QuantumField[PartialD[OPEDelta],A,{OPEDelta},{a}]

QuantumField[PartialD[OPEDelta]^OPEm,A,{OPEDelta},{a}]

QuantumField[QuantumField[A]] === QuantumField[A]

QuarkField

Description

QuarkField is the name of a fermionic field. QuarkField is just a name with no functional properties. Only typesetting rules are attached.

See also:  AntiQuarkField, QuantumField.

Examples

QuarkField

QuarkGluonVertex

Description

QuarkGluonVertex[μ, a]  gives the Feynman rule for the quark-gluon vertex.

Options[QuarkGluonVertex]

See also:  GluonVertex.

Examples

QuarkGluonVertex[μ,a]

QuarkGluonVertex[μ,a,CounterTerm ->1]

QuarkGluonVertex[μ,a,CounterTerm ->2]

QuarkGluonVertex[μ,a,CounterTerm ->3]

QuarkGluonVertex[{p,μ,a},{q},{k},OPE->True]

QuarkGluonVertex[{p,μ,a},{q},{k},OPE->False]

QuarkPropagator

Description

QuarkPropagator[p] is the massless quark propagator.  
QuarkPropagator[{p,m}] or gives the  quark propagator with mass m.

Options[QuarkPropagator]

See also:  GluonPropagator, QuarkGluonVertex.

Examples

QuarkPropagator[p]

QuarkPropagator[{p,m}]

QuarkPropagator[p,1,2]

RightPartialD

Description

RightPartialD[μ] denotes (∂_μ), acting to the right.

See also:  ExpandPartialD, PartialD, LeftPartialD.

Examples

RightPartialD[μ]

RightPartialD[μ].QuantumField[A,LorentzIndex[μ]]

ExpandPartialD[%]

%//InputForm

RightPartialD[μ]//InputForm

RussianTrick

Description

RussianTrick[exp, k, {q1,q2,p}] (=RussianTrick[exp,p,p,{q1,q2,p}])  does the integration  by parts where p is the external  momentum.  
RussianTrick[exp, k,l, {q1,q2,p}] (=RussianTrick[exp,k,l]) does integration by parts where  l is the momentum to be differentiated.

The result is an expression which is vanishing.

See also:  FourDivergence, FourLaplacian.

Examples

t=RHI[{OPEm,0, 0,0, 0}, {1, 1, 1, 1, 1}]

t//RHI2FC

RussianTrick[%//RHI2FC,q2]

FC2RHI[%]

Solve2[%,t]

Clear[t]

ScalarProduct

Description

ScalarProduct[p, q] is the input for scalar product. ScalarProduct[p] is   equivalent to ScalarProduct[p, p]. Expansion of sums of momenta in   ScalarProduct is done with ExpandScalarProduct. Scalar product may  be set,   e.g., ScalarProduct[a, b] = m^2; but a and b must not contain sums. Note that ScalarProduct[a, b] = m^2 actually sets also: Pair[Momentum[a, ___], Momentum[b, ___]] = m^2. 
It is encouraged  to always set ScalarProduct's before any calculation.  
This  improves the performance of FeynCalc .

See also:  Calc, ExpandScalarProduct, Pair, SP, SPD.

Examples

ScalarProduct[p,q]

ScalarProduct[p+q,-q]

ScalarProduct[p,p]

ScalarProduct[q]

ScalarProduct[p,q]//InputForm

ScalarProduct[p,q,Dimension->D]//InputForm

ScalarProduct[(Subscript[p, 1]),(Subscript[p, 2])] = s/2

ExpandScalarProduct[ ScalarProduct[(Subscript[p, 1])-q,(Subscript[p, 2])-k]]

Calc[ ScalarProduct[(Subscript[p, 1])-q,(Subscript[p, 2])-k]]

ScalarProductCancel

Description

ScalarProductCancel[exp, q1, q2, ...] cancels scalar products with propagators. ScalarProductCancel[exp] cancels simple cases.

SPC

SPC//Options

?SPC

Examples

See also:  FeynAmpDenominatorSimplify.

t1 = SPD[q,p] FAD[{q,m},{q-p,0}]//FCI

ScalarProductCancel[t1,q]

FeynAmpDenominatorSimplify[%,q]

SPC[t1,q,FDS->True]

t2 =  SPD[q2,p]SPD[q1,p] FAD[{q1,m},{q2,m},q1-p,q2-p,q2-q1]//FCI

SPC[t2,q1,q2,FDS->True]

Clear[t1,t2];

SD

Description

SD[i, j] is the (FeynCalc-external) Kronecker-delta for SU(N) with color indices i and j. SD[i,j] is transformed into 
SUNDelta[SUNIndex[i],SUNIndex[j]] by FeynCalcInternal.

See also:  SUNDelta.

Examples

SD[a,b]

%//FCI//InputForm

%//FCE//InputForm

SelectFree

Description

SelectFree[expr, a, b, ...] is equivalent to Select[expr, FreeQ2[#, {a,b, ...}]&], except the special cases: SelectFree[a, b] returns a and SelectFree[a,a] returns 1 (where a is not a product or a sum).

SelectFree is equivalent to Select1.

See also:  FreeQ2, SelectNotFree.

Examples

SelectFree[a+b+f[a]+d,a]

SelectFree[x y, x]

SelectFree[2 x y z f[x], {x,y}]

SelectFree[a,b]

SelectFree[a,a]

SelectFree[1,c]

SelectFree[f[x],x]

SelectNotFree

Description

SelectNotFree[expr, x] returns that part of expr which is not free of any occurance of x.

SelectNotFree[expr, a, b, ...] is equivalent to Select[expr, !FreeQ2[#,  {a, b, ...}]&], except the special cases: SelectNotFree[a,  b] returns 1 and SelectNotFree[a, a] returns a (where a is not a product or a sum).

SelectNotFree is equivalent to Select2.

See also:  FreeQ2, SelectFree.

Examples

SelectNotFree[a+b+f[a],a]

SelectNotFree[2 x y f[x] z,{x,y}]

SelectNotFree[a,b]

SelectNotFree[a+x,b]

SelectNotFree[a,a]

SelectNotFree[1,c]

SelectNotFree[f[x],x]

Series2

Description

Series2 performs a series expansion around 0. Series2 is (up to the Gamma - bug) equivalent to Series, except that it applies Normal on the result and has an option FinalSubstitutions.  Series2[f, e, n] is equivalent to  Series2[f, {e, 0, n}].

Options[Series2]

Examples

Series2[(x (1-x))^(δ/2),δ,1]

Series2[Gamma[x],x,1]

Series[Gamma[x],{x,0,1}]

Series2[Gamma[x],x,2]

Series2[Gamma[x],x,2,FinalSubstitutions->{}]//FullSimplify

Series[Gamma[x],{x,0,4}]//Normal//FullSimplify

There is a table of expansions of special hypergeometric functions.

Series2[HypergeometricPFQ[{1,OPEm-1,Epsilon/2+OPEm},{OPEm,OPEm+Epsilon},1],	     {Epsilon,0,1}]

Series2[HypergeometricPFQ[{1, OPEm, Epsilon/2 + OPEm}, {1 + OPEm, Epsilon + OPEm},    1],{Epsilon,0,1}]

Hypergeometric2F1[1, Epsilon, 1 + 2 Epsilon,x]

Series2[%,{Epsilon,0,3}]

There are over 100 more special expansions of (Subscript[ , 2])(Subscript[F, 1]) tabulated in Series2.m. The interested user can consult the source code  (search for HYPERLIST).

SimplifyDeltaFunction

Description

SimplifyDeltaFunction[exp, x] simplifies f[x]*DeltaFunction[1-x] toLimit[f[x],x->1] DeltaFunction[1-x] and applies a list of transformation  rules for DeltaFunctionPrime[1-x]*x^(OPEm-1)*f[x]   where x^(OPEm-1)  is suppressed in exp.

See also:  DeltaFunction, DeltaFunctionPrime.

Examples

g[x] DeltaFunction[1-x]

SimplifyDeltaFunction[ %,x]

g[x]DeltaFunctionPrime[1-x]

SimplifyDeltaFunction[ %,x]

x Log[x] DeltaFunctionPrime[1-x]

SimplifyDeltaFunction[ %,x]

PolyLog[2,1-x]  DeltaFunctionPrime[1-x]

SimplifyDeltaFunction[ %,x]

Log[x]PolyLog[2,1-x]  DeltaFunctionPrime[1-x]

SimplifyDeltaFunction[ %,x]

PolyLog[3,1-x]  DeltaFunctionPrime[1-x]

SimplifyDeltaFunction[ %,x]

SimplifyPolyLog

Description

SimplifyPolyLog[y] performs several simplifications assuming that the variables occuring in the Log and PolyLog functions are between 0 and 1.

See also:  Nielsen.

Examples

sip[y_] := y == SimplifyPolyLog[y]

sip[PolyLog[2,1/x]]

sip[PolyLog[2,x]]

sip[PolyLog[2,1-x^2]]

sip[PolyLog[2,x^2]]

sip[PolyLog[2,-x/(1-x)]]

sip[PolyLog[2,x/(x-1)]]

sip[Nielsen[1,2,-x/(1-x)]]

sip[PolyLog[3,-1/x]]

sip[PolyLog[3,1-x]]

sip[PolyLog[3,x^2]]

sip[PolyLog[3,-x/(1-x)]]

sip[PolyLog[3,1-1/x]]

sip[PolyLog[4,-x/(1-x)]]

sip[Log[a+b/c]]

sip[Log[1/x]]

sip[ArcTanh[x]]

sip[ArcSinh[x]]

sip[ArcCosh[x]]

Clear[sip]

SOD

Description

SOD[q] is a D-dimensional scalar product of OPEDelta with q. It is transformed into Pair[Momentum[q,D], Momentum[OPEDelta,D] by FeynCalcInternal.

See also:  OPEDelta, Pair, ScalarProduct, SOD.

Examples

SOD[p]

SOD[p-q]

SOD[p]//FCI//InputForm

Solve2

Description

Solve2 is equivalent to Solve, except that it works only for  linear equations (and   returns just a list)  and accepts the options Factoring and FinalSubstitutions.
Solve2 uses the "high school algorithm" and factors intermediate results.Therefore it can be drastically more useful than Solve.

Options[Solve2]

Examples

Solve2[{2 x==b-w/2,y-d==p},{x,y}]

If no equation sign is given the polynomials are supposed to be 0.

Solve2[x+y,x]

Solve2[x+y,x,FinalSubstitutions->{y->h}]

Solve2[{2 x==b-w/2,y-d==p},{x,y},Factoring->Expand]

Solve[{2 x==b-w/2,y-d==p},{x,y}]

SO

Description

SO[q] is a four-dimensional scalar product of OPEDelta with q.
It is transformed into Pair[Momentum[q], Momentum[OPEDelta] by FCI.

See also: FCI, OPEDelta, Pair, ScalarProduct, SOD.

Examples

SO[p]

SO[p-q]

SO[p]//FCI//InputForm

SPD

Description

SPD[a, b] denotes a D-dimensional scalar product. SPD[a, b] is transformed    into ScalarProduct[a, b,Dimension->D] by FeynCalcInternal.  SPD[p] is   the same as SPD[p,p]  (=p^2).

See also:  Calc, ExpandScalarProduct, ScalarProduct.

Examples

SPD[p,q] + SPD[q]

SPD[p-q,q+2p]

Calc[ SPD[p-q,q+2p] ]

ExpandScalarProduct[SPD[p-q]]

SPD[a,b]//InputForm

SPD[a,b]//FCI//InputForm

SPD[a,b]//FCI//FCE//InputForm

FCE[ChangeDimension[SP[p,q], D]]//InputForm

Spinor

Description

Spinor[p, m, optarg] is the head of Dirac spinors. 
Which of the spinors u, v, (OverBar[u]) , or  (OverBar[v]) is understood, depends on the sign of the momentum (p)  argument and the  relative position of DiracSlash[p]: Spinor[sign p, mass]  is that spinor  which yields: sign*mass*Spinor[p, mass] if the Dirac equation is applied  (by   DiracEquation or DiracSimplify).

See also:  DiracSimplify, SpinorU, SpinorV, SpinorUBar, SpinorVBar.

Examples

Spinor[p]

Spinor[p,m]

DiracSimplify[Spinor[-p,m].DiracSlash[p]]

Spinor[p]//InputForm

ChangeDimension[Spinor[p],D]//InputForm

Spinor[p,m]//InputForm

Spinor[p,SmallVariable[m]]//InputForm

SpinorUBar

Description

SpinorUBar[p, m] denotes a (OverBar[u]) - spinor.

See also:  Spinor, SpinorU, SpinorV, SpinorVBar.

Examples

One argument only assumes a massless spinor.

SpinorUBar[p]

SpinorUBar[p,m]

SpinorUBar[p,m]//InputForm

SpinorUBar[p,m]//FCI//InputForm

SpinorUBar[p,m]//FCI//FCE//InputForm

SpinorU

Description

SpinorU[p, m, optarg] denotes a u-spinor.

See also:  Spinor, SpinorUBar, SpinorV, SpinorVBar.

Examples

SpinorU[p]

SpinorU[p,m]

SpinorU[p,m]//InputForm

SpinorU[p,m]//FCI//InputForm

SpinorU[p,m]//FCI//FCE//InputForm

SpinorVBar

Description

SpinorVBar[p, m] denotes a (OverBar[v])(p,m) - spinor.

See also:  Spinor, SpinorU, SpinorV, SpinorUBar.

Examples

SpinorVBar[p]

SpinorVBar[p,m]

SpinorVBar[p,m]//InputForm

SpinorVBar[p,m]//FCI//InputForm

SpinorVBar[p,m]//FCI//FCE//InputForm

SpinorV

Description

SpinorV[p, m, optarg] denotes a v-spinor.

See also:  Spinor, SpinorUBar, SpinorU, SpinorVBar.

Examples

SpinorV[p]

SpinorV[p,m]

SpinorV[p,m]//InputForm

SpinorV[p,m]//FCI//InputForm

SpinorV[p,m]//FCI//FCE//InputForm

SplittingFunction

Description

SplittingFunction[pxy] is a database of splitting functions in the (OverBar[MS]) scheme.

Options[SplittingFunction]

See also:  AnomalousDimension.

Examples

Unpolarized case:

SetOptions[SplittingFunction,Polarization->0];

SplittingFunction[Pqq]

SplittingFunction[Pqg]

SplittingFunction[Pgq]

SplittingFunction[Pgg]

SplittingFunction[aqq]

SplittingFunction[agq]

SplittingFunction[aqg]

SplittingFunction[agg]

Polarized case:

SetOptions[SplittingFunction,Polarization->1];

SplittingFunction[Pqq]

SplittingFunction[Pqg]

SplittingFunction[Pgq]

SplittingFunction[Pgg]

SplittingFunction[aqq]

SplittingFunction[agq]

SplittingFunction[agqd]

SplittingFunction[aqg]

SplittingFunction[aqgd]

SplittingFunction[agg]

SplittingFunction[aggd]

SplittingFunction[PQQS]

SplittingFunction[PQQNS]

SplittingFunction[PQG]

SplittingFunction[PGQ]

SplittingFunction[PGG]

SP

Description

SP[a, b] denotes a four-dimensional scalar product. SP[a, b] is   transformed  into ScalarProduct[a, b] by FeynCalcInternal. SP[p] is the same   as SP[p, p]  (=(p^2)).

See also:  Calc, ExpandScalarProduct, ScalarProduct.

Examples

SP[p,q] + SP[q]

SP[p-q,q+2p]

Calc[ SP[p-q,q+2p] ]

ExpandScalarProduct[SP[p-q]]

SP[a,b]//InputForm

SP[a,b]//FCI//InputForm

SP[a,b]//FCI//FCE//InputForm

SumP

Description

SumP[k, m] is 2^(k-1)(∑_(i=1)^(2m))(1+(-1)^i)/(i^k)

See also:  SumS, SumT.

Examples

SumP[1,m-1]

SumP[2,m-1]

SumP[1,m]

SumP[1,4]

(∑_(i=1)^8)(1+(-1)^i)/i

Explicit[SumP[1,n/2]]

%/.n->8

SumS

Description

SumS[1, m] is the harmonic number (∑_(i=1)^m) i^(-1)  (=(Subscript[S, 1])(m) ).
SumS[1,1,m] is  (∑_(i=1)^m)(Subscript[S, 1])(i)/i.
SumS[k,l,m] is (∑_(i=1)^m) (Subscript[S, l])(i)/(i^k). 
SumS[r, n] represents Sum[Sign[r]^i/i^Abs[r], {i, 1, n}]. 
SumS[r,s,   n] is  Sum[Sign[r]^k/k^Abs[r] Sign[s]^j/j^Abs[s], {k, 1, n}, {j, 1,  k}],   etc.

Options[SumS]

See also:  SumP, SumT.

Examples

SumS[1,m-1]

SumS[2,m-1]

SumS[1,m]

SumS[1,m,Reduce->True]

SumS[3,m+2,Reduce->True]

SetOptions[SumS,Reduce->True];SumS[3,m+2]

SetOptions[SumS,Reduce->False];

SumS[1,4]

(∑_(i=1)^4)1/i

SumS[1,2,m-1]

SumS[1,1,1,11]

SumS[-1,4]

SumT[1,4]

SumT

Description

SumT[1, m] is the alternative harmonic number (∑_(i=1)^m) (-1)^i/i 
SumT[r, n] represents Sum[(-1)^i/i^r, {i,1,n}], 
SumT[r,s, n] is   Sum[1/k^r (-1)^j/j^s, {k, 1, n}, {j, 1, k}].

See also:  SumP, SumS.

Examples

SumT[1,m-1]

SumT[2,m-1]

SumT[1,m]

SumT[1,m,Reduce->True]

SumT[1,4]

(∑_(i=1)^4)(-1)^i/i

SumT[1,2,m-1]

SumT[1,2,42]

SumT[1,4]

SumS[-1,4]

(∑_(i=1)^(m-1))(-1)^i/i

SumT[1,2,12]

SumS[1,-2,42]

Array[SumT,6]

Array[SumS[-2,1,#1]&,6]

SUNDelta

Description

SUNDelta[a, b] is the Kronecker-delta for SU(N) with color indices a and b.

See also:  SD, SUNF, SUNSimplify, Trick.

Examples

SUNDelta[a,b]

Trick[ SUNDelta[a,b] SUNDelta[b,c] ]

SUNDelta[SUNIndex[a],SUNIndex[b]]

SUNDelta[a,b]//InputForm

SUNDelta[a,b]//FCI//InputForm

SUNDelta[a,b]//FCI//FCE//InputForm

SD[a,b]//FCI//InputForm

SUND

Description

SUND[a,b,c] are the symmetric SU(N) (Subscript[d, abc]).

See also:  SUNDelta, SUNF, SUNSimplify.

Examples

SUND[a,b,c]

tt=SUND[a,b,c,Explicit->True]

SUND[c,a,b]

SUND[a,b,b]

SUNSimplify[SUND[a,b,c] SUND[a,b,c]]

SUNSimplify[SUND[a,b,c] SUND[a,b,c],SUNNToCACF->False]//Factor2

SUNSimplify[SUND[a,b,c] SUND[e,b,c],SUNNToCACF->False]//Factor2

SUND[a,b,c]//InputForm

SUND[a,b,c]//FCI//InputForm

SUND[a,b,c]//FCI//FCE//InputForm

SUNF

Description

SUNF[a,b,c] are the structure constants of SU(N).  The arguments a,b,c should be of symbolic type.

Options[SUNF]

See also:  SUND, SUNDelta, SUNIndex, SUNSimplify, SUNT, Trick.

Examples

t1=SUNF[a,b,c]x+SUNF[b,a,c]y

Calc[t1]

SUNSimplify[t1]

SUNF[a,a,b]

SUNF[a,a,b]//Calc

This is a consequence of the usual choice for the normalization of the (Subscript[T, a]) generatorsin (see  SUNT).

SUNF[a,b,c,Explicit->True]

SUNSimplify[SUNF[a,b,c] SUNF[a,b,d]]

SUNSimplify[SUNF[a,b,c],Explicit->True]

SUNF[a,b,c]//InputForm

SUNF[a,b,c]//FCI//InputForm

SUNF[a,b,c]//FCI//FCE//InputForm

SUNF[b,a,c]

SUNF[b,a,c]//FCI

SUNIndex

Description

SUNIndex is the head of SU(N)indices.

See also:  SUNDelta, SUNF.

Examples

SUNIndex[i]

SUNDelta[i,j]//FCI//InputForm

SUNSimplify

Description

SUNSimplify simplifies products of SUNT (and complex conjugated) matrices. 
Basic renaming of dummy indices is done. If the option SUNTrace is set to False, then any SUNT-matrices are taken out of DiracTrace[...]; otherwise a color-trace is taken (by  SUNTrace) before taking the SUN-objects in front of 
DiracTrace[...].

Options[SUNSimplify]

See also:  Trick.

Examples

t1=SUNDelta[a,b] SUNDelta[b,c]

SUNSimplify[t1]

t2=SUNT[a].SUNT[a]

SUNSimplify[t2]

SUNSimplify[t2,SUNNToCACF->False]

t3=SUNF[a,r,s]SUNF[b,r,s]

SUNSimplify[t3]

t4=SUNF[a,b,c] . SUNF[a,b,c]

SUNSimplify[t4]

t5=SUNF[a,b,c] SUNF[d,b,c]

SUNSimplify[t5]

t6=SUNF[a,b,c] SUND[d,b,c]

SUNSimplify[t6,Explicit->True]

SUNSimplify[SUND[a,b,c] SUND[a,b,c],SUNNToCACF->False]//Factor2

SUNSimplify[SUND[a,b,c] SUND[e,b,c],SUNNToCACF->False]//FullSimplify

SUNSimplify[SUNF[a,b,c],Explicit->True]

SUNSimplify[SUND[a,b,c],Explicit->True]

SUNSimplify[SUNF[a,b,c] SUNT[c,b,a]]

a1=SUNF[a,b,e]SUNF[c,d,e]+SUNF[a,b,z]SUNF[c,d,z]

SUNSimplify[a1,Explicit->False]

a2=DiracTrace[SUNT[a,b].DiracMatrix[μ,ν]]

SUNSimplify[a2]

SUNSimplify[a2,SUNTrace->False]

SUNSimplify[a2,SUNTrace->False]//InputForm

SUNT

Description

SUNT[a] is the SU(N) (Subscript[T, a]) generator in the fundamental representation.

See also:  CA, CF, SUND, SUNDelta, SUNF, SUNSimplify.

Examples

SUNT[a]

Since (Subscript[T, a]) is a  noncommutative object, products have to separated by a dot (.).

SUNT[a]. SUNT[b]. SUNT[c]

SUNT[a,b,c,d]

SUNSimplify[SUNT[a,b,a],SUNNToCACF->False]

SUNSimplify[SUNT[a,b,b,a]]

SUNSimplify[SUNT[a,b,a]]

SUNSimplify[SUNT[a,b,a],SUNNToCACF->False]

The normalizaton of the generators is chosen in the standard way,   therefore  tr((Subscript[T, a])(Subscript[T, b])) = 1/2 (Subscript[δ, ab]).

SUNTrace[SUNT[a,b]]

In case you want (Subscript[T, f]), you need to include a factor 2Tf inside the trace.

SUNTrace[2 Tf SUNT[a,b]]

SUNTrace[SUNT[a,b]]//InputForm

SUNT[a]//FCI//InputForm

SUNT[a]//FCI//FCE//InputForm

SUNTrace

Description

SUNTrace[expr] calculates the color-trace.

Options[SUNTrace]

See also:  SUNSimplify, Tr.

Examples

SUNTrace[SUNT[a,b]]

SUNTrace[SUNT[a,b,c]]

SUNTrace[SUNT[a,b,c],Explicit->True]

SUNTrace[SUNT[a,b,c,d]]

t1=SUNTrace[SUNT[a,b,c,d],Explicit->True]

SUNSimplify[t1,Explicit->True]

t2=SUNTrace[SUNT[a,b,c,d,e],Explicit->True]

SUNSimplify[t2,Explicit->True]

SUNSimplify[SUNF[a,b,c] SUND[d,b,c]]

SUNSimplify[SUNF[a,b,c] SUND[a,b,d]]

SUNSimplify[SUNF[a,b,c] SUND[a,d,c]]

SUNSimplify[SUND[a,b,c] SUND[d,b,c]]

Symmetrize

Description

Symmetrize[expr, {a1, a2, ...}] symmetrizes expr w.r.t. to the variables a2,a2. ...

Examples

Symmetrize[f[a,b],{a,b}]

Symmetrize[f[a,b,c,d],{a,b,c}]

Tdec

Description

Tdec[{q,mu}, {p}]; Tdec[{{qi, mu}, {qj, nu}, ...}, {p1, p2, ...}] or Tdec[exp, {{qi, mu}, {qj, nu}, ...}, {p1, p2, ...}]  calculates the tensorialdecomposition formulas. The more common ones are saved in TIDL.

Options[Tdec]

See also:  TID, TIDL, OneLoopSimplify.

Examples

Check that ∫d^Df(p,q)q^μ= p^μ/p^2∫d^Df(p,q)p·q

Tdec[{q,μ},{p}]

%[[2]]/.%[[1]]

This calculates integral transformation for any
 ∫(d^D)(Subscript[q, 1])(d^D)(Subscript[q, 2])(d^D)(Subscript[q, 3])  f(p,(Subscript[q, 1,])(Subscript[q, 2]),(Subscript[q, 3])) (Subscript[q, 1]^μ)(Subscript[q, 2]^ν)(Subscript[q, 3]^ρ).

t=Tdec[{{(Subscript[q, 1]),μ},{(Subscript[q, 2]),ν},{(Subscript[q, 3]),ρ}},{p}];

t[[2]]/.t[[1]]

Contract[% FVD[p,μ]FVD[p,ν] FVD[p,ρ]]//Factor

Clear[t];

Tensorfunction

Description

Tensorfunction[t, mu, nu, ...] transform into t[LorentzIndex[mu], LorentzIndex[nu], ...], i.e., it can be used as an unspecified tensoriell function t. 
A symmetric tensor can be obtained by Tensorfunction[{t, "S"}, mu, nu, ...], and an antisymmteric one by Tensorfunction[{t, "A"}, mu, nu, ...].

See also:  Symmetrize.

Examples

Tensorfunction[t,μ,ν,τ]

%//FullForm

Contract[FV[p,μ] %]

%//InputForm

Tensorfunction[{f,"S"},α,β]

Tensorfunction[{f,"S"},β,α]

%//InputForm

??f

ClearAttributes[f,Orderless]

TFi

Description

TFi[d, pp, {{n1,m1},{n2,m2},{n3,m3},{n4,m4},{n5,m5}}] is the loop 
d-dimensional integral 1/( (q1^2 - m1^2)^n1 (q2^2 - m2^2)^n2 ((q1-p)^2 - 
m3^2)^n3 *((q2-p)^2 - m4^2)^n4 * ((q1-q2)^2 - m5^2)^n5 ) .  

TFi[d, pp, {x,y,z,v,w}, {{n1,m1},{n2,m2},{n3,m3},{n4,m4},{n5,m5}}]  has as 
additional factors in the numerator (q1^2)^x*(q2^2)^y*(q1.p)^z* 
(q2.p)^v*(q1.q2)^w.   

TFi[d, pp, dp, {a,b}, {{n1,m1},{n2,m2},{n3,m3},{n4,m4},{n5,m5}}]  has as 
additional factors in the numerator  (OPEDelta.q1)^a * (OPEDelta.q2)^b; dp is 
(OPEDelta.p).

TFi is similar to TFI from the TARCER package, see  hep-ph/9801383.

The function TarcerRecurse from the TARCER package recognize TFi (as well as TFI, which is defined in the HighEnergyPhysics`Tarcer` context).

See also:  ToTFi, FromTFi.

Examples

TFi[D,M^2,{{2,m1},{1,m2},{3,m3},{1,m4},{1,m5}}]

TFi[D,M^2,{{2,M},1,1,1,1}]

TIDL

Description

TIDL is a database of tensorial reduction formalae.

See also:  TID

Examples

(Subscript[B, μ])-type

In any n-dimensional integral ∫ (d^n) (q^μ) f(q,p) the (q^μ) can be replaced by

TIDL[{q,μ},{p}]

(Subscript[B, μν])-type

TIDL[{{q,μ},{q,ν}},{p}]

(Subscript[C, μ])-type

TIDL[{q,μ},{(Subscript[p, 1]),(Subscript[p, 2])}]

(Subscript[C, μν])-type

TIDL[{{q,μ},{q,ν}},{(Subscript[p, 1]),(Subscript[p, 2])}]

(Subscript[C, μνρ])-type

TIDL[{{q,μ},{q,ν},{q,ρ}},{p,k}];

(Subscript[C, μνρσ])-type

TIDL[{{q,μ},{q,ν},{q,ρ},{q,σ}},{p,k}];

(Subscript[D, μ])-type

TIDL[{q,μ},{(Subscript[p, 1]),(Subscript[p, 2]),(Subscript[p, 3])}]

(Subscript[D, μν])-type

TIDL[{{q,μ},{q,ν}},{p,k,r}];

(Subscript[D, μνρ])-type

TIDL[{{q,μ},{q,ν},{q,ρ}},{p,k,r}];

(Subscript[D, μνρσ])-type

TIDL[{{q,μ},{q,ν},{q,ρ},{q,σ}},{p,k,r,s}];

{Length[%], LeafCount[%],ByteCount[%]}

TID

Description

TID[amp,q] performs a tensorial decomposition.

Options[TID]

See also:  OneLoopSimplify, TIDL.

Examples

FAD[k, k - (Subscript[p, 1]), k - (Subscript[p, 2])]FVD[k,μ]//FCI

Factor/@TID[%,k]//FCE

FAD[k, k - p]FVD[k,μ]//FCI

TID[%,k]

TID[%%,k,FeynAmpDenominatorSimplify->True]

ToDistribution

Description

ToDistribution[exp,x] replaces (1-x)^(a Epsilon - 1) in exp by 1/(a Epsilon)  
DeltaFunction[1-x] + 1/(1-x) + a Epsilon Log[1-x]/(1-x) + 1/2 a^2 Epsilon^2 
Log[1-x]^2/(1-x)] and (1-x)^(a Epsilon - 2) in exp by -1/(a Epsilon) 
DeltaFunctionPrime[1-x] + 1/(1-x)^2 + (a Epsilon) Log[1-x]/(1-x)^2 + a^2 
Epsilon^2/2 Log[1-x]^2/(1-x)^2 + a^3 Epsilon^3/6 Log[1-x]^3/(1-x)^2.

Options[ToDistribution]

See also:  PlusDistribution.

Examples

SetOptions[ToDistribution,PlusDistribution->PlusDistribution]

ToDistribution[(1-x)^(Epsilon-1),x]

SetOptions[ToDistribution,PlusDistribution->Identity]

ToDistribution[(1-x)^(Epsilon-2),x]

Series2[Integrate[(((1-x))^(Epsilon-2)),{x,0,1},GenerateConditions->False],Epsilon,3]

Options@Integrate

Integrate2[ToDistribution[(1-x)^(Epsilon-2),x],{x,0,1}]

ToHypergeometric

Description

ToHypergeometric[t^b (1-t)^c (1+t z)^a, t]  returns 
Γ(b+1)   Γ(c+1)/Γ(b+c+2). (Subscript[, 2])(Subscript[F, 1])(-a,b+1;b+c+2;-z). 
Remember that Re b >0 and Re (c-b) > 0 should hold (need not be set in   Mathematica).

See also:  HypergeometricAC, HypergeometricIR, HypergeometricSE.

Examples

ToHypergeometric[t^b (1-t)^c (1+t z)^a,t]

ToHypergeometric[w t^(b-1) (1-t)^(c-b-1) (1-t z)^(-a),t]

ToHypergeometric[t^b (1-t)^c (u+t z)^a,t]

ToHypergeometric[w t^(b-1) (1-t)^(c-b-1) (u-t z)^(-a),t]

ToLarin

Description

ToLarin[exp] translates all (γ^μ) (γ^5) in exp into -i/6 (ε^(μνλσ))(γ^ν) (γ^λ) (γ^σ).

See also:  Eps.

Examples

DiracMatrix[ν].DiracMatrix[μ].DiracMatrix[5]

ToLarin[%]

ToTFi

Description

ToTFi[expr, q1, q2, p] translates  FeynCalc 2-loop self energy type integrals into the TFi notatation, which can be used as input for the function TarcerRecurse from the TARCER package.  See TFi for details on the conventions.

See also:  TFi, FromTFi.

Examples

FAD[q1,q1-p,{q2,M},{q2-p,m},q1-q2]

ToTFi[%,q1,q2,p]

%//InputForm

SOD[q1] SOD[q2]FAD[q1,q1-p,{q2,M},{q2-p,m},q1-q2]//FCI

ToTFi[%]

%//InputForm

TrickMandelstam

Description

TrickMandelstam[expr, {s, t, u, (Subscript[m, 1]^2) + (Subscript[m, 2]^2)+ (Subscript[m, 3]^2)+ (Subscript[m, 4]^2)}] simplifies all sums in expr  so that one of the Mandelstam variables s,   t or u is eliminated by the relation 
s + t + u = (Subscript[m, 1]^2) + (Subscript[m, 2]^2)+ (Subscript[m, 3]^2)+ (Subscript[m, 4]^2)  .
The trick is that the resulting sum has the most short number of    terms.

Examples

TrickMandelstam[(s+t-u) (2(Subscript[M, W]^2)-t-u),{s,t,u,2(Subscript[M, W]^2)}]//Factor2

TrickMandelstam[M^2 s - s^2 + M^2 t - st + M^2 u - su, {s,t,u,2M^2}]

Trick

Description

Trick[exp] performs several basic simplifications without expansion.
Trick[exp] uses Contract, DotSimplify and SUNDeltaContract.

See also:  Calc, Contract, DiracTrick, DotSimplify, DiracTrick.

Examples

This calculates g^μν(Subscript[γ, μ])  and (Subscript[g, ν]^ν) in D dimensions.

Trick[{GA[μ] MT[μ,ν], MTD[ν,ν]}]

FV[p+r,μ] MT[μ,ν] FV[q-p,ν]

Trick[%]

Trick[c.b.a . GA[d].GA[e]]

%//FCE//InputForm

Tr

Description

Tr[exp] calculates the Dirac trace of exp. Depending on the setting of the option SUNTrace also a trace over SU(N) objects is performed. Tr is identical toDiracTrace, up to the default setting of DiracTraceEvaluate.

Options[Tr]

See also:  DiracSimplify, DiracTrace, SUNTrace.

Examples

GA[μ,ν]

Tr[%]

Tr[(GSD[p]+m).GAD[μ].(GSD[q]-m).GAD[ν]]

Tr[GA[μ,ν,ρ,σ,5]]

Tr[GAD[μ,ν,ρ,σ,τ,ξ,5]]

$West

?$West

$West=False should be set before any calculation is done (because intermediate results from trace calculations are cached).

$West=False

Tr[GAD[(Subscript[ν, 1]),(Subscript[ν, 2]),(Subscript[ν, 3]),(Subscript[ν, 4]),(Subscript[ν, 5]),(Subscript[ν, 6])].GA[5]]

Tr[GS[p,q,r,s]]

Tr[(GS[p]+m).GA[μ].(GS[q]+m).GA[μ],Factoring->True]

Tr[GA[α,β],FCE->True]

%//InputForm

Twist2GluonOperator

Description

Twist2GluonOperator[{p, mu, a}, {nu, b}] or Twist2GluonOperator[p, {mu, a}, {nu, b}] or Twist2GluonOperator[p, mu,a,  nu,b] yields the  2-gluon operator (p is ingoing momentum corresponding to Lorentz index mu).
Twist2GluonOperator[{p,mu,a}, {q,nu,b}, {k,la,c}] or
Twist2GluonOperator[ p,mu,a ,  q,nu,b ,  k,la,c ] gives the 3-gluon operator.
Twist2GluonOperator[{p,mu,a}, {q,nu,b}, {k,la,c}, {s,si,d}] or
Twist2GluonOperator[p,mu,a ,  q,nu,b ,  k,la,c ,  s,si,d]
yields the 4-Gluon operator.
The dimension is determined by the option and Dimension.
The setting of the option Polarization (unpolarized: 0; polarized: 1) 
determines whether the unpolarized or polarized feynman rule is returned.
With the setting Explicit to False  the color-structure and the (1+(-1)^OPEm) 
(for polarized: (1-(-1)^OPEm)) is extracted and the color indices are omitted in the arguments of Twist2GluonOperator.

See also:  Twist2QuarkOperator.

Polarized case, zero-momentum insertion

SetOptions[Twist2GluonOperator, Polarization -> 1,	Explicit->False,  ZeroMomentumInsertion -> True]

2-gluon legs

Twist2GluonOperator[p,{μ,a},{ν,b}]

Twist2GluonOperator[p,{μ,a},{ν,b},Explicit->True]

Twist2GluonOperator[p,{μ},{ν}]

Twist2GluonOperator[p,{μ},{ν},Explicit->True]

3-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},Explicit->True]

4-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c},{s,σ,d}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},{s,σ}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},{s,σ},Explicit->True]

Unpolarized case, zero-momentum insertion

SetOptions[Twist2GluonOperator, Polarization -> 0,	                        ZeroMomentumInsertion -> True]

2-gluon legs

Twist2GluonOperator[p,{μ,a},{ν,b}]

Twist2GluonOperator[p,{μ,a},{ν,b},Explicit->True]

Twist2GluonOperator[p,{μ},{ν}]

Twist2GluonOperator[p,{μ},{ν},Explicit->True]

3-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},Explicit->True]

4-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c},{s,σ,d}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},{s,σ}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},{s,σ},Explicit->True]

Advanced Examples

The setting All for Explicit  performs the sums.

SetOptions[Twist2GluonOperator, Polarization -> 1, Explicit->All];

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c}];

Polarized case, non-zero-momentum insertion

SetOptions[Twist2GluonOperator, Polarization -> 1,ZeroMomentumInsertion->False]

2-gluon legs

Twist2GluonOperator[{p,q},{μ,a},{ν,b}]

3-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c}]

4-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c},{s,σ,d},	Explicit->False]

Unpolarized case, non-zero-momentum insertion

SetOptions[Twist2GluonOperator, Polarization -> 0,ZeroMomentumInsertion->False]

2-gluon legs

Twist2GluonOperator[{p,q},{μ,a},{ν,b}]

3-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c}];

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ}]

Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},Explicit->True]

4-gluon legs

Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c},{s,σ,d},	Explicit->False]

Suppress the lengthy output.

Short[Twist2GluonOperator[{p,μ},{q,ν},{r,ρ},{s,σ},Explicit->True],6]

The setting  Explicit -> All performs the sums.

SetOptions[Twist2GluonOperator, Polarization -> 1, Explicit->All];

Short[Twist2GluonOperator[{p,μ,a},{q,ν,b},{r,ρ,c}],5]

Twist2QuarkOperator

Description

Twist2QuarkOperator[p] or Twist2QuarkOperator[p,_,_] yields the quark-antiquark operator (p is momentum in the direction of the incoming quark).
Twist2QuarkOperator[{p,q}] yields the  2-quark operator for non-zero momentum  insertion (p is momentum in the direction of the incoming quark).

Twist2QuarkOperator[{p1,___}, {p2,___}, {p3, mu, a}] or 
Twist2QuarkOperator[p1,_,_,  p2,_,_,  p3,mu,a] is the quark-antiquark-gluon 
operator, where p1 is the incoming quark, p2 the incoming antiquark and p3 denotes the incoming gluon momentum.

Twist2QuarkOperator[{p1}, {p2}, {p3, mu, a}, {p4, nu, b}] or 
Twist2QuarkOperator[{p1,___}, {p2,___}, {p3, mu, a}, {p4, nu, b}] or Twist2QuarkOperator[p1,_,_,  p2,_,_,  p3,mu,a, p4, nu, b] gives the Quark-Quark-Gluon-Gluon-operator. 

The setting of the option Polarization (unpolarized: 0;  polarized: 1) determines whether the unpolarized or polarized operator is returned

See also:  Twist2GluonOperator.

Examples

Polarized case, zero-momentum insertion

SetOptions[Twist2QuarkOperator,Polarization->1,ZeroMomentumInsertion->True]

Quark-antiquark operator.

t1=Twist2QuarkOperator[p]

Quark-antiquark-gluon operator.

t2=Twist2QuarkOperator[{p},{q},{k,μ,a}]

Quark-antiquark-gluon-gluon operator.

t3=Twist2QuarkOperator[{p},{q},{k,μ,a},{r,ν,b}]

Unpolarized case, zero-momentum insertion

SetOptions[Twist2QuarkOperator, Polarization->0,ZeroMomentumInsertion->True]

Quark-antiquark operator.

t4=Twist2QuarkOperator[p]

Quark-antiquark-gluon operator.

t5=Twist2QuarkOperator[{p},{q},{k,μ,a}]

Quark-antiquark-gluon-gluon operator.

t6=Twist2QuarkOperator[{p},{q},{k,μ,a},{r,ν,b}]

This shows the FeynCalcExternal (FCE) form.

Twist2QuarkOperator[p]//FCE//InputForm

Twist2QuarkOperator[{p},{q},{k,μ,a},Explicit->All,Polarization->0]

Twist2QuarkOperator[{p},{q},{k,μ,a},{r,ν,b},Explicit->All,Polarization->0]

Polarized case, non-zero momentum insertion

SetOptions[Twist2QuarkOperator,Polarization->1,ZeroMomentumInsertion->False]

With the setting ZeroMomentumInsertion -> False a non-zero momentum is assumed to  flow into the operator vertex.

This is the Feynman rule associated with the quark-antiquark operator, where p is the momentum of the incoming quark and q the momentum of the antiquark. The momentum flowing into the operator vertex is thus -p-q.

t1=Twist2QuarkOperator[{p,q}]

This is the quark-antiquark-gluon operator vertex.

t2=Twist2QuarkOperator[{p},{q},{k,μ,a}]

This shows the FeynCalcExternal form.

t2//FCE//InputForm

Unpolarized case, non-zero momentum insertion

SetOptions[Twist2QuarkOperator,Polarization->1,ZeroMomentumInsertion->False]

Quark-antiquark operator.

t4=Twist2QuarkOperator[{p,q}]

Quark-antiquark-gluon operator.

t5=Twist2QuarkOperator[{p},{q},{k,μ,a}]

Clear[t1,t2,t3,t4,t5];

Uncontract

Description

Uncontract[exp, q1, q2, ...] uncontracts  Eps and DiracGamma. Uncontract[exp,  q1, q2, Pair -> {p}] uncontracts also p.q1 and p.q2; the option Pair -> All uncontracts all momenta except OPEDelta.

Options[Uncontract]

See also:  Contract.

Examples

t1 = LeviCivita[μ,ν][p,q]

Uncontract[t1, p]

t2=DiracSlash[p]

Uncontract[t2, p]

Uncontract[t1, p,q]

By default scalar products are not uncontracted.

Uncontract[ScalarProduct[p,q], q]

With the option Pair->All they are “uncontracted  ”.

Uncontract[ScalarProduct[p,q],q,Pair->All]

Uncontract[ScalarProduct[p,q]^2,q,Pair->All]

Clear[t1,t2]

UnDeclareNonCommutative

Description

UnDeclareNonCommutative[a, b, ...] undeclares a,b, ... to be  noncommutative,  i.e., DataType[a,b, ..., NonCommutative] is set to False.

See also:  DataType, DeclareNonCommutative.

Examples

DeclareNonCommutative[x]

As a side-effect of DeclareNonCommutative x is declared to be of DataType NonCommutative.

DataType[x,NonCommutative]

The inverse operation is UnDeclareNonCommutative.

UnDeclareNonCommutative[x]

DataType[x,NonCommutative]

DeclareNonCommutative[y,z]

DataType[y,z,NonCommutative]

UnDeclareNonCommutative[y,z]

DataType[y,z,NonCommutative]

Write2

Description

Write2[file, val1 = expr1, val2 = expr2, ...] writes the settings val1 = expr1, val2 = expr2 in sequence followed by a newline, to the specified output file. Setting the option FormatType of Write2 to FortranForm results in FORTRAN syntax output.

Options[Write2]

Attributes[Write2]

See also:  Isolate, PaVeReduce.

Examples

t=Collect[(a-b-c)^3,a,Factor]

tempfilename=ToString[$SessionID]<>".s"

Write2[tempfilename,r=t];

TableForm[ReadList[If[$OperatingSystem==="MacOS",":",""]<>tempfilename,String]]

DeleteFile[If[$OperatingSystem==="MacOS",":",""]<>tempfilename]

tpol=x+Isolate[t,a]

KK[1]

Write2[tempfilename,r=tpol];

TableForm[ReadList[If[$OperatingSystem==="MacOS",":",""]<>tempfilename,String]]

DeleteFile[If[$OperatingSystem==="MacOS",":",""]<>tempfilename]

Write2[tempfilename,r=tpol,FormatType->FortranForm];

TableForm[ReadList[If[$OperatingSystem==="MacOS",":",""]<>tempfilename,String]]

DeleteFile[If[$OperatingSystem==="MacOS",":",""]<>tempfilename]

Evaluation time and memory usage

AbsoluteTime[]-absolutestarttime

MemoryInUse[]

MaxMemoryUsed[]