Next: Omitting indices Up: The LanHEP Handbook Previous: Objects in the expressions   Contents

Subsections

# Lagrangian expressions

When all parameters and particles necessary for the introduction of a (physical) model are declared, one can enter Lagrangian terms with the help of the lterm statement:

lterm expr.

Elementary objects of expression are integers, identifiers of parameters, particles, specials, let-substitutions, and arrays.

These elementary objects can be combined by the usual arithmetic operators as

• expr1-expr2 (subtraction),
• expr1*expr2 (product),
• expr1/expr2 (fraction; here expr2 must be a product of integers and parameters),
• expr1**N (Nth power of expr1; N must be an integer).
One can use brackets '(' and ')' to force the precedence of operators. Note, that indices can follow only elementary objects symbols, i.e. if A1 and A2 were declared as two vector particles then valid expression for their sum is A1^mu+A2^mu, rather than (A1+A2)^mu.

## Where-substitutions

More general form of expressions involves where-substitutions:

expr where subst.

In the simple form subst is name=repl or several constructions of this type separated by comma ','. In the form of such kind each instance of identifier name in expr is replaced by repl.

Note that in contrast to let-substitutions, where-substitution does not create a new object. LanHEP simply replaces name by repl, and then processes the resulting expression. It means in particular that name can not have indices, although it can denote an object with indices:

lterm F**2 where F=deriv^mu*A^nu-deriv^nu*A^mu.
is equivalent to
lterm (deriv^mu*A^nu-deriv^nu*A^mu)**2.

The substitution rule introduced by the keyword where is active only within the current lterm statement.

More general form of where-substitution allows to use several name=repl substitution rules separated by semicolon ';'. In this case expr will be replaced by the sum of expressions; each term in this sum is produced by applying one of the substitution rules from semicolon-separated list to the expression expr. This form is useful for writing the Lagrangian where many particles have a similar interaction.

For example, if u,d,s,c,b,t are declared as quark names, their interaction with the gluon may read as

lterm gg*anti(psi)*gamma*lambda*G*psi where
psi=u; psi=d; psi=s; psi=c; psi=b; psi=t.

The equivalent form is

lterm gg*U*gamma*lambda*G*u + gg*D*gamma*lambda*G*d +
gg*C*gamma*lambda*G*c + gg*S*gamma*lambda*G*s +
gg*T*gamma*lambda*G*t + gg*B*gamma*lambda*G*b.

Where-substitution can also be used in let statement. In this case one should use brackets:

let lsub=(expr where wsub=expr1).

It is possible to generate hermitian conjugate terms automatically by putting the symbol AddHermConj to lterm statement:

Continuing the former example, one can write:
lterm a*H*H*h + b*H**3 + AddHermConj.

Note, that the symbol AddHermConj adds the hermitian conjugate expressions to all terms in the lterm statement. It means in particular that in the statement

lterm expr1 + (expr2 + AddHermConj).
the conjugate terms are added to both expr1 and expr2. Thus, one should not place self-conjugate terms in the lterm statement where AddHermConj present (or one should supply these terms with factor).

## Using the superpotential formalism in the MSSM and its extensions

In supersymmetric models (in particular, in the Minimal Supersymmetric Standard Model (MSSM) [3]) one makes use of the superpotential -- a polynomial depending on scalar fields (superpotential also can be defined in terms of superfields, we do not consider this case). Then, there is the contribution to the Lagrangian: Yukawa terms in the form

and terms, where (for more details, see [3] and references therein).

To use this formalism in LanHEP, one should define first the multiplets of matter fields and then define the superpotential through the let-substitution statement. The example of the MSSM with a single generation may read:

keep_lets W.
let W=eps*(mu*H1*H2+ml*H1*L*R+md*H1*Q*D+mu*H2*Q*U).
Here symbols H1, H2, L, R, Q, U, D are defined somewhere else as doublets and singlets in terms of scalar particles.

Note that before the definition of W this symbol should appear in the keep_lets statement. It is necessary to notify LanHEP that let-substitutions (multiplets) at the definition of W should not be expanded. Without this statement, the representation used by LanHEP for W will not contain symbols of multiplets but only the particles which were used at multiplets definition.

Since W was declared in the keep_lets statement and contains the symbols of multiplets, one can evaluate the variational derivative of W by one or two multiplets, e.g. df(W,H1) or df(W,H1,L). Thus the Yukawa terms may be written:

lterm - df(W,H1,H2)*fH1*fH2 - ... + AddHermConj.
Here fH1, fH2 are fermionic partners of corresponding multiplets.

To introduce the terms one needs to declare the conjugate superpotential, e.g. Wc, and write:

lterm - df(W,H1)*df(Wc,H1c) - ....
A better way is to use the function dfdfc(W,H1) instead:
lterm - dfdfc(W,H1) - ....
The function evaluates the variational derivative, multiply it by the conjugate expression and returns the result. Moreover, it can introduce auxiliary fields to split vertices with 4 color particles (in the case of CompHEP output); see Section 9 for more details.

## Generation of counterterms

Ultraviolet divergencies in renormalized quantum field theories are compensated by renormalization of wave functions , masses , charges , and may be some other Lagrangian constants. Such transformation of the Lagrangian assumes changes in the Feynman rules. In particular vertices are changed due to the appearence of new terms -- counterterms. It is possible to treat this transformation at 1-loop level by means of LanHEP package.

The statement

transform obj -> expr.
forces LanHEP to substitute symbol of a parameter or a particle, obj, by the expression expr when this object appears in the Lagrangian expressions of the Lagrangian.

For example, if the electric charge in QED is renormalized than the statement

transform e -> e+d_e.
makes LanHEP substitute each occurence of e symbol in further expressions by e+d_e. Of course, e and d_e should be declared as parameters before this statement.

The transform statement is very similar to the let statement and uses the same syntax for expression expr. It has however two advantages. First, one does not need to introduce new name for transformed parameter or field. Second, if one has the LanHEP file for some physical model, it is enough to add counterterms statements into the input file just after the statements declaring parameters and particles.

In 1-loop approximation renormalization parameters appear in expressions only at first power, i.e. , where means all renormalization parameters (, , , ...). This should be done with the help of the following statement

infinitesimal d_Z1, d_Z2, ..., d_Zn.
It declares that a monomial should be omitted if it contains more than one of parameters d_Z1, d_Z2, ..., d_Zn.

An example for QED model with renormalization reads as:

parameter e = 0.3133: 'Electric charge'.
vector A/A:photon.
spinor e1/E1:(electron, mass me=0.000511).
parameter d_e, d_me, d_e1, d_A.
infinitesimal d_e, d_me, d_e1, d_A.
transform e -> e*(1+d_e), me -> me+d_me,
A -> A*(1+d_A),
e1 -> e1 + d_e1*e1,
E1 -> E1 + d_e1*E1.
lterm e*E1*(i*gamma*deriv+gamma*A+me)*e1.

## Constructing the ghost Lagrangian

The ghost Lagrangian can be constructed by means of the BRST formalism. To use it, the user should first declare the BRST transformations for fields (see Section 6.4).

where ( ) are gauge-fixing functions. The ghost Lagrangian ensures the BRST invariance of the entire Lagrangian and can be written as ([7])

where is an overall function, which is BRST-invariant.

So, for the photon and , the LanHEP code for gauge-fixing and ghost terms reads as:

let G_A = deriv*A.
lterm -G_A**2/2.
lterm -'A.C'*brst(G_A).
Here the brst function is used to get BRST-transformation of the specified expression.

The inverse BRST transformation can also be used. One can declare the transformations for the fields by means of brsti_transform. The function brsti(expr) can be used in lterm statements.

Next: Omitting indices Up: The LanHEP Handbook Previous: Objects in the expressions   Contents
Andrei Semenov 2008-02-16