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.