asymptotic

asymptotic is a symbolic asymptotic-analysis package built on SymPy. It spans directed real and multivariate asymptotics together with complex/sector-aware branch geometry, formal ODE/transseries interchange, asymptotic expansions, limits, sums, recurrences, implicit asymptotics, perturbation methods, and probability/Laplace asymptotics, and it includes certification and evidence for the conditions that make results valid. It handles simultaneous multivariate approaches, competing power/logarithmic/exponential scales, parameter conditions, and selected special-function and perturbation problems.

Installation

python -m pip install asymptotic

The package requires Python 3.11 or later and SymPy 1.14 or later. The required semialg dependency installs python-flint 0.9.0 or later. The flint extra also declares this backend explicitly. The ode extra supplies the differential-equation integration.

Start with a limit

import sympy as sp
from asymptotic import limit, one_sided_limit
from asymptotic.limit_models import LimitStatus

x, y = sp.symbols("x y", real=True)
assert limit(x * y / sp.sqrt(x**2 + y**2), (x, y), (0, 0)) == 0
assert one_sided_limit(1 / x, x, 0, direction="+") == sp.oo

Note that the direction argument uses the SymPy convention for the sign: + means the approach is from the right and - means the approach is from the left. This differs from Mathematica's convention, in which Direction -> +1 means you approach from more negative values and Direction -> -1 means you approach from more positive values.

When you give a tuple of variables you're asking for a simultaneous limit, not one coordinate limit followed by another. For limit(...) and other API functions, the package gives the mathematical answer (without wrappers containing metadata) by default when that is feasible, i.e. it can be represented without losing unresolved branches or hypotheses. Use the option return_result=True when you need status, conditions or evidence.

expr = x * y / (x**2 + y**2)
result = limit(expr, (x, y), (0, 0), return_result=True)
assert result.status is LimitStatus.DOES_NOT_EXIST
assert len({item.value for item in result.evidence}) >= 2

The result carries evidence for incompatible approaches. Inspect result.evidence when you need the proof route.

An asymptotic sum

from asymptotic import sum

n, k = sp.symbols("n k", positive=True, integer=True)
assert sum(
    k**-2, k, n, sp.oo, parameter=n, terms=3, method="euler-maclaurin"
) == 1/n + 1/(2 * n**2) + 1/(6 * n**3)

Use return_result=True for a sum's remainder, method and certificates. This option also exposes the internal records for expansion, solving, statistics and optimization workflows. Unresolved or unproved formal calculations retain their records. Lazy nested expansions and scale-regime stratifications keep the structures needed to express their mathematics; see the return conventions.

An asymptotic expansion: keep the error term

With a series expansion, keep its omitted-term scale alongside the prefix. For a positive variable tending to infinity:

from asymptotic import multiseries

t = sp.symbols("t", positive=True)
expansion = multiseries(sp.exp(1/t), t, scale=[1 / t], terms=5, return_result=True)
truncation = expansion.as_element().truncation(3)
assert truncation.prefix == 1 + 1/t + 1/(2 * t**2)
assert truncation.remainder.check() is True

Here the omitted scale is 1/(6*t**3). A remainder certificate concerns the declared regime; a formal series alone does not establish a uniform error bound. Follow the expansion guide for the difference between a prefix, its remainder and a certified operation.

Choose the right workflow

The root namespace has 66 primary entry points, including result types. The API guide distinguishes between common and specialized/expert-level theorem/ geometry functions.

Understand the answer

Formal expansions and certified asymptotic expansions are distinct. Read the attached remainder and certification information before using an expansion as an error bound. Numerical checks support a symbolic argument but do not replace its domain and branch hypotheses.

Capabilities and limitations

For limits, strong coverage includes rational and algebraic real limits, uniform norm and logarithmic bounds, selected real discontinuities,selected parameter strata, finite local germs, fixed complex-ray branches, gamma and harmonic tails, proportional large-order Bessel J/Y tails, bounded recurrence reductions, and attained oscillatory subsequences. Complex directional infinity retains a direction and is distinct from spherical complex infinity. General complex sectors, arbitrary variable-order special functions, and coupled oscillations with accumulating poles need additional hypotheses or unsupported theorems. Some expressions exceed practical computation budgets. Unknown user functions have no assumed continuity; analytic_limit accepts an explicit, call-scoped analytic contract.

The capability matrix gives supported inputs, proof boundaries and limitations by area. The limit guide explains domains, parameters, branches and nonexistence witnesses for limits. The limit contracts guide covers conditional outputs, whole-plane approaches, cluster sets and directional infinities.

Learn by running examples

Start with certified limits, then try complex branches and special-function tails. Each example contains executable checks and explains its mathematical question.

For expansion, summation, probability and perturbation workflows, follow the examples guide. The getting-started guide supplies the assumptions and terminology needed for these examples.

The examples/ directory contains executable examples. The introductory sequence is:

1. certified_limits.py — existence, nonexistence, domains, and evidence.
2. multivariate_limits.py — radial, path-dependent, cylindrical, and correlated examples.
3. ordinary_expansion.py — ordinary expansion.
4. asymptotic_summation.py — discrete asymptotics.
5. probability_asymptotics.py — probability and Laplace asymptotics.
6. perturbation_problem.py — unified perturbation dispatch, validation, and evidence.

Documentation

I suggest starting with these guides:

• Introduction to asymptotics — conceptual background, techniques, and applications.
• Documentation index — complete documentation map for users, specialists, reference, and contributors.
• Getting started — installation, first computations, and result inspection.
• Choosing an API — problem-oriented guide to the appropriate public entry point.
• Limits — limit semantics, domains, assumptions, and evidence.
• Multivariate limits — joint/simultanous limits, radial/angular geometry, cluster sets, and parameters.
• Certification — what a proof status means and why UNKNOWN is useful.
• Capabilities and limitations — supported routes and known capabilty boundaries.
• User guide — broader workflows across expansions, sums, ODEs and probability.
• Algorithm selection — how high-level APIs choose exact, structural, saddle, implicit, ODE, recurrence, and optimization routes.
• Primary API — curated public entry points and contracts.
• API reference — detailed signatures and public records.
• API classification — primary, expert, and internal interfaces.
• Function properties — reviewed branch-aware property, singularity, and domain reasoning.
• Probability and expectation asymptotics — exact reduction, moving domains, degenerate/coalescing saddles, and global Laplace certificates.
• Asymptotic sums — creative telescoping, Euler-Maclaurin, Mellin/Poisson methods, uniform termwise expansion, multidimensonal sums, and discrete saddles.
• Discrete asymptotics — factorial scales, discrete Newton polygons, and recurrence lifting.
• Perturbation hierarchies — common order-by-order representation used by perturbation solvers.
• Power simplification and branch semantics — branch-sensitive transformations and their proof obligations.
• Architecture — solver organization for contributors.
• Testing — public contracts, theorem tests, metamorphic tests, and performance gates.

Development

Contributions – whether they are bug reports, suggestions, or code – are welcome!

Source check:

python -m pip install -e ".[test,lint,benchmark]"
ruff check src tests examples
ruff format --check src tests examples
pytest -m "not reference_corpus"

Correctness, proof boundaries and performance tested separately. See testing guide and documentation guide.

Maintainers can follow the release guide for artifact checks and publishing gates.

License

The package is distributed under the GPL-3.0 license.