Modules documentation

The operators module

Core module with the definitions of the basic building blocks: the classes Tensor, Operator, and OperatorSum. Implements the Leibniz rule for derivatives and the algorithms for matching and replacing as well as functional derivatives.

Defines interfaces for the creation of tensors, fields, operators and operator sums: TensorBuilder, FieldBuilder, Op() and OpSum(); the interface for creating derivatives of single tensors: the function D(); and interfaces for creating special single-tensor associated to (complex) numbers and powers of constants.

Defines the Lorentz tensors epsUp, epsUpDot, epsDown, epsDownDot, sigma4 and sigma4bar.

class matchingtools.core.Tensor(name, indices, is_field=False, num_of_der=0, dimension=0, statistics=True, content=None, exponent=None)

Basic building block for operators.

A tensor might have some derivatives applied to it. The indices correponding to the derivatives are given by the first indices in the list of indices of the Tensor.

name

identifier

Type:string
indices

indices of the tensor and the derivaties applied to it

Type:list of ints
is_field

specifies whether it is non-constant

Type:bool
num_of_der

number of derivatives acting

Type:int
dimension

energy dimensions

Type:int
statistics

True for bosons and False for fermions

Type:bool
content

to be used internally to carry associated data

exponent

to be used internally to simplify repetitions of a tensor

class matchingtools.core.Operator(tensors)

Container for a list of tensors with their indices contracted.

Indices repeated in different tensors mean contraction. Contracted indices should be positive. Negative indices represent free indices and should appear in order: -1, -2, …

The methods include the basic derivation, matching and replacing operations, as well as the implementation of functional derivatives.

tensors

list of the tensors contained

Type:[Tensor]
variation(field_name, statistics)

Take functional derivative of the spacetime integral of self:

Parameters:
  • field_name (string) – the name of the field with respect to which the functional derivative is taken
  • statistics (bool) – statistics of the field
replace_first(field_name, operator_sum)

Replace the first ocurrence of a field.

Parameters:
  • field_name (string) – name of the field to be replaced
  • operator_sum (OperatorSum) – replacement
Returns:

An OperatorSum resulting from replacing the first ocurrence of the field by its replacement

replace_all(substitutions, max_dim)

Replace all ocurrences of several fields.

Parameters:
  • substitutions ([(string, OperatorSum)]) – list of pairs with the first element of the pair being the name of a field to be replaced and the second being the replacement.
  • max_dim (int) – maximum dimension of the operators in the result
Returns:

An OperatorSum resulting from replacing every ocurrence of the fields by their replacements

match_first(pattern)

Match the first ocurrence of a pattern

Parameters:pattern (Operator) – contains the tensors and index structure to be matched
Returns:
if the matching succeeds, an Operator with the first occurrence
of the pattern substituted by a “generic” tensor (with a sign change if needed); None otherwise
__eq__(other)

Match self with other operator. All tensors and index contractions should match. No sign differences allowed. All free indices should be equal.

class matchingtools.core.OperatorSum(operators=None)

Container for lists of operators representing their sum.

The methods perform the basic operations defined for operators generalized for sums of them

operators

the operators whose sum is represented

Type:[Operator]
variation(field_name, statistics)

Take functional derivative of the spacetime integral of self.

Parameters:
  • field_name (string) – the name of the field with respect to which the functional derivative is taken
  • statistics (bool) – statistics of the field
replace_all(substitutions, max_dim)

Replace all ocurrences of several fields.

Parameters:
  • substitutions ([(string, OperatorSum)]) – list of pairs with the first element of the pair being the name of a field to be replaced and the second being the replacement.
  • max_dim (int) – maximum dimension of the operators in the result
Returns:

An OperatorSum resulting from replacing every ocurrence of the fields by their replacements

class matchingtools.core.TensorBuilder(name)

Interface for the creation of constant tensors.

name

the name attribute of the tensors to be created

Type:string
__call__(*indices)

Creates a Tensor object with the given indices and the following attributes: is_field = False, num_of_der = 0, dimension = 0, statistics = boson

class matchingtools.core.FieldBuilder(name, dimension, statistics)

Interface for the creation of fields.

name

identifier of the fields to be created

Type:string
dimension

energy dimensions of the fields to be created

Type:int
statistics

statistics of the fields to be created

Type:bool
__call__(*indices)

Creates a Tensor object with the given indices and the following attributes: is_field = True, num_of_der = 0

matchingtools.core.D(index, tensor)

Interface for the creation of tensors with derivatives applied.

matchingtools.core.D_op(index, *tensors)

Interface for the creation of operator sums of obtained from de application of derivatives to producs of tensors.

matchingtools.core.Op(*tensors)

Interface for the creation of operators

matchingtools.core.OpSum(*operators)

Interface for the creation of operator sums

matchingtools.core.number_op(number)

Create an operator correponding to a number.

matchingtools.core.power_op(name, exponent, indices=None)

Create an operator corresponding to a tensor exponentiated to some power.

matchingtools.core.tensor_op(name, indices=None)
matchingtools.core.flavor_tensor_op(name)

Interface for the creation of one-tensor operators with indices

matchingtools.core.kdelta

Kronecker delta. To be replaced by the correponding index contraction appearing instead (module transformations).

matchingtools.core.generic

Generic tensor to be used for intermediate steps in calculations and in the output of matching.

matchingtools.core.epsUp

Totally anti-symmetric tensor with two two-component spinor undotted superindices

matchingtools.core.epsUpDot

Totally anti-symmetric tensor with two two-component spinor dotted superindices

matchingtools.core.epsDown

Totally anti-symmetric tensor with two two-component spinor undotted subindices

matchingtools.core.epsDownDot

Totally anti-symmetric tensor with two two-component spinor dotted subindices

matchingtools.core.sigma4bar

Tensor with one lorentz index, one two-component spinor dotted superindex and one two-component spinor undotted superindex. Represents the four-vector of 2x2 matrices built out identity and minus the Pauli matrices.

matchingtools.core.sigma4

Tensor with one lorentz index, one two-component spinor undotted subindex and one two-component spinor dotted subindex. Represents the four-vector of 2x2 matrices built out identity and the Pauli matrices.

The integration module

Module for the integration of heavy fields from a high-energy lagrangian. Contains the function integrate() and the classes for representing the different types of heavy fields.

class matchingtools.integration.RealScalar(name, num_of_inds, has_flavor=True, order=2, max_dim=4)

Representation for heavy real scalar bosons.

The has_flavor argument to the constructor is a bool that specifies whether there are several generations of the heavy field, whereas the order argument gives a maximum order in the derivatives for the propagator.

name

name identifier of the corresponding tensor

Type:string
num_of_inds

number of indices of the corresponding tensor

Type:int
class matchingtools.integration.ComplexScalar(name, c_name, num_of_inds, has_flavor=True, order=2, max_dim=4)

Representation for heavy complex scalar bosons.

The has_flavor argument to the constructor is a bool that specifies whether there are several generations of the heavy field, whereas the order argument gives a maximum order in the derivatives for the propagator.

name

name identifier of the corresponding tensor

Type:string
c_name

name identifier of the conjugate tensor

Type:string
num_of_inds

number of indices of the corresponding tensor

Type:int
class matchingtools.integration.RealVector(name, num_of_inds, has_flavor=True, order=2, max_dim=4)

Representation for heavy real vector bosons.

The has_flavor argument to the constructor is a bool that specifies whether there are several generations of the heavy field, whereas the order argument gives a maximum order in the derivatives for the propagator.

name

name identifier of the corresponding tensor

Type:string
num_of_inds

number of indices of the corresponding tensor

Type:int
class matchingtools.integration.ComplexVector(name, c_name, num_of_inds, has_flavor=True, order=2, max_dim=4)

Representation for heavy complex vector bosons.

The has_flavor argument to the constructor is a bool that specifies whether there are several generations of the heavy field, whereas the order argument gives a maximum order in the derivatives for the propagator.

name

name identifier of the corresponding tensor

Type:string
c_name

name identifier of the conjugate tensor

Type:string
num_of_inds

number of indices of the corresponding tensor

Type:int
class matchingtools.integration.VectorLikeFermion(name, L_name, R_name, Lc_name, Rc_name, num_of_inds, has_flavor=True)

Representation for heavy vector-like fermions

The has_flavor argument to the constructor is a bool that specifies whether there are several generations of the heavy field.

name

name of the field

Type:string
L_name

name of the left-handed part

Type:string
R_name

name of the right-handed part

Type:string
Lc_name

name of the conjugate of the left-handed part

Type:string
Rc_name

name of the conjugate of the right-handed part

Type:string
num_of_inds

number of indices of the corresponding tensor

Type:int
class matchingtools.integration.MajoranaFermion(name, c_name, num_of_inds, has_flavor=True)

Representation for heavy Majorana fermions.

The has_flavor argument to the constructor is a bool that specifies whether there are several generations of the heavy field.

name

name identifier of the corresponding tensor

Type:string
c_name

name identifier of the conjugate tensor

Type:string
num_of_inds

number of indices of the corresponding tensor

Type:int
matchingtools.integration.integrate(heavy_fields, interaction_lagrangian, max_dim=6, verbose=True)

Integrate out heavy fields.

Heavy field classes: RealScalar, ComplexScalar, RealVector, ComplexVector, VectorLikeFermion or MajoranaFermion.

Parameters:
  • heavy_fields (list of heavy fields) – to be integrated out
  • interaction_lagrangian (matchingtools.operators.OperatorSum) – from which to integrate out the heavy fields
  • max_dim (int) – maximum dimension of the operators in the effective lagrangian
  • verbose (bool) – specifies whether to print messages signaling the start and end of the integration process.

The transformations module

Module dedicated to the transformation and simplification of operators and operator sums. Defines functions for collecting numeric and symbolic factors.

Implements the function apply_rules() for the systematic substitution of patterns inside operators in an operator sum until writing the sum it in a given basis of operators; and the function collect() for collecting the coefficients of each operator in a given list.

matchingtools.transformations.collect_numbers(operator)

Collect all the tensors representing numbers into a single one.

A tensor is understood to represent a number when its name is "$number" or $i.

matchingtools.transformations.collect_powers(operator)

Collect all the tensors that are equal and return the correspondin powers.

matchingtools.transformations.collect_numbers_and_powers(op_sum)

Collect the numeric factors and powers of tensors.

matchingtools.transformations.apply_rule(operator, pattern, replacement)

Replace the first occurrence of pattern by replacement in operator

matchingtools.transformations.apply_rules(op_sum, rules, max_iterations, verbose=True)

Apply all the given rules to the operator sum.

With the adecuate set of rules this function can be used to express an effective lagrangian in a specific basis of operators

Parameters:
  • op_sum (matchingtools.operator.OperatorSum) – to which the rules should be applied.
  • rules (list of pairs (matchingtools.operators.Operator, matchingtools.operators.OperatorSum)) – The first element of each pair represents a pattern to be subtituted in each operator by the second element using apply_rule().
  • max_iterations (int) – maximum number of application of rules to each operator.
  • verbose (bool) – specifies whether to print messages signaling the start and end of the integration process
Returns:

OperatorSum containing the result of the application of rules.

matchingtools.transformations.collect_by_tensors(op_sum, tensor_names)

Collect the coefficients of the given tensors.

Usually, these tensors represent operators of a basis in which the effective lagrangian is expressed.

Parameters:
  • op_sum (OperatorSum) – whose terms are to be collectd
  • tensor_names (list of strings) – names of the tensors whose coefficients will be obtained
Returns:

A pair (collection, rest) where collection is a list of pairs (name, coef) where name is the name of each of the tensors and coef is an OperatorSum representing its coefficients; and where rest is an OperatorSum with the operators that didn’t contain a tensor with one of the given names.

matchingtools.transformations.collect(op_sum, tensor_names, verbose=True)

Simplify the numeric and exponentiated symbolic tensors (using collect_numbers_and_powers()) and collect the coefficients of the given tensors (using collect_by_tensors()).

Parameters:
  • op_sum (OperatorSum) – whose terms are to be collected
  • tensor_names (list of strings) – names of the tensors whose coefficients will be obtained
  • verbose (bool) – specify whether to write messages signaling the start and end of the computation.

The output module

Module dedicated to the conversion of operator sums to plain text and latex code.

Defines the class Writer to represent the coefficients of some given operators in both formats.

class matchingtools.output.Writer(op_sum, op_names, conjugates=None, verbose=True)

Class to write an operator sum in various formats.

The coefficients of the tensors with the given names are collected and prepared to be written.

collection (list of pairs (string, list of pairs

(complex, Operator)): the first element of each pair in the main list is the name of the tensor having the second part as coefficient. The pairs in the list that is the second element represent a numeric coefficient and an Operator (product of tensors) that multiplied together and summed with the others give the complete coefficient.

rest

represents a sum of the operators that couldn’t be collected with their corresponding coefficients.

Type:list of pairs (complex, Operator)
conjugates (dictionary string

string): name of the complex conjugate corresponding to the name of each tensor. If it is not None, this is used for collecting conjugate pairs to give their real or imaginary parts.

no_parens

names of tensors that, when having a non-unit exponent are to represented in latex as tensor^exp instead of (tensor)^exp

Type:list of strings
numeric

names of tensors that symbolically represent numbers. The effect of this is the latex output: they come after the “$number” tensors and before the “$i”.

Type:list of strings
__init__(op_sum, op_names, conjugates=None, verbose=True)
Parameters:
  • op_sum (OperatorSum) – to be represented
  • op_names (list of strings) – the names of the tensors (represented as tensors) whose coefficients are to be collected and written
__str__()

Plain text representation

write_text_file(filename)
latex_code(structures, op_reps, inds, no_parens=None, numeric=None)

Representation as LaTeX’s amsmath align environments

Parameters:
  • structures (dict) – the keys are the names of all the tensors. The corresponding values are the LaTeX formula representation, using python`s str.format notation "{}" to specify the popsitions where the indices should appear.
  • structures – the keys are the names of all the operators in the basis. The corresponding values are the LaTeX formula representation.
  • inds (list of strings) – the symbols to be used to represent the indices, in the order in which they should appear.
  • no_parens (function) – receives the name of a tensor and returns True if its LaTeX representation should not have parenthesis around it when exponentiated to some power.
  • numeric (list of strings) – list of names of tensors that should appear with the numeric coefficients in the representation, before the rest of the tensors.
write_latex(filename, structures, op_reps, inds, no_parens=None, numeric=None)

Write a LaTeX document with the representation.

Parameters:
  • filename (string) – the name of the file without the extension ".tex" in which to write
  • structures (dict) – the keys are the names of all the tensors. The corresponding values are the LaTeX formula representation, using python`s str.format notation "{}" to specify the positions where the indices should appear.
  • structures – the keys are the names of all the operators in the basis. The corresponding values are the LaTeX formula representation.
  • inds (list of strings) – the symbols to be used to represent the indices, in the order in which they should appear.
  • no_parens (function) – receives the name of a tensor and returns True if its LaTeX representation should not have parenthesis around it when exponentiated to some power.
  • numeric (list of strings) – list of names of tensors that should appear with the numeric coefficients in the representation, before the rest of the tensors.
show_pdf(filename, pdf_viewer, structures, op_reps, inds)

Directly show the pdf file with the results, obtained using pdflatex on the .tex file.

Parameters:
  • filename (string) – the name of the files without the extension ".tex" and .pdf in which to write.
  • pdfviewer (string) – name of the program (callable from the command-line) to show the pdf.
  • structures (dict) – the keys are the names of all the tensors. The corresponding values are the LaTeX formula representation, using python`s str.format notation "{}" to specify the positions where the indices should appear.
  • structures – the keys are the names of all the operators in the basis. The corresponding values are the LaTeX formula representation.
  • inds (list of strings) – the symbols to be used to represent the indices, in the order in which they should appear.v

The extras package

The matchingtools.extras package provides several modules with some useful definitions of tensors related to the Lorentz group and the groups \(SU(3)\) and \(SU(2)\), as well as rules for transforming some combinations of these tensors into others.

The definitions for the Standard Model tensors and fields, together with the rules derived from their equations of motion for the substitution of their covariant derivatives are provided. A basis for the Standard Model effective Lagrangian up to dimension 6 is also given.

The extras.SU2 module

This module defines tensors and rules related to the group \(SU(2)\).

matchingtools.extras.SU2.epsSU2

Totally antisymmetric tensor \(\epsilon=i\sigma^2\) with two \(SU(2)\) doublet indices such that \(\epsilon_{12}=1\).

matchingtools.extras.SU2.sigmaSU2

Pauli matrices \((\sigma^a)_{ij}\).

matchingtools.extras.SU2.CSU2

Clebsh-Gordan coefficients \(C^I_{a\beta}\) with the first index \(I\) being a quadruplet index, the second \(a\) a triplet index, and the third \(\beta\) a doublet index.

matchingtools.extras.SU2.CSU2c

Conjugate of the Clebsh-Gordan coefficients \(C^I_{a\beta}\).

matchingtools.extras.SU2.epsSU2triplets

Totally antisymmetric tensor \(\epsilon_{abc}\) with three \(SU(2)\) triplet indices such that \(\epsilon_{123}=1\).

matchingtools.extras.SU2.epsSU2quadruplets

Two-index that gives a singlet when contracted with two \(SU(2)\) quadruplets.

matchingtools.extras.SU2.fSU2

Totally antisymmetric tensor with three \(SU(2)\) triplet indices given by \(f_{abc}=\frac{i}{\sqrt{2}}\epsilon_{abc}\) with \(\epsilon_{123}=1\).

matchingtools.extras.SU2.rule_SU2_fierz

Subtitute \(\sigma^a_{ij} \sigma^a_{kl}\) by \(2\delta_{il}\delta_{kj} - \delta_{ij}\delta{kl}\).

matchingtools.extras.SU2.rule_SU2_product_sigmas

Subtitute \(\sigma^a_{ij}\sigma^a_{jk}\) by \(3\delta_{ik}\).

matchingtools.extras.SU2.rule_SU2_free_eps

Subtitute \(\epsilon_{ij}\epsilon_{kl}\) by \(\delta_{ik}\delta_{jl}-\delta_{il}\delta_{jk}\).

matchingtools.extras.SU2.rules_SU2_eps_cancel

Substitute contracted \(\epsilon\) tensors with the corresponding Kronecker delta.

matchingtools.extras.SU2.rule_SU2_eps_zero

Substitute \(\epsilon_{ii}\) by zero because \(\epsilon\) is antisymmetric.

matchingtools.extras.SU2.rules_SU2_epsquadruplets_cancel

Substitute contracted \(\epsilon\) tensors with the corresponding Kronecker delta.

matchingtools.extras.SU2.rules_SU2_C_sigma

Substitute \(C^I_{ap}\epsilon_{pm}\sigma^a_{ij} C^{I*}_{bq}\epsilon_{qn}\sigma^b_{kl}\) by the equivalent \(-\frac{2}{3}\delta_{mn}\delta_{ij}\delta_{kl} +\frac{4}{3}\delta_{mn}\delta_{il}\delta_{kj} +\frac{2}{3}\delta_{ml}\delta_{in}\delta_{kj} -\frac{2}{3}\delta_{mj}\delta_{il}\delta_{kn}\).

matchingtools.extras.SU2.rules_SU2

All the rules defined in matchingtools.extras.SU2 together

matchingtools.extras.SU2.latex_SU2

LaTeX code representation of the \(SU(2)\) tensors.

The extras.SU3 module

This module defines tensors related to the group \(SU(3)\).

matchingtools.extras.SU3.epsSU3

Totally antisymmetric tensor \(\epsilon_{ABC}\) with three \(SU(3)\) triplet indices such that \(\epsilon_{123}=1\).

matchingtools.extras.SU3.TSU3

\(SU(3)\) generators \((T_A)_{BC}\) (half of the Gell-Mann matrices).

matchingtools.extras.SU3.fSU3

\(SU(3)\) structure constants \(f_{ABC}\).

The extras.Lorentz module

This module defines rules related to the Lorentz group.

matchingtools.extras.Lorentz.eps4

Totally antisymmetric tensor with four Lorentz vector indices \(\epsilon_{\mu\nu\rho\sigma}\) where \(\epsilon_{0123}=1\).

matchingtools.extras.Lorentz.sigmaTensor

Lorentz tensor \(\sigma^{\mu\nu}=\frac{i}{4}\left( \sigma^\mu_{\alpha\dot{\gamma}}\bar{\sigma}^{\nu\dot{\gamma}\beta}- \sigma^\nu_{\alpha\dot{\gamma}}\bar{\sigma}^{\mu\dot{\gamma}\beta} \right)\).

matchingtools.extras.Lorentz.rule_Lorentz_free_epsUp

Substitute \(\epsilon^{\alpha\beta}\epsilon^{\dot{\alpha}\dot{\beta}}\) by

\[-\frac{1}{2} \bar{\sigma}^{\mu,\dot{\alpha}\alpha} \bar{\sigma}^{\dot{\beta}\beta}_\mu\]
matchingtools.extras.Lorentz.rule_Lorentz_free_epsDown

Substitute \(\epsilon_{\alpha\beta}\epsilon_{\dot{\alpha}\dot{\beta}}\) by

\[-\frac{1}{2} \bar{\sigma}^\mu_{\alpha\dot{\alpha}} \bar{\sigma}_{\mu,\beta\dot{\beta}}\]
matchingtools.extras.Lorentz.rules_Lorentz_eps_cancel

Substitute contracted \(\epsilon\) tensors with undotted indices by the corresponding Kronecker delta.

matchingtools.extras.Lorentz.rules_Lorentz_epsDot_cancel

Substitute contracted \(\epsilon\) tensors with dotted indices by the corresponding Kronecker delta.

matchingtools.extras.Lorentz.rules_Lorentz

All the rules defined in matchingtools.extras.Lorentz together

matchingtools.extras.Lorentz.latex_Lorentz

LaTeX code representation of the Lorentz tensors.

The extras.SM module

This module defines the Standard Model tensors and fields and the rules for substituting their equations of motion.

matchingtools.extras.SM.gb

\(U(1)\) coupling constant \(g'\)

matchingtools.extras.SM.gw

\(SU(2)\) coupling constant \(g\)

matchingtools.extras.SM.mu2phi

Higgs quadratic coupling \(\mu^2_\phi\)

matchingtools.extras.SM.lambdaphi

Higgs quartic coupling \(\lambda_\phi\)

matchingtools.extras.SM.ye

Yukawa coupling for leptons \(y^e_{ij}\)

matchingtools.extras.SM.yec

Conjugate of the Yukawa coupling for leptons \(y^{e*}_{ij}\)

matchingtools.extras.SM.yd

Yukawa coupling for down quarks \(y^d_{ij}\)

matchingtools.extras.SM.ydc

Conjugate of the Yukawa coupling for down quarks \(y^{d*}_{ij}\)

matchingtools.extras.SM.yu

Yukawa coupling for up quarks \(y^u_{ij}\)

matchingtools.extras.SM.yuc

Conjugate of the Yukawa coupling for up quarks \(y^{u*}_{ij}\)

matchingtools.extras.SM.V

CKM matrix

matchingtools.extras.SM.Vc

Conjugate of the CKM matrix

matchingtools.extras.SM.deltaFlavor

Kronecker delta for flavor indices

matchingtools.extras.SM.phi

Higgs doublet

matchingtools.extras.SM.phic

Conjugate of the Higgs doublet

matchingtools.extras.SM.lL

Lepton left-handed doublet

matchingtools.extras.SM.lLc

Conjugate of the lepton left-handed doublet

matchingtools.extras.SM.qL

Quark left-handed doublet

matchingtools.extras.SM.qLc

Conjugate of the quark left-handed doublet

matchingtools.extras.SM.eR

Electron right-handed singlet

matchingtools.extras.SM.eRc

Conjugate of the electron right-handed singlet

matchingtools.extras.SM.dR

Down quark right-handed doublet

matchingtools.extras.SM.dRc

Conjugate of the down quark right-handed doublet

matchingtools.extras.SM.uR

Up quark right-handed doublet

matchingtools.extras.SM.uRc

Conjugate of the up quark right-handed doublet

matchingtools.extras.SM.bFS

\(U(1)\) gauge field strength \(B_{\mu\nu}\)

matchingtools.extras.SM.wFS

\(SU(2)\) gauge field strength \(W^a_{\mu\nu}\)

matchingtools.extras.SM.gFS

\(SU(3)\) gauge field strength \(G^A_{\mu\nu}\)

matchingtools.extras.SM.eom_phi

Rule using the Higgs doublet equation of motion. Substitute \(D^2\phi\) by

\[\mu^2_\phi \phi- 2\lambda_\phi (\phi^\dagger\phi) \phi - y^{e*}_{ij} \bar{e}_{Rj} l_{Li} - y^{d*}_{ij} \bar{d}_{Rj} q_{Li} + V^*_{ki} y^u_{kj} i\sigma^2 \bar{q}^T_{Li} u_{Rj}\]
matchingtools.extras.SM.eom_phic

Rule using the conjugate of the Higgs doublet equation of motion. Substitute \(D^2\phi^\dagger\) by

\[\mu^2_\phi \phi^\dagger- 2\lambda_\phi (\phi^\dagger\phi) \phi^\dagger - y^e_{ij} \bar{l}_{Li} e_{Rj} - y^d_{ij} \bar{q}_{Li} d_{Rj} - V_{ki} y^{u*}_{kj} \bar{u}_{Rj} q^T_{Li} i\sigma^2\]
matchingtools.extras.SM.eom_bFS

Rule using the \(U(1)\) gauge field strength equation of motion. Substitute \(D_\mu B^{\mu\nu}\) by

\[-g' \sum_f Y_f \bar{f} \gamma^\nu f -(\frac{i}{2} g' \phi^\dagger D^\nu \phi + h.c.)\]

where \(\sum_f\) runs over all SM fermions \(f\) and the \(Y_f\) are the hypercharges.

matchingtools.extras.SM.eom_wFS

Rule using the \(SU(2)\) gauge field strength equation of motion. Substitute \(D_\mu W^{a,\mu\nu}\) by

\[-\frac{1}{2} g \sum_F \bar{F} \sigma^a \gamma^\nu F -(\frac{i}{2} g \phi^\dagger \sigma^a D^\nu \phi + h.c.)\]

where \(\sum_F\) runs over the SM fermion doublets \(F\).

matchingtools.extras.SM.eom_lL

Rule using the equation of motion of the left-handed lepton doublet. Substitute \(\gamma^\mu D_\mu l_{Li}\) by \(-iy^e_{ij}\phi e_{Rj}\).

matchingtools.extras.SM.eom_lLc

Rule using the equation of motion of conjugate of the left-handed lepton doublet. Substitute \(D_\mu\bar{l}_{Li}\gamma^\mu\) by \(iy^{e*}_{ij} \bar{e}_{Rj}\phi^\dagger\).

matchingtools.extras.SM.eom_qL

Rule using the equation of motion of the left-handed quark doublet. Substitute \(\gamma^\mu D_\mu q_{Li}\) by \(-iy^d_{ij}\phi d_{Rj}-i V^*_{ji}y^u_{kj} \tilde{\phi} u_{Rj}\).

matchingtools.extras.SM.eom_qLc

Rule using the equation of motion of the conjugate of the left-handed quark doublet. Substitute \(D_\mu \bar{q}_{Li}\gamma^\mu\) by \(iy^{d*}_{ij} \bar{d}_{Rj}\phi^\dagger+ i V_{ji}y^{u*}_{kj} \bar{u}_{Rj}\tilde{\phi}^\dagger\).

matchingtools.extras.SM.eom_eR

Rule using the equation of motion of the right-handed electron singlet. Substitute \(\gamma^\mu D_\mu e_{Rj}\) by \(-i y^{e*}_{ij} \phi^\dagger l_{Li}\).

matchingtools.extras.SM.eom_eRc

Rule using the equation of motion of the conjugate of the right-handed electron singlet. Substitute \(D_\mu \bar{e}_{Rj} \gamma^\mu\) by \(i y^e_{ij} \bar{l}_{Li}\phi\).

matchingtools.extras.SM.eom_dR

Rule using the equation of motion of the right-handed down quark singlet. Substitute \(\gamma^\mu D_\mu d_{Rj}\) by \(-i y^{d*}_{ij} \phi^\dagger q_{Li}\).

matchingtools.extras.SM.eom_dRc

Rule using the equation of motion of the conjugate of the right-handed down quark singlet. Substitute \(D_\mu \bar{d}_{Rj} \gamma^\mu\) by \(i y^d_{ij} \bar{q}_{Li}\phi\).

matchingtools.extras.SM.eom_uR

Rule using the equation of motion of the right-handed up quark singlet. Substitute \(\gamma^\mu D_\mu u_{Rj}\) by \(-i V_{ki} y^{u*}_{kj} \tilde{\phi}^\dagger q_{Li}\).

matchingtools.extras.SM.eom_uRc

Rule using the equation of motion of the conjugate of the right-handed up quark singlet. Substitute \(D_\mu \bar{u}_{Rj}\gamma^\mu\) by \(i V^*_{ki} y^u_{kj} \bar{q}_{Li} \tilde{\phi}\).

matchingtools.extras.SM.eoms_SM

Rules that use the equations of motion of the Standard Model fields to substitute some expressions involving their derivatives by other combinations of the fields.

matchingtools.extras.SM.latex_SM

LaTeX code representation of the tensors and fields of the Standard Model.

The extras.SM_dim_6_basis module

This module defines a basis of operators for the Standar Model effective lagrangian up to dimension 6.

The basis is the one in arXiv:1412.8480v2.

matchingtools.extras.SM_dim_6_basis.Okinphi

Higgs kinetic term \(\mathcal{O}_{kin,\phi} = (D_\mu \phi)^\dagger D^\mu \phi\).

matchingtools.extras.SM_dim_6_basis.Ophi4

Higgs quartic coupling \(\mathcal{O}_{\phi 4} = (\phi^\dagger\phi)^2\).

matchingtools.extras.SM_dim_6_basis.Ophi2

Higgs quadratic coupling \(\mathcal{O}_{\phi 2} = \phi^\dagger\phi\).

matchingtools.extras.SM_dim_6_basis.Oye(*indices)

Lepton Yukawa coupling \((\mathcal{O}_{y^e})_{ij} = \bar{l}_{Li}\phi e_{Rj}\).

matchingtools.extras.SM_dim_6_basis.Oyec(*indices)

Conjugate lepton Yukawa coupling \((\mathcal{O}_{y^e})^*_{ij} = \bar{e}_{Rj}\phi^\dagger l_{Li}\).

matchingtools.extras.SM_dim_6_basis.Oyd(*indices)

Down quark Yukawa coupling \((\mathcal{O}_{y^d})_{ij} = \bar{q}_{Li}\phi d_{Rj}\).

matchingtools.extras.SM_dim_6_basis.Oydc(*indices)

Conjugate down quark Yukawa coupling \((\mathcal{O}_{y^d})^*_{ij} = \bar{d}_{Rj}\phi^\dagger q_{Li}\).

matchingtools.extras.SM_dim_6_basis.Oyu(*indices)

Up quark Yukawa coupling \((\mathcal{O}_{y^u})_{ij} = \bar{q}_{Li}\tilde{\phi} u_{Rj}\).

matchingtools.extras.SM_dim_6_basis.Oyuc(*indices)

Conjugate up quark Yukawa coupling \((\mathcal{O}_{y^d})^*_{ij} = \bar{d}_{Rj}\tilde{\phi}^\dagger q_{Li}\).

matchingtools.extras.SM_dim_6_basis.O5(*indices)

Weinberg operator \(\mathcal{O}_5 = \overline{l^c}_L\tilde{\phi}^*\tilde{\phi}^\dagger l_L\).

matchingtools.extras.SM_dim_6_basis.O5c(*indices)

Conjugate Weinberg operator \(\mathcal{O}_5 = \bar{l}_L\tilde{\phi}\tilde{\phi}^T l^c_L\).

matchingtools.extras.SM_dim_6_basis.O1ll(*indices)

LLLL type four-fermion operator \((\mathcal{O}^{(1)}_{ll})_{ijkl}= \frac{1}{2}(\bar{l}_{Li}\gamma_\mu l_{Lj}) (\bar{l}_{Lk}\gamma^\mu l_{Ll})\).

matchingtools.extras.SM_dim_6_basis.O1qq(*indices)

LLLL type four-fermion operator \((\mathcal{O}^{(1)}_{qq})_{ijkl}= \frac{1}{2}(\bar{q}_{Li}\gamma_\mu q_{Lj}) (\bar{q}_{Lk}\gamma^\mu q_{Ll})\).

matchingtools.extras.SM_dim_6_basis.O8qq(*indices)

LLLL type four-fermion operator \((\mathcal{O}^{(8)}_{qq})_{ijkl}= \frac{1}{2}(\bar{q}_{Li}T_A \gamma_\mu q_{Lj}) (\bar{q}_{Lk}T_A \gamma^\mu q_{Ll})\).

matchingtools.extras.SM_dim_6_basis.O1lq(*indices)

LLLL type four-fermion operator \((\mathcal{O}^{(1)}_{lq})_{ijkl}= (\bar{l}_{Li}\gamma_\mu l_{Lj}) (\bar{q}_{Lk}\gamma^\mu q_{Ll})\).

matchingtools.extras.SM_dim_6_basis.O3lq(*indices)

LLLL type four-fermion operator \((\mathcal{O}^{(8)}_{qq})_{ijkl}= (\bar{l}_{Li}\sigma_a \gamma_\mu l_{Lj}) (\bar{q}_{Lk}\sigma_a \gamma^\mu q_{Ll})\).

matchingtools.extras.SM_dim_6_basis.Oee(*indices)

RRRR type four-fermion operator \((\mathcal{O}_{ee})_{ijkl}= \frac{1}{2}(\bar{e}_{Ri}\gamma_\mu e_{Rj}) (\bar{e}_{Rk}\gamma^\mu e_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O1uu(*indices)

RRRR type four-fermion operator \((\mathcal{O}^{(1)}_{uu})_{ijkl}= \frac{1}{2}(\bar{u}_{Ri}\gamma_\mu u_{Rj}) (\bar{u}_{Rk}\gamma^\mu u_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O1dd(*indices)

RRRR type four-fermion operator \((\mathcal{O}^{(1)}_{dd})_{ijkl}= \frac{1}{2}(\bar{d}_{Ri}\gamma_\mu d_{Rj}) (\bar{d}_{Rk}\gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O1ud(*indices)

RRRR type four-fermion operator \((\mathcal{O}^{(1)}_{uu})_{ijkl}= (\bar{u}_{Ri}\gamma_\mu u_{Rj}) (\bar{d}_{Rk}\gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O8ud(*indices)

RRRR type four-fermion operator \((\mathcal{O}^{(8)}_{uu})_{ijkl}= (\bar{u}_{Ri}T_A \gamma_\mu u_{Rj}) (\bar{d}_{Rk}T_A \gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Oeu(*indices)

RRRR type four-fermion operator \((\mathcal{O}_{eu})_{ijkl}= (\bar{e}_{Ri}\gamma_\mu e_{Rj}) (\bar{u}_{Rk}\gamma^\mu u_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Oed(*indices)

RRRR type four-fermion operator \((\mathcal{O}_{ed})_{ijkl}= (\bar{e}_{Ri}\gamma_\mu e_{Rj}) (\bar{d}_{Rk}\gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Ole(*indices)

LLRR type four-fermion operator \((\mathcal{O}_{le})_{ijkl}= (\bar{l}_{Li}\gamma_\mu l_{Lj}) (\bar{e}_{Rk}\gamma^\mu e_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Oqe(*indices)

LLRR type four-fermion operator \((\mathcal{O}_{qe})_{ijkl}= (\bar{q}_{Li}\gamma_\mu q_{Lj}) (\bar{e}_{Rk}\gamma^\mu e_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Olu(*indices)

LLRR type four-fermion operator \((\mathcal{O}_{lu})_{ijkl}= (\bar{l}_{Li}\gamma_\mu l_{Lj}) (\bar{u}_{Rk}\gamma^\mu u_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Old(*indices)

LLRR type four-fermion operator \((\mathcal{O}_{ld})_{ijkl}= (\bar{l}_{Li}\gamma_\mu l_{Lj}) (\bar{d}_{Rk}\gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O1qu(*indices)

LLRR type four-fermion operator \((\mathcal{O}^{(1)}_{qu})_{ijkl}= (\bar{q}_{Li}\gamma_\mu q_{Lj}) (\bar{u}_{Rk}\gamma^\mu u_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O8qu(*indices)

LLRR type four-fermion operator \((\mathcal{O}^{(8)}_{qu})_{ijkl}= (\bar{q}_{Li}T_A\gamma_\mu q_{Lj}) (\bar{u}_{Rk}T_A\gamma^\mu u_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O1qd(*indices)

LLRR type four-fermion operator \((\mathcal{O}^{(1)}_{qd})_{ijkl}= (\bar{q}_{Li}\gamma_\mu q_{Lj}) (\bar{d}_{Rk}\gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.O8qd(*indices)

LLRR type four-fermion operator \((\mathcal{O}^{(8)}_{qd})_{ijkl}= (\bar{q}_{Li}T_A\gamma_\mu q_{Lj}) (\bar{d}_{Rk}T_A\gamma^\mu d_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Oledq(*indices)

LRRL type four-fermion operator \((\mathcal{O}_{leqd})_{ijkl}= (\bar{l}_{Li} e_{Rj}) (\bar{d}_{Rk} q_{Ll})\).

matchingtools.extras.SM_dim_6_basis.Oledqc(*indices)

LRRL type four-fermion operator \((\mathcal{O}_{leqd})^*_{ijkl}= (\bar{e}_{Rj} l_{Li}) (\bar{q}_{Ll} d_{Rk})\).

matchingtools.extras.SM_dim_6_basis.O1qud(*indices)

LRLR type four-fermion operator \((\mathcal{O}^{(1)}_{qud})_{ijkl}= (\bar{q}_{Li} u_{Rj})i\sigma_2 (\bar{q}_{Lk} d_{Rl})^T\).

matchingtools.extras.SM_dim_6_basis.O1qudc(*indices)

LRLR type four-fermion operator \((\mathcal{O}^{(1)}_{qud})^*_{ijkl}= (\bar{u}_{Rj} q_{Li})i\sigma_2 (\bar{d}_{Rl} q_{Lk})^T\).

matchingtools.extras.SM_dim_6_basis.O8qud(*indices)

LRLR type four-fermion operator \((\mathcal{O}^{(8)}_{qud})_{ijkl}= (\bar{q}_{Li}T_A u_{Rj})i\sigma_2 (\bar{q}_{Lk}T_A d_{Rl})^T\).

matchingtools.extras.SM_dim_6_basis.O8qudc(*indices)

LRLR type four-fermion operator \((\mathcal{O}^{(8)}_{qud})^*_{ijkl}= (\bar{u}_{Rj} T_A q_{Li})i\sigma_2 (\bar{d}_{Rl} T_A q_{Lk}})^T\).

matchingtools.extras.SM_dim_6_basis.Olequ(*indices)

LRLR type four-fermion operator \((\mathcal{O}_{lequ})_{ijkl}= (\bar{l}_{Li} e_{Rj})i\sigma_2 (\bar{q}_{Lk} u_{Rl})^T\).

matchingtools.extras.SM_dim_6_basis.Olequc(*indices)

LRLR type four-fermion operator \((\mathcal{O}_{lequ})^*_{ijkl}= (\bar{e}_{Rj} l_{Li})i\sigma_2 (\bar{u}_{Rl} q_{Lk})^T\).

matchingtools.extras.SM_dim_6_basis.Oluqe(*indices)

LRLR type four-fermion operator \((\mathcal{O}_{luqe})_{ijkl}= (\bar{l}_{Li} u_{Rj})i\sigma_2 (\bar{q}_{Lk} e_{Rl})^T\).

matchingtools.extras.SM_dim_6_basis.Oluqec(*indices)

LRLR type four-fermion operator \((\mathcal{O}_{luqe})^*_{ijkl}= (\bar{l}_{Li} u_{Rj})i\sigma_2 (\bar{q}_{Lk} e_{Rl})^T\).

matchingtools.extras.SM_dim_6_basis.Olqdu(*indices)

Four-fermion operator \((\mathcal{O}_{lqdu})_{ijkl}= \epsilon_{ABC}(\bar{l}_{Li} i\sigma_2 q^{c,A}_{Lj}) (\bar{d}^B_{Rk} u^{c,C}_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Olqduc(*indices)

Four-fermion operator \((\mathcal{O}_{lqdu})^*_{ijkl}= -\epsilon_{ABC}(\bar{q}^{c,A}_{Lj}i\sigma_2 l_{Li}) (\bar{u}^{c,C}_{Rl} d^B_{Rk})\).

matchingtools.extras.SM_dim_6_basis.Oqqeu(*indices)

Four-fermion operator \((\mathcal{O}_{lqdu})_{ijkl}= \epsilon_{ABC}(\bar{q}^A_{Li} i\sigma_2 q^{c,B}_{Lj}) (\bar{e}_{Rk} u^{c,C}_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Oqqeuc(*indices)

Four-fermion operator \((\mathcal{O}_{lqdu})^*_{ijkl}= -\epsilon_{ABC}(\bar{q}^{c,B}_{Lj}i\sigma_2 q^A_{Li}) (\bar{u}^{c,C}_{Rl} e_{Rk})\).

matchingtools.extras.SM_dim_6_basis.O1lqqq(*indices)

Four-fermion operator \((\mathcal{O}^{{(1)}}_{lqqq})_{ijkl}= \epsilon_{ABC}(\bar{l}_{Li} i\sigma_2 q^{c,A}_{Lj}) (\bar{q}^B_{Lk} i\sigma_2 q^{c,C}_{Ll})\).

matchingtools.extras.SM_dim_6_basis.O1lqqqc(*indices)

Four-fermion operator \((\mathcal{O}^{{(1)}}_{lqqq})^*_{ijkl}= \epsilon_{ABC}(\bar{q}^{c,A}_{Lj} i\sigma_2 l_{i}) (\bar{q}^{c,C}_{Ll} i\sigma_2 q^B_{Lk})\).

matchingtools.extras.SM_dim_6_basis.Oudeu(*indices)

Four-fermion operator \((\mathcal{O}_{udeu})_{ijkl}= \epsilon_{ABC}(\bar{u}^A_{Ri} d^{c,B}_{Rj}) (\bar{e}_{Rk} u^{c,C}_{Rl})\).

matchingtools.extras.SM_dim_6_basis.Oudeuc(*indices)

Four-fermion operator \((\mathcal{O}_{udeu})^*_{ijkl}= \epsilon_{ABC}(\bar{d}^{c,B}_{Rj} u^A_{Ri}) (\bar{u}^{c,C}_{Rl} e_{Rk})\).

matchingtools.extras.SM_dim_6_basis.O3lqqq(*indices)

Four-fermion operator \((\mathcal{O}^{{(3)}}_{lqqq})_{ijkl}= \epsilon_{ABC}(\bar{l}_{Li} \sigma_a i\sigma_2 q^{c,A}_{Lj}) (\bar{q}^B_{Lk} \sigma_a i\sigma_ 2 q^{c,C}_{Ll})\).

matchingtools.extras.SM_dim_6_basis.O3lqqqc(*indices)

Four-fermion operator \((\mathcal{O}^{{(3)}}_{lqqq})^*_{ijkl}= \epsilon_{ABC}(\bar{q}^{c,A}_{Lj} i sigma_2 \sigma_a l_{Li} ) (\bar{q}^{c,C}_{Ll} i\sigma_2 \sigma_a q^B_{Lk})\).

matchingtools.extras.SM_dim_6_basis.Ophisq

S type operator \(\mathcal{O}_{\phi\square}=\phi^\dagger\phi\square(\phi^\dagger\phi)\).

matchingtools.extras.SM_dim_6_basis.Ophi

S type six Higgs interaction operator \(\mathcal{O}_\phi = \frac{1}{3}(\phi^\dagger\phi)^3\).

matchingtools.extras.SM_dim_6_basis.O1phil(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi l})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{l}_{Li}\gamma^\mu l_{Lj})\).

matchingtools.extras.SM_dim_6_basis.O1philc(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi l})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{l}_{Lj}\gamma^\mu l_{Li})\).

matchingtools.extras.SM_dim_6_basis.O1phiq(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi q})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{q}_{Li}\gamma^\mu q_{Lj})\).

matchingtools.extras.SM_dim_6_basis.O1phiqc(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi q})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{q}_{Lj}\gamma^\mu q_{Li})\).

matchingtools.extras.SM_dim_6_basis.O3phil(*indices)

SVF type operator \((\mathcal{O}^{(3)}_{\phi l})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{l}_{Li}\gamma^\mu l_{Lj})\).

matchingtools.extras.SM_dim_6_basis.O3philc(*indices)

SVF type operator \((\mathcal{O}^{(3)}_{\phi l})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{l}_{Lj}\gamma^\mu l_{Li})\).

matchingtools.extras.SM_dim_6_basis.O3phiq(*indices)

SVF type operator \((\mathcal{O}^{(3)}_{\phi q})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{q}_{Li}\gamma^\mu q_{Lj})\).

matchingtools.extras.SM_dim_6_basis.O3phiqc(*indices)

SVF type operator \((\mathcal{O}^{(3)}_{\phi q})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{q}_{Lj}\gamma^\mu q_{Li})\).

matchingtools.extras.SM_dim_6_basis.O1phie(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi e})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{e}_{Ri}\gamma^\mu e_{Rj})\).

matchingtools.extras.SM_dim_6_basis.O1phiec(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi e})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{e}_{Rj}\gamma^\mu e_{Ri})\).

matchingtools.extras.SM_dim_6_basis.O1phid(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi d})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{d}_{Ri}\gamma^\mu d_{Rj})\).

matchingtools.extras.SM_dim_6_basis.O1phidc(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi d})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{d}_{Rj}\gamma^\mu d_{Ri})\).

matchingtools.extras.SM_dim_6_basis.O1phiu(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi u})_{ij}= (\phi^\dagger i D_\mu \phi)(\bar{u}_{Ri}\gamma^\mu u_{Rj})\).

matchingtools.extras.SM_dim_6_basis.O1phiuc(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi u})^*_{ij}= (-i (D_\mu \phi)^\dagger \phi)(\bar{u}_{Rj}\gamma^\mu u_{Ri})\).

matchingtools.extras.SM_dim_6_basis.Ophiud(*indices)

SVF type operator \((\mathcal{O}^{(1)}_{\phi ud})_{ij}= -(\tilde{\phi}^\dagger i D_\mu \phi)(\bar{u}_{Ri}\gamma^\mu d_{Rj})\).

matchingtools.extras.SM_dim_6_basis.Ophiudc(*indices)

SVF type operator \((\mathcal{O}_{\phi ud})^*_{ij}= (i (D_\mu \phi)^\dagger \tilde{\phi})(\bar{u}_{Rj}\gamma^\mu d_{Ri})\).

matchingtools.extras.SM_dim_6_basis.OeB(*indices)

STF type operator \((\mathcal{O}_{eB})_{ij}= (\bar{l}_{Li}\sigma^{\mu\nu}e_{Rj})\phi B_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OeBc(*indices)

STF type operator \((\mathcal{O}_{eB})^*_{ij}= \phi^\dagger (\bar{e}_{Rj}\sigma^{\mu\nu}l_{Li}) B_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OeW(*indices)

STF type operator \((\mathcal{O}_{eW})_{ij}= (\bar{l}_{Li}\sigma^{\mu\nu}e_{Rj})\sigma^a\phi W^a_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OeWc(*indices)

STF type operator \((\mathcal{O}_{eW})^*_{ij}= \phi^\dagger\sigma^a(\bar{e}_{Rj}\sigma^{\mu\nu}l_{Li}) W^a_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OuB(*indices)

STF type operator \((\mathcal{O}_{uB})_{ij}= (\bar{q}_{Li}\sigma^{\mu\nu}u_{Rj})\tilde{\phi} B_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OuBc(*indices)

STF type operator \((\mathcal{O}_{uB})^*_{ij}= \tilde{\phi}^\dagger(\bar{u}_{Rj}\sigma^{\mu\nu}q_{Li}) B_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OuW(*indices)

STF type operator \((\mathcal{O}_{uW})_{ij}= (\bar{q}_{Li}\sigma^{\mu\nu}u_{Rj})\sigma^a\tilde{\phi} W^a_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OuWc(*indices)

STF type operator \((\mathcal{O}_{uW})^*_{ij}= \tilde{\phi}\sigma^a(\bar{u}_{Rj}\sigma^{\mu\nu}q_{Li}) W^a_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OdB(*indices)

STF type operator \((\mathcal{O}_{dB})_{ij}= (\bar{q}_{Li}\sigma^{\mu\nu}d_{Rj})\phi B_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OdBc(*indices)

STF type operator \((\mathcal{O}_{dB})^*_{ij}= \phi^\dagger(\bar{d}_{Rj}\sigma^{\mu\nu}q_{Li}) B_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OdW(*indices)

STF type operator \((\mathcal{O}_{dW})_{ij}= (\bar{q}_{Li}\sigma^{\mu\nu}d_{Rj})\sigma^a\phi W^a_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OdWc(*indices)

STF type operator \((\mathcal{O}_{dW})^*_{ij}= \phi^\dagger\sigma^a(\bar{d}_{Rj}\sigma^{\mu\nu}q_{Li}) W^a_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OuG(*indices)

STF type operator \((\mathcal{O}_{uG})_{ij}= (\bar{q}_{Li}\sigma^{\mu\nu}T_A u_{Rj})\tilde{\phi} G^A_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OuGc(*indices)

STF type operator \((\mathcal{O}_{uG})^*_{ij}= \tilde{\phi}^\dagger(\bar{u}_{Rj}\sigma^{\mu\nu}T_A q_{Li}) G^A_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OdG(*indices)

STF type operator \((\mathcal{O}_{dG})_{ij}= (\bar{q}_{Li}\sigma^{\mu\nu}T_A d_{Rj})\phi G^A_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OdGc(*indices)

STF type operator \((\mathcal{O}_{dG})^*_{ij}= \phi^\dagger(\bar{d}_{Rj}\sigma^{\mu\nu}T_A q_{Li}) G^A_{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.Oephi(*indices)

SF type operator \((\mathcal{O}_{e\phi})_{ij}= (\phi^\dagger\phi)(\bar{l}_{Li}\phi e_{Rj})\).

matchingtools.extras.SM_dim_6_basis.Odphi(*indices)

SF type operator \((\mathcal{O}_{d\phi})_{ij}= (\phi^\dagger\phi)(\bar{q}_{Li}\phi d_{Rj})\).

matchingtools.extras.SM_dim_6_basis.Ouphi(*indices)

SF type operator \((\mathcal{O}_{u\phi})_{ij}= (\phi^\dagger\phi)(\bar{q}_{Li}\tilde{\phi} u_{Rj})\).

matchingtools.extras.SM_dim_6_basis.Oephic(*indices)

SF type operator \((\mathcal{O}_{e\phi})^*_{ij}= (\phi^\dagger\phi)(\bar{e}_{Rj}\phi^\dagger l_{Li})\).

matchingtools.extras.SM_dim_6_basis.Odphic(*indices)

SF type operator \((\mathcal{O}_{d\phi})^*_{ij}= (\phi^\dagger\phi)(\bar{d}_{Rj}\phi^\dagger q_{Li})\).

matchingtools.extras.SM_dim_6_basis.Ouphic(*indices)

SF type operator \((\mathcal{O}_{u\phi})^*_{ij}= (\phi^\dagger\phi)(\bar{u}_{Rj}\tilde{\phi}^\dagger q_{Li})\).

matchingtools.extras.SM_dim_6_basis.OphiD

Oblique operator \(\mathcal{O}_{\phi D}=(\phi^\dagger D_\mu \phi)((D^\mu\phi)^\dagger\phi)\).

matchingtools.extras.SM_dim_6_basis.OphiB

Oblique operator \(\mathcal{O}_{\phi B}=\phi^\dagger\phi B_{\mu\nu}B^{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OphiBTilde

Oblique operator \(\mathcal{O}_{\phi \tilde{B}}= \phi^\dagger\phi \tilde{B}_{\mu\nu}B^{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OphiW

Oblique operator \(\mathcal{O}_{\phi W}= \phi^\dagger\phi W^a_{\mu\nu}W^{a,\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OphiWTilde

Oblique operator \(\mathcal{O}_{\phi \tilde{W}}= \phi^\dagger\phi \tilde{W}^a_{\mu\nu}W^{a,\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OWB

Oblique operator \(\mathcal{O}_{W B}= \phi^\dagger\sigma^a\phi W^a_{\mu\nu}B^{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OWBTilde

Oblique operator \(\mathcal{O}_{\tilde{W} B}= \phi^\dagger\sigma^a\phi \tilde{W}^a_{\mu\nu}B^{\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OphiG

Oblique operator \(\mathcal{O}_{\phi W}= \phi^\dagger\phi G^A_{\mu\nu}G^{A,\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OphiGTilde

Oblique operator \(\mathcal{O}_{\phi \tilde{W}}= \phi^\dagger\phi \tilde{G}^A_{\mu\nu}G^{A,\mu\nu}\).

matchingtools.extras.SM_dim_6_basis.OW

Gauge type operator \(\mathcal{O}_W= \varepsilon_{abc}W^{a,\nu}_\mu W^{b,\rho}_\nu W^{c,\mu}_\rho\).

matchingtools.extras.SM_dim_6_basis.OWTilde

Gauge type operator \(\mathcal{O}_{\tilde{W}}= \varepsilon_{abc}\tilde{W}^{a,\nu}_\mu W^{b,\rho}_\nu W^{c,\mu}_\rho\).

matchingtools.extras.SM_dim_6_basis.OG

Gauge type operator \(\mathcal{O}_G= f_{ABC}G^{A,\nu}_\mu G^{B,\rho}_\nu G^{C,\mu}_\rho\).

matchingtools.extras.SM_dim_6_basis.OGTilde

Gauge type operator \(\mathcal{O}_{\tilde{G}}= f_{ABC}\tilde{G}^{A,\nu}_\mu G^{B,\rho}_\nu G^{C,\mu}_\rho\).

matchingtools.extras.SM_dim_6_basis.rules_basis_definitions

Rules defining the operators in the basis in terms of Standard Model fields.

matchingtools.extras.SM_dim_6_basis.latex_basis_coefs

LaTeX representation of the coefficients of the operators in the basis.