KinematicTransport

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

KinematicTransport

class KinematicTransport

Transport a common master basis in physical invariants, reusing verified cached points. The declared branch domain and explicit straight-path admission are part of the physical continuation contract; distance alone never establishes a sheet.

Attributes

Name	Description
dimension
identity
nonzero_conditions
roots	Native root declarations; discrete sheet signs live on each boundary/query.

dimension

KinematicTransport.dimension: builtins.int

identity

KinematicTransport.identity: builtins.str

nonzero_conditions

KinematicTransport.nonzero_conditions: builtins.list[Expression]

roots

KinematicTransport.roots: builtins.dict[Expression, Expression]

Native root declarations; discrete sheet signs live on each boundary/query.

Methods

Name	Description
__new__	Construct a general physical connection, optionally with named square roots
add_boundary	Insert caller-established boundary evidence
canonical	Construct dY = epsilon sum(M_a dlog(letter_a))Y without dense physical assembly
evaluate	A true cache hit needs no admission
evaluate_endpoint	Evaluate finite epsilon coefficient limits in an exact endpoint chart

__new__

KinematicTransport.__new__(
    epsilon: Expression,
    derivatives: typing.Mapping[Expression, typing.Sequence[typing.Sequence[Expression]]],
    basis: typing.Sequence[Expression],
    normalization: Expression,
    *,
    branch_domain: builtins.str,
    roots: typing.Optional[typing.Mapping[Expression, Expression]] = None,
    options: typing.Optional[EvaluationOptions] = None,
    nonzero_conditions: typing.Optional[typing.Sequence[Expression]] = None,
    continuation: typing.Optional[ContinuationPrescription] = None,
) -> KinematicTransport

Related types: Expression, EvaluationOptions, ContinuationPrescription

Construct a general physical connection, optionally with named square roots. Registered roots require explicit source and destination sheet signs. Matrix entries may contain epsilon-independent and higher epsilon terms; their admission and expansion use the native connection implementation.

add_boundary

KinematicTransport.add_boundary(
    cache: BoundaryCache,
    point: typing.Mapping[Expression, Expression],
    coefficients: typing.Sequence[typing.Sequence[ComplexFloat | Float | builtins.int | builtins.float | builtins.str | decimal.Decimal | builtins.complex | tuple[Float | builtins.int | builtins.float | builtins.str | decimal.Decimal, Float | builtins.int | builtins.float | builtins.str | decimal.Decimal]]],
    leading: builtins.int,
    *,
    verified_digits: builtins.int,
    comparison_errors: typing.Sequence[typing.Sequence[Float | builtins.int | builtins.float | builtins.str | decimal.Decimal]],
    provenance: builtins.str,
    root_sheets: typing.Optional[typing.Mapping[Expression, builtins.int]] = None,
) -> TransportResult

Related types: BoundaryCache, Expression, ComplexFloat, Float, TransportResult

Insert caller-established boundary evidence. Declared accuracy is not certified here. Coefficients and absolute error estimates are epsilon-major arrays.

canonical

KinematicTransport.canonical(
    epsilon: Expression,
    variables: typing.Sequence[Expression],
    letters: typing.Sequence[Expression],
    matrices: typing.Sequence[typing.Sequence[typing.Sequence[Expression]]],
    basis: typing.Sequence[Expression],
    normalization: Expression,
    *,
    branch_domain: builtins.str,
    roots: typing.Optional[typing.Mapping[Expression, Expression]] = None,
    options: typing.Optional[EvaluationOptions] = None,
    nonzero_conditions: typing.Optional[typing.Sequence[Expression]] = None,
    continuation: typing.Optional[ContinuationPrescription] = None,
) -> KinematicTransport

Related types: Expression, EvaluationOptions, ContinuationPrescription

Construct dY = epsilon sum(M_a dlog(letter_a))Y without dense physical assembly. Named square roots retain separate generators and explicit endpoint sheet signs.

evaluate

KinematicTransport.evaluate(
    cache: BoundaryCache,
    destination: typing.Mapping[Expression, Expression],
    leading: builtins.int,
    last: builtins.int,
    *,
    root_sheets: typing.Optional[typing.Mapping[Expression, builtins.int]] = None,
    admit_straight_path: builtins.bool = False,
    admit_prescribed_path: builtins.bool = False,
    scales: typing.Optional[typing.Mapping[Expression, Expression]] = None,
    control: typing.Optional[ComputationControl] = None,
) -> TransportResult

Related types: BoundaryCache, Expression, ComputationControl, TransportResult

A true cache hit needs no admission. Other points require an explicitly admitted regular affine path or, with continuation declarations, an explicitly admitted prescribed homotopy. These admissions are separate.

evaluate_endpoint

KinematicTransport.evaluate_endpoint(
    cache: BoundaryCache,
    route: EndpointRoute,
    leading: builtins.int,
    last: builtins.int,
    *,
    admit_matching_path: builtins.bool = False,
    admit_endpoint: builtins.bool = False,
    scales: typing.Optional[typing.Mapping[Expression, Expression]] = None,
    max_lift_dimension: builtins.int = 256,
    series_order: builtins.int = 64,
    constraints: typing.Optional[EndpointConstraints] = None,
    control: typing.Optional[ComputationControl] = None,
) -> EndpointResult

Related types: BoundaryCache, EndpointRoute, Expression, EndpointConstraints, ComputationControl, EndpointResult

Evaluate finite epsilon coefficient limits in an exact endpoint chart. Admit the regular matching path and final endpoint approach separately. With a continuation declaration, matching uses the native prescribed contour and admit_matching_path admits its declared global homotopy. Recorded input errors and independent precision/order profiles determine reusable evidence; this is not symbolic dimensional-sector projection.