- Where-substitutions
- Adding Hermitian conjugate terms
- Using the superpotential formalism in the MSSM and its extensions
- Generation of counterterms
- Constructing the ghost Lagrangian

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:

ltermexpr.

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*(addition),*expr1-expr2*(subtraction),*expr1*expr2*(product),*expr1/expr2*(fraction; here*expr2*must be a product of integers and parameters),*expr1**N*(*N*th power of*expr1*;*N*must be an integer).

More general form of expressions involves *where-substitutions*:

expr.wheresubst

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

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:

is equivalent tolterm F**2 where F=deriv^mu*A^nu-deriv^nu*A^mu.

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

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:

letlsub=(exprwherewsub=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:ltermexpr+ AddHermConj.

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

the conjugate terms are added to bothltermexpr1+ (expr2+ AddHermConj).

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:

Here symbolskeep_lets W.

let W=eps*(mu*H1*H2+ml*H1*L*R+md*H1*Q*D+mu*H2*Q*U).

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:

Herelterm - df(W,H1,H2)*fH1*fH2 - ... + AddHermConj.

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

A better way is to use the functionlterm - df(W,H1)*df(Wc,H1c) - ....

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.lterm - dfdfc(W,H1) - ....

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

forces LanHEP to substitute symbol of a parameter or a particle,transformobj->expr.

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

makes LanHEP substitute each occurence oftransform e -> e+d_e.

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

It declares that a monomial should be omitted if it contains more than one of parametersinfinitesimald_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.

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).

The gauge-fixing Lagrangian reads as:

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:

Here thelet G_A = deriv*A.

lterm -G_A**2/2.

lterm -'A.C'*brst(G_A).

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