Reduction

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

`Reduction`

class Reduction

A symbolic linear combination of scalar one-loop master integrals.

Created by oneloop.reduce; there is no direct constructor. terms contains (coefficient, MasterIntegral) pairs with exact dependence on the family’s symbolic dimension. to_expression assembles a symbolic sum; oneloop.reduction_coefficients expands it about d=4-2*eps for evaluation.

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])
assert len(reduction) == 1
coefficient, master = reduction.terms[0]
assert master.kind == "bubble"
expression = reduction.to_expression()

Attributes

Name	Description
`dimension`	Symbolic dimension used in the unreduced family and its exact coefficients.
`terms`	Linear-combination terms as (coefficient, MasterIntegral) pairs.

`dimension`

Reduction.dimension: Expression

Symbolic dimension used in the unreduced family and its exact coefficients.

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])
assert reduction.dimension == d

`terms`

Reduction.terms: builtins.list[tuple[Expression, MasterIntegral]]

Linear-combination terms as (coefficient, MasterIntegral) pairs.

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])
bubbles = [(c, m) for c, m in reduction.terms if m.kind == "bubble"]
assert len(bubbles) == 1

Methods

Name	Description
`__len__`	Number of terms in this reduction; it can be zero for a vanishing integral.
`__repr__`	Display the number of retained master-integral terms.
`simplify`	Cancel each rational coefficient to lowest terms and return a new reduction.
`to_expression`	Assemble primitive scalar-master calls with the squared scale last

`len`

Reduction.__len__() -> builtins.int

Number of terms in this reduction; it can be zero for a vanishing integral.

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])
assert len(reduction) == len(reduction.terms)

`repr`

Reduction.__repr__() -> builtins.str

Display the number of retained master-integral terms.

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])
summary = repr(reduction)

`simplify`

Reduction.simplify() -> Reduction

Cancel each rational coefficient to lowest terms and return a new reduction.

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])
simplified = reduction.simplify()
assert (simplified.to_expression() - reduction.to_expression()).together() == E("0")

`to_expression`

Reduction.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])
mu2 = S("mu2")
expression = reduction.to_expression(mu2)
assert expression == oneloop.B0(s, 0, 0, mu2)

Parameters

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