MasterIntegral

Symbolica documentation for getting started, symbolic expressions, numerical evaluation, pattern matching, and APIs in Python and Rust.

`MasterIntegral`

class MasterIntegral

A scalar tadpole, bubble, triangle or box returned in Reduction.terms.

There is no direct constructor. arguments gives the invariants and squared masses in primitive order; the squared renormalization scale is supplied separately to to_expression. The result is symbolic until passed to the numerical or coefficient-evaluation API.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
assert master.kind == "bubble" and master.head == "B0"
assert master.arguments == [s, E("0"), E("0")]
assert master.to_expression() == oneloop.B0(s, 0, 0, 1)

Attributes

Name	Description
`arguments`	Kinematic arguments in primitive order, excluding the squared scale
`head`	Primitive symbol name: “A0”, “B0”, “C0” or “D0”.
`kind`	Topology name: “tadpole”, “bubble”, “triangle” or “box”.

`arguments`

MasterIntegral.arguments: builtins.list[Expression]

Kinematic arguments in primitive order, excluding the squared scale.

A0 takes one squared mass; B0 takes an external invariant and two squared masses; C0 takes three invariants then three squared masses; D0 takes four external squared momenta, s12, s23, then four squared masses.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
assert master.arguments == [s, E("0"), E("0")]

`head`

MasterIntegral.head: builtins.str

Primitive symbol name: “A0”, “B0”, “C0” or “D0”.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
assert master.head == "B0"

`kind`

MasterIntegral.kind: builtins.str

Topology name: “tadpole”, “bubble”, “triangle” or “box”.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
assert master.kind == "bubble"

Methods

Name	Description
`__eq__`	Compare topology and symbolic kinematic arguments.
`__repr__`	Display the primitive family and its kinematic arguments.
`to_expression`	Assemble primitive scalar-master calls with the squared scale last

`eq`

MasterIntegral.__eq__(other: builtins.object) -> builtins.bool

Compare topology and symbolic kinematic arguments.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
assert master == reduction.terms[0][1]

Parameters

other (object) Object to compare with this master. Equality compares the master topology and its symbolic kinematic arguments.

`repr`

MasterIntegral.__repr__() -> builtins.str

Display the primitive family and its kinematic arguments.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
summary = repr(master)

`to_expression`

MasterIntegral.to_expression(mu_squared: typing.Optional[Expression] = None) -> Expression

Assemble primitive scalar-master calls with the squared scale last.

The default scale is exactly one. This builds a symbolic expression; use master_coefficients or reduction_coefficients to obtain Laurent coefficients with native evaluation hooks.

Examples

from symbolica import S, E
from symbolica.community import hepkit as hep
from symbolica.community.hepkit import oneloop
d, k, p, s = S("d", "k", "p", "s")
kin = hep.Kinematics(d, momenta=[k, p]).with_scalar_product(p, p, s)
family = hep.IntegralFamily([k], [p], [kin.scalar_product(k, k),
    kin.scalar_product(k-p, k-p)], kinematics=kin)
reduction = oneloop.reduce(family, [1, 1])
coefficient, master = reduction.terms[0]
mu2 = S("mu2")
expression = master.to_expression(mu2)
assert expression == oneloop.B0(s, 0, 0, mu2)

Parameters

mu_squared (Expression or None, optional) Squared renormalization scale; None uses one.