This is a package for calculating bases of operators in effective field theories. It can also be used to compute independent sets of gauge-covariant operators. It includes functionality for doing calculations with semisimple Lie algebra representations.

To obtain a basis of operators, the following input is needed:

• A semisimple Lie algebra. This corresponds to the symmetry group of the field theory.
• A set of fields, with information about their irreducible representation (irrep) under the symmetry group, their charges under an arbitrary number of U(1) factors, their dimension, statistics, etc.

Fixing a maximum dimension, a set of invariant operators constructed using the fields and their derivatives can be computed. Integration by parts redundancy is automatically taken into account. Optionally, equations of motion can be imposed to reduce the number of invariants.

$ pip install basisgen

(Python 3.5+ is required)

As an example, we will compute the weight system for the representation of A₂ = su(3) with highest weight (1 1) (an octet):

>>> from basisgen import irrep
>>> irrep('A2', '1 1').weights_view()
    (1 1)
(2 -1) (-1 2)
 (0 0) (0 0)
(1 -2) (-2 1)
   (-1 -1)

The decomposition of the tensor product of (1 0) and (0 1) (a triplet and an anti-triplet) is done directly as:

>>> irrep('A2', '1 0') * irrep('A2', '0 1')
[1 1] + [0 0]

This also works for semisimple algebras:

>>> irrep('B2 + G2', '0 2 1 0 0 0').weights_view()
     (0 2 1 0)
     (0 2 -1 3)
      (0 2 0 1)
     (0 2 1 -1)
(0 2 -1 2) (0 2 2 -3)
 (0 2 0 0) (0 2 0 0)
(0 2 1 -2) (0 2 -2 3)
     (0 2 -1 1)
     (0 2 0 -1)
     (0 2 1 -3)
     (0 2 -1 0)

The group notation (using SO, SU and Sp for simple algebras and x for their direct sum) can be used. For example an SU(3) triplet, SU(2) doublet would be:

>>> irrep('SU3 x SU2', '1 0 1').weights_view()
     (1 0 1)
(-1 1 1) (1 0 -1)
(0 -1 1) (-1 1 -1)
    (0 -1 -1)

Consider a simple EFT: a scalar SU(2) doublet with hypercharge 1/2. To compute all the independent invariants built with this field and its derivatives (using integration by parts and equations of motion) we can write the script:

from basisgen import algebra, irrep, scalar, Field, EFT

phi = Field(
    name='phi',
    lorentz_irrep=scalar,
    internal_irrep=irrep('SU2', '1'),
    charges=[1/2]
)

my_eft = EFT(algebra('SU2'), [phi, phi.conjugate])

invariants = my_eft.invariants(max_dimension=8)

print(invariants)
print("Total:", invariants.count())

This code can be also found in examples/simple.py. Running it gives:

$ python simple.py
phi phi*: 1
(phi)^2 (phi*)^2: 1
(phi)^2 (phi*)^2 D^2: 2
(phi)^2 (phi*)^2 D^4: 3
(phi)^3 (phi*)^3: 1
(phi)^3 (phi*)^3 D^2: 2
(phi)^4 (phi*)^4: 1
Total: 11

Each line gives the number of independent invariant operators with the specified field content (and number covariant derivatives).

The SMEFT is defined in basisgen.smeft. See the code there for a more complex example. The script examples/standard_model.py makes use of this module. To obtain the dimension 8 operators in the SMEFT (with one generation), do:

$ python standard_model.py --dimension 8

This gives 993 invariants (in ~ 40 seconds in a 2,6 GHz Intel Core i5). This agrees with arXiv:1512.03433. For dimension 9, it gives 560 operators (in 3 minutes), and for dimension 10, 15456 (in 15 minutes).

Do python standard_model.py --help to see more options included in the script. For example, the dimension-6 SMEFT with 3 generations of fermions is obtained by:

$ python standard_model.py --dimension 6 --number_of_flavors 3

As another example, consider the Georgi-Glashow model of grand unification. The internal symmetry group is SU(5). The independent terms in the scalar potential can be found using the following code:

from basisgen import irrep, algebra, boson, scalar, Field, EFT

irrep_5 = irrep('SU5', '1 0 0 0')
irrep_24 = irrep('SU5', '1 0 0 1')

Phi = Field(
    name='Phi',
    lorentz_irrep=scalar,
    internal_irrep=irrep_24,
    statistics=boson,
    dimension=1
)

phi = Field(
    name='phi',
    lorentz_irrep=scalar,
    internal_irrep=irrep_5,
    statistics=boson,
    dimension=1
)

SU5_GUT_scalar_sector = EFT(algebra('SU5'), [Phi, phi, phi.conjugate])

print(SU5_GUT_scalar_sector.invariants(max_dimension=4, verbose=True))

Its output is:

phi phi*: 1
(phi)^2 (phi*)^2: 1
Phi phi phi*: 1
(Phi)^2: 1
(Phi)^2 phi phi*: 2
(Phi)^3: 1
(Phi)^4: 2

Gauge field strength tensors can be defined as any other field using the Field class constructor. However, it is convenient to use the static method Field.strength_tensors to directly obtain a pair of dimension-2 boson fields transforming under Lorentz as (1, 0) and (0, 1), respectively. An example of use:

from basisgen import irrep, algebra, Field, EFT

BL, BR = Field.strength_tensors(
    name='B',
    internal_irrep=irrep('SU2', '0'),
    charges=[0],
)

my_eft = EFT(algebra('SU2'), [BL, BR])

invariants = my_eft.invariants(max_dimension=8, use_eom=False)

print(invariants)

The Field.strength_tensors method ensures that Bianchi identities are used to reduce the basis, even in use_eom=False mode. This is demonstrated in the example above. If the fields BL and BR where naively defined using the Field constructor, setting use_eom=False prevents the Bianchi identities from being used, as they take the same form as the equation of motion for the dual field strength tensor. Field.strength_tensors forces the use of the equations of motion for one of the 2 fields it creates. Equivalently, this can be done manually by setting BR._force_use_eom=True.

If you use this work, please cite: https://arxiv.org/abs/1901.03501