minBasis

This submodule takes care of handling covariant derivatives, field strength tensors and overall derivatives in a common way to be able to work out a basis that is fully linearly independent and thus minimal.

_IBPbilinear(op: LinearComb) → bool

Absorb one left-acting covariant derivative in a Bilinear into an overall derivative and a right-acting covariant derivative.

Danger

Intended for internal use. Make sure to act with simplify otherwise any non-trivial factors still residing in (covariant) derivatives etc. will get lost.

Parameters:

op (LinearComb) – Operator in which each Bilinear, carrying covariant derivatives acting to the left, is rewritten as total derivatives and right-acting covariant derivatives.

Returns:

Indicates whether a left-acting covariant derivative was encountered and replaced.

Return type:

bool

_IBPtrace(op: LinearComb)

Searches for a total derivative acting on a algebra-valued Trace and replaces it by an appropriate combination of covariant derivatives.

Danger

Intended for internal use. Make sure to act with simplify otherwise any non-trivial factors still residing in (covariant) derivatives etc. will get lost.

Parameters:

op (LinearComb) – Operator to be reexpressed.

Returns:

Indicates whether a total derivative was encountered and reexpressed.

Return type:

bool

class _dA(mu: sptIdx, derivatives: list[int] | None = None, factor: Complex = 1)

Bases: Block

Intended for internal use only to give gluon Trace a unique string representation in terms of monomials of the gluon field and its (higher order) derivatives.

Parameters:

  • mu (sptIdx) – Space-time index of the gluon.

  • derivatives (list[d]|None, optional) – Collection (space-time indices) of derivatives acting on the gluon. Defaults to None.

simplify()

Is expected to take care of any relations among different index permutations.

Caution

Has to be adapted for non-trivial cases.

_mapCoefficients(rep: list[tuple[str, Complex]], map_: dict[str, int])

Each unique term in the overcomplete basis can be identified as an eigenvector in a vector space spanned by all the terms. Using the factors corresponding to the different terms in a LinearComb, we can thus assign each operator a vector in this vector-space to establish a truly linearly independent and thus minimal basis.

Parameters:

  • rep (list[tuple[str,Complex]]) – String-representations of all the terms of an operator together with the corresponding factor.

  • map (dict[str,int]) – Table mapping each string-representation of a term into a component of the full #terms-dimensional vector.

Returns:

Eigenvector corresponding to rep in the full vector-space.

Return type:

list[Complex|int|Fraction]

_mapToVectors(bases: list[list[LinearComb]])

Turns the various terms in all the LinearComb in bases into eigenvectors identified by the string representation of those terms. The various components are tracked via a dictionary and the bases are reexpressed in terms of those eigenvectors.

Danger

Intended for internal use. Make sure to act with simplify on the bases otherwise any non-trivial factors still residing within the expression will get lost.

Parameters:

bases (list[list[LinearComb]]) – The entire basis of operators still grouped in some user-defined manner.

Returns:

The coefficients of the operator bases in the newly introduced vector space as well as the translation table to identify the various coefficients.

Return type:

tuple[list[list[list[Complex]]], dict[str,int]]

_toRep(op: LinearComb)

Takes care of any total derivatives by applying the product rule and IBP relations. Afterwards, any _AlgebraBlock is written out explicitly and the resulting unique expression is prepared for being mapped in our vector-space.

Danger

Intended for internal use. Make sure to act with simplify otherwise any non-trivial factors still residing in (covariant) derivatives etc. will get lost.

Parameters:

op (LinearComb) – Operator to be processed.

Returns:

Returns the details needed to map the operator into our vector-space.

Return type:

list[tuple[str,Complex]] | None

_unmaskAlgebraBlock(op: LinearComb) → bool

Looks for an instance of _AlgebraBlock and reexpresses it by the appropriate commutators of covariant derivatives acting on the right-most algebra block, which can be a field strength tensor or Colour.

Danger

Intended for internal use. Make sure to act with simplify otherwise any non-trivial factors still residing in the expression will get lost.

Parameters:

op (LinearComb) –

Expression in which _AlgebraBlock are supposed to be reexpressed.

Caution

The input argument will be changed!

Returns:

Indicating whether an instance of _AlgebraBlock was encountered.

Return type:

bool

findMinBases(bases: list[list[LinearComb]], gEOM: GluonEOM | None = None, fEOMs: list[LinearComb] | None = None, model: Model | None = None)

Takes the (various) overcomplete bases and identifies appropriate minimal bases while dropping linear dependent terms. The ordering of the sets of bases and within each basis determine which operators to keep. Operators with higher priority should come first.

Optionally allows to start from EOMs still being masked by D0, D0l, and DF.

In which case the appropriate EOMs must be provided:

  • fEOMs & model or both None

  • gEOM or None

Attention

If any EOMs are None, please make sure that all D0, D0l, and DF are unmasked!

Attention

Expects the operators to be simplified already!

Parameters:

  • bases (list[list[LinearComb]]) – Collection of operators that are still grouped to allow for keeping track of initially used templates.

  • gEOM (GluonEOM|None, optional) – Description of the gluon EOM, defaults to None.

  • fEOMs (list[LinearComb]|None, optional) – Collection of fermion EOMs, i.e., allows to have different EOMs for different flavours. Defaults to None.

  • model (Model) – Description of the theory currently considered. Only required for use with the fermion EOMs to track sets of flavours. Defaults to None.

Returns:

Collection of linearly independent operators keeping the original grouping intact while ensuring that earlier groups take precedence.

Return type:

list[list[LinearComb]]

Raises:

AssertionError – If fermion EOMs are provided but model is None.