IntegralEvaluator

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

`IntegralEvaluator`

class IntegralEvaluator

Evaluate native HEPKit families with exact reduction and recursive boundary construction.

Attributes

Name	Description
`backend_identity`
`options`

`backend_identity`

IntegralEvaluator.backend_identity: builtins.str

`options`

IntegralEvaluator.options: EvaluationOptions

Methods

Name	Description
`__new__`
`evaluate`	Denominator powers follow the native family’s exact input order.
`evaluate_cut_diagram`	Integrate one native positive-energy cut, including the contracted numerator
`evaluate_cut_diagram_samples`	Shared finite-epsilon cut evaluation
`evaluate_diagram`	Contract the native diagram numerator, decompose it, then integrate the exact weighted sum.
`evaluate_projections`	Evaluate several exact linear combinations with shared sample values and reductions
`evaluate_samples`	Evaluate prescribed exact nonzero epsilon samples with fresh recursive boundaries.
`prepare`	Prepare a common derivative-closed basis in all remaining physical variables.

`new`

IntegralEvaluator.__new__(
    *,
    options: typing.Optional[EvaluationOptions] = None,
    reductions: typing.Optional[ReductionTables] = None,
    reduction_depth: builtins.int = 2,
    reduction_targets: builtins.int = 4096,
    reduction_batch_size: builtins.int = 32,
) -> IntegralEvaluator

`evaluate`

IntegralEvaluator.evaluate(
    family: IntegralFamily,
    powers: typing.Sequence[typing.Sequence[builtins.int]],
    point: typing.Mapping[Expression, Expression],
    epsilon: Expression,
    *,
    last: builtins.int = 0,
    physical_propagators: typing.Optional[builtins.int] = None,
    control: typing.Optional[ComputationControl] = None,
) -> builtins.list[LaurentExpansion]

Denominator powers follow the native family’s exact input order.

`evaluate_cut_diagram`

IntegralEvaluator.evaluate_cut_diagram(
    diagram: FeynmanDiagram,
    kinematics: Kinematics,
    point: typing.Mapping[Expression, Expression],
    epsilon: Expression,
    *,
    cut_index: builtins.int,
    future_channel: typing.Sequence[Expression],
    loop_prescriptions: typing.Sequence[builtins.str],
    edge_powers: typing.Optional[typing.Mapping[builtins.int, builtins.int]] = None,
    last: builtins.int = 0,
    control: typing.Optional[ComputationControl] = None,
) -> LaurentExpansion

Integrate one native positive-energy cut, including the contracted numerator. Channel coefficients refer to the native independent external basis. Loop prescriptions are +i0, -i0 or insensitive in native loop-basis order. Raised cut powers use derivative-delta normalization; no flux or symmetry factor is added beyond the diagram’s own exact overall factor.

`evaluate_cut_diagram_samples`

IntegralEvaluator.evaluate_cut_diagram_samples(
    diagram: FeynmanDiagram,
    kinematics: Kinematics,
    point: typing.Mapping[Expression, Expression],
    epsilon: Expression,
    samples: typing.Sequence[Expression],
    *,
    cut_index: builtins.int,
    future_channel: typing.Sequence[Expression],
    loop_prescriptions: typing.Sequence[builtins.str],
    edge_powers: typing.Optional[typing.Mapping[builtins.int, builtins.int]] = None,
    control: typing.Optional[ComputationControl] = None,
) -> builtins.list[ComplexFloat]

Shared finite-epsilon cut evaluation. Exact numerator weights and cut IBP coefficients are applied at each nonzero sample before any truncation. Values have working precision; this method does not assert fitted accuracy.

`evaluate_diagram`

IntegralEvaluator.evaluate_diagram(
    diagram: FeynmanDiagram,
    kinematics: Kinematics,
    point: typing.Mapping[Expression, Expression],
    epsilon: Expression,
    *,
    last: builtins.int = 0,
    max_partial_fraction_states: builtins.int = 10000,
    control: typing.Optional[ComputationControl] = None,
) -> LaurentExpansion

Contract the native diagram numerator, decompose it, then integrate the exact weighted sum.

`evaluate_projections`

IntegralEvaluator.evaluate_projections(
    family: IntegralFamily,
    projections: typing.Sequence[typing.Sequence[tuple[typing.Sequence[builtins.int], Expression]]],
    point: typing.Mapping[Expression, Expression],
    epsilon: Expression,
    *,
    last: builtins.int = 0,
    physical_propagators: typing.Optional[builtins.int] = None,
    control: typing.Optional[ComputationControl] = None,
) -> builtins.list[LaurentExpansion]

Evaluate several exact linear combinations with shared sample values and reductions. Projection weights are multiplied before Laurent fitting.

`evaluate_samples`

IntegralEvaluator.evaluate_samples(
    family: IntegralFamily,
    powers: typing.Sequence[typing.Sequence[builtins.int]],
    point: typing.Mapping[Expression, Expression],
    epsilon: Expression,
    samples: typing.Sequence[Expression],
    *,
    physical_propagators: typing.Optional[builtins.int] = None,
    control: typing.Optional[ComputationControl] = None,
) -> builtins.list[builtins.list[ComplexFloat]]

Evaluate prescribed exact nonzero epsilon samples with fresh recursive boundaries.

`prepare`

IntegralEvaluator.prepare(
    family: IntegralFamily,
    powers: typing.Sequence[typing.Sequence[builtins.int]],
    variables: typing.Sequence[Expression],
    epsilon: Expression,
    *,
    branch_domain: builtins.str,
    physical_propagators: typing.Optional[builtins.int] = None,
    fixed_parameters: typing.Optional[typing.Mapping[Expression, Expression]] = None,
    epsilon_shearing: builtins.bool = False,
    control: typing.Optional[ComputationControl] = None,
) -> PreparedIntegralFamily

Prepare a common derivative-closed basis in all remaining physical variables.