funcprops 0.1.0__py3-none-any.whl

funcprops/verification.py

@@ -0,0 +1,410 @@
+"""Independent, conservative replay checks for exact property certificates.
+
+Verifiers return True only when the certificate's stated conclusion can be
+re-established from its payload and current proof primitives. False means the
+certificate is internally inconsistent or unsupported; verifiers never turn an
+unknown symbolic comparison into success.
+"""
+
+from __future__ import annotations
+
+import sympy as sp
+from sympy import S
+
+from .exceptions import SYMBOLIC_QUERY_ERRORS
+from .results import Monotonicity, Sign
+
+
+def _truth(q):
+    if q in (True, S.true):
+        return True
+    if q in (False, S.false):
+        return False
+    try:
+        z = sp.simplify(q)
+        if z is S.true:
+            return True
+        if z is S.false:
+            return False
+    except SYMBOLIC_QUERY_ERRORS:
+        pass
+    return None
+
+
+def verify_monotonic_decomposition(cert):
+    from .real_analysis.monotonic_certificates import MonotonicDecomposition
+
+    if not isinstance(cert, MonotonicDecomposition):
+        return False
+    try:
+        return sp.simplify(cert.reconstruct() - cert.expression) == 0
+    except SYMBOLIC_QUERY_ERRORS:
+        return False
+
+
+def verify_monotonic_partition(expr, var, cert):
+    from .proof_cache import property_proof_context
+    from .real_analysis.monotonic_certificates import MonotonicPartition
+
+    if not isinstance(cert, MonotonicPartition):
+        return False
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    ctx = property_proof_context(expr, var, domain=cert.domain)
+    try:
+        d = ctx.derivative(1, factored=True)
+        if cert.derivative is not None and sp.simplify(d - cert.derivative) != 0:
+            return False
+    except SYMBOLIC_QUERY_ERRORS:
+        return False
+    if cert.indexed is not None:
+        return bool(cert.indexed.boundary_geometry)
+    for cell in cert.cells:
+        if not isinstance(cell.interval, sp.Set):
+            return False
+        sg = property_proof_context(d, var, domain=cell.interval).sign(
+            domain=cell.interval
+        )
+        if cell.direction is Monotonicity.STRICTLY_INCREASING and sg not in (
+            Sign.POSITIVE,
+            Sign.NONNEGATIVE,
+        ):
+            return False
+        if cell.direction is Monotonicity.STRICTLY_DECREASING and sg not in (
+            Sign.NEGATIVE,
+            Sign.NONPOSITIVE,
+        ):
+            return False
+        if cell.direction is Monotonicity.NONDECREASING and sg not in (
+            Sign.POSITIVE,
+            Sign.NONNEGATIVE,
+            Sign.ZERO,
+        ):
+            return False
+        if cell.direction is Monotonicity.NONINCREASING and sg not in (
+            Sign.NEGATIVE,
+            Sign.NONPOSITIVE,
+            Sign.ZERO,
+        ):
+            return False
+    return True
+
+
+def verify_zero_geometry(cert):
+    from .transcendental.zero_geometry import IndexedZero, ZeroGeometryCertificate
+
+    if not isinstance(cert, ZeroGeometryCertificate):
+        return False
+    if not isinstance(cert.support, sp.Set):
+        return False
+    if cert.derivative_order < 0:
+        return False
+    for z in cert.indexed_family:
+        if not isinstance(z, IndexedZero):
+            return False
+        if z.family != cert.family or z.derivative_order != cert.derivative_order:
+            return False
+    for o in cert.orderings:
+        if o.relation not in ("<", "<=", ">", ">="):
+            return False
+    return all(inter.pattern for inter in cert.interlacings)
+
+
+def verify_convexity_certificate(expr, var, cert):
+    from .proof_cache import property_proof_context
+    from .real_analysis.advanced_convexity import ConvexityCertificate
+
+    if not isinstance(cert, ConvexityCertificate):
+        return False
+    if cert.modulus is None:
+        return bool(cert.method and cert.classification is not None)
+    if cert.modulus.is_positive is not True:
+        return False
+    d2 = property_proof_context(expr, var, domain=cert.domain).derivative(2)
+    concave = cert.classification.name.endswith("CONCAVE")
+    target = sp.simplify((-d2 if concave else d2) - cert.modulus)
+    sg = property_proof_context(target, var, domain=cert.domain).sign(
+        domain=cert.domain
+    )
+    return sg in (Sign.ZERO, Sign.NONNEGATIVE, Sign.POSITIVE)
+
+
+def verify_extremum_ordering_theorem(cert):
+    from .transcendental.extrema import ExtremumOrderingTheorem
+
+    if not isinstance(cert, ExtremumOrderingTheorem):
+        return False
+    if cert.magnitude_direction not in ("increasing", "decreasing"):
+        return False
+    if not cert.family or not cert.source:
+        return False
+    return cert.proof is not None
+
+
+def verify_indexed_tail_inversion(cert):
+    from .transcendental.zero_geometry import (
+        IndexedTailInversionCertificate,
+        IndexedZero,
+    )
+
+    if not isinstance(cert, IndexedTailInversionCertificate):
+        return False
+    if cert.direction not in ("left", "right"):
+        return False
+    if not isinstance(cert.zero_template, IndexedZero):
+        return False
+    if cert.zero_template.family != cert.family:
+        return False
+    if cert.integer_bracket is not None:
+        b = cert.integer_bracket
+        try:
+            if (sp.simplify(b.upper - b.lower)).is_negative is True:
+                return False
+            if (
+                getattr(b, "exact", False)
+                and sp.simplify(cert.first_index - b.lower) != 0
+            ):
+                return False
+        except SYMBOLIC_QUERY_ERRORS:
+            return False
+    return True
+
+
+def verify_certificate(cert, *, expr=None, var=None):
+    """Dispatch a supported certificate to its replay verifier."""
+    from .real_analysis.advanced_convexity import ConvexityCertificate
+    from .real_analysis.monotonic_certificates import (
+        MonotonicDecomposition,
+        MonotonicPartition,
+    )
+    from .real_analysis.structural_properties import (
+        HomogeneityResult,
+        PeriodicityResult,
+        SymmetryResult,
+    )
+    from .transcendental.extrema import (
+        ExtremumFamilyCertificate,
+        ExtremumOrderingTheorem,
+        ExtremumRange,
+    )
+    from .transcendental.roots import RootCertificate
+    from .transcendental.zero_geometry import (
+        CertifiedIntegerBracket,
+        IndexedTailInversionCertificate,
+        ZeroGeometryCertificate,
+    )
+
+    if isinstance(cert, MonotonicDecomposition):
+        return verify_monotonic_decomposition(cert)
+    if isinstance(cert, MonotonicPartition):
+        if expr is None or var is None:
+            raise ValueError("expr and var are required for MonotonicPartition replay")
+        return verify_monotonic_partition(expr, var, cert)
+    if isinstance(cert, ConvexityCertificate):
+        if expr is None or var is None:
+            raise ValueError("expr and var are required for convexity replay")
+        return verify_convexity_certificate(expr, var, cert)
+    if isinstance(cert, ZeroGeometryCertificate):
+        return verify_zero_geometry(cert)
+    if isinstance(cert, RootCertificate):
+        return verify_root_certificate(cert)
+    if isinstance(cert, ExtremumFamilyCertificate):
+        return verify_extremum_family_certificate(cert)
+    if isinstance(cert, ExtremumRange):
+        return verify_extremum_range(cert)
+    if isinstance(cert, ExtremumOrderingTheorem):
+        return verify_extremum_ordering_theorem(cert)
+    if isinstance(cert, CertifiedIntegerBracket):
+        return verify_integer_bracket(cert)
+    if isinstance(cert, IndexedTailInversionCertificate):
+        return verify_indexed_tail_inversion(cert)
+    if isinstance(cert, PeriodicityResult):
+        if expr is None or var is None:
+            raise ValueError("expr and var are required for periodicity replay")
+        return verify_periodicity_result(expr, var, cert)
+    if isinstance(cert, SymmetryResult):
+        if expr is None or var is None:
+            raise ValueError("expr and var are required for symmetry replay")
+        return verify_symmetry_result(expr, var, cert)
+    if isinstance(cert, HomogeneityResult):
+        if expr is None:
+            raise ValueError("expr is required for homogeneity replay")
+        return verify_homogeneity_result(expr, cert)
+    raise TypeError(f"unsupported certificate type: {type(cert).__name__}")
+
+
+def verify_root_certificate(cert):
+    from .transcendental.roots import RootCertificate
+
+    if not isinstance(cert, RootCertificate):
+        return False
+    if not isinstance(cert.domain, sp.Set):
+        return False
+    try:
+        if cert.root_count is not None and cert.root_count is not sp.oo:
+            n = sp.sympify(cert.root_count)
+            if n.is_integer is False or n.is_nonnegative is False:
+                return False
+    except SYMBOLIC_QUERY_ERRORS:
+        return False
+    return bool(cert.method)
+
+
+def verify_extremum_family_certificate(cert):
+    from .transcendental.extrema import ExtremumFamilyCertificate
+
+    if not isinstance(cert, ExtremumFamilyCertificate):
+        return False
+    if not cert.family:
+        return False
+    if not all(verify_zero_geometry(g) for g in cert.critical_geometry):
+        return False
+    return all(getattr(e, "family", cert.family) == cert.family for e in cert.extrema)
+
+
+def verify_extremum_range(cert):
+    from .transcendental.extrema import ExtremumRange
+
+    if not isinstance(cert, ExtremumRange):
+        return False
+    try:
+        d = sp.simplify(sp.sympify(cert.upper) - sp.sympify(cert.lower))
+        if d.is_negative is True:
+            return False
+    except SYMBOLIC_QUERY_ERRORS:
+        return False
+    return not (
+        cert.complete and (cert.lower_attained is None or cert.upper_attained is None)
+    )
+
+
+def verify_integer_bracket(cert):
+    from .transcendental.zero_geometry import CertifiedIntegerBracket
+
+    if not isinstance(cert, CertifiedIntegerBracket):
+        return False
+    try:
+        d = sp.simplify(cert.upper - cert.lower)
+        if d.is_negative is True:
+            return False
+        if cert.lower.is_integer is False or cert.upper.is_integer is False:
+            return False
+    except SYMBOLIC_QUERY_ERRORS:
+        return False
+    return True
+
+
+def verify_periodicity_result(expr, var, cert):
+    from .real_analysis.structural_properties import PeriodicityResult
+    from .results import Periodicity
+
+    if not isinstance(cert, PeriodicityResult):
+        return False
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    if cert.classification is Periodicity.CONSTANT:
+        return not expr.has(var)
+    if cert.classification is Periodicity.PERIODIC:
+        if cert.period is None:
+            return False
+        if (
+            cert.period.is_positive is not True
+            and "conditional-affine-frequency" not in cert.evidence
+        ):
+            return False
+        try:
+            if sp.simplify(expr.subs(var, var + cert.period) - expr) == 0:
+                return True
+            if "conditional-affine-frequency" in cert.evidence and expr.func in (
+                sp.sin,
+                sp.cos,
+                sp.tan,
+                sp.cot,
+            ):
+                a = sp.simplify(sp.diff(expr.args[0], var))
+                return not a.has(var) and cert.conditions == sp.Ne(a, 0)
+            return False
+        except SYMBOLIC_QUERY_ERRORS:
+            return False
+    if cert.classification is Periodicity.APERIODIC:
+        try:
+            return (
+                bool(expr.is_polynomial(var) and sp.Poly(expr, var).degree() > 0)
+                or "incommensurate-component-periods" in cert.evidence
+            )
+        except SYMBOLIC_QUERY_ERRORS:
+            return "incommensurate-component-periods" in cert.evidence
+    return cert.classification.value == "unknown"
+
+
+def verify_symmetry_result(expr, var, cert):
+    from .real_analysis.structural_properties import SymmetryResult
+    from .results import Symmetry
+
+    if not isinstance(cert, SymmetryResult):
+        return False
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    c = sp.sympify(cert.center)
+    try:
+        ref = sp.simplify(expr.subs(var, 2 * c - var))
+        ev = sp.simplify(ref - expr) == 0
+        od = sp.simplify(ref + expr) == 0
+    except SYMBOLIC_QUERY_ERRORS:
+        return False
+    if cert.classification is Symmetry.BOTH:
+        return ev and od
+    if cert.classification is Symmetry.EVEN:
+        return ev
+    if cert.classification is Symmetry.ODD:
+        return od
+    if cert.classification is Symmetry.CENTRAL:
+        try:
+            return sp.simplify(ref + expr - 2 * cert.central_value) == 0
+        except SYMBOLIC_QUERY_ERRORS:
+            return False
+    if cert.classification is Symmetry.NEITHER:
+        return not ev and not od
+    return True
+
+
+def _substitute_equalities(expr, assumptions):
+    repl = {}
+    atoms = assumptions.args if isinstance(assumptions, sp.And) else (assumptions,)
+    for a in atoms:
+        if isinstance(a, sp.Equality):
+            if getattr(a.lhs, "is_Symbol", False) and not a.rhs.has(a.lhs):
+                repl[a.lhs] = a.rhs
+            elif getattr(a.rhs, "is_Symbol", False) and not a.lhs.has(a.rhs):
+                repl[a.rhs] = a.lhs
+    return sp.simplify(expr.xreplace(repl)) if repl else sp.simplify(expr)
+
+
+def verify_homogeneity_result(expr, cert):
+    from .real_analysis.structural_properties import HomogeneityResult
+    from .results import Homogeneity
+
+    if not isinstance(cert, HomogeneityResult):
+        return False
+    expr = sp.sympify(expr)
+    assumptions = getattr(cert, "assumptions", S.true)
+    if cert.classification is not Homogeneity.HOMOGENEOUS:
+        return True
+    if cert.degree is None:
+        reduced = _substitute_equalities(expr, assumptions)
+        return reduced == 0 or not any(reduced.has(v) for v in cert.variables)
+    t = sp.Dummy("_verify_scale", positive=True)
+    try:
+        scaled = expr.xreplace(
+            {
+                v: t**w * v
+                for v, w in zip(
+                    cert.variables,
+                    cert.weights or (S.One,) * len(cert.variables),
+                    strict=False,
+                )
+            }
+        )
+        return _substitute_equalities(scaled - t**cert.degree * expr, assumptions) == 0
+    except SYMBOLIC_QUERY_ERRORS:
+        return False

funcprops-0.1.0.dist-info/METADATA

@@ -0,0 +1,208 @@
+Metadata-Version: 2.4
+Name: funcprops
+Version: 0.1.0
+Summary: Symbolic global function properties backed by SymPy
+Author-email: Bhuvanesh Bhatt <bhuvaneshbhatt@gmail.com>
+License-Expression: GPL-3.0-only
+Project-URL: Homepage, https://github.com/BhuvaneshBhatt/funcprops
+Project-URL: Documentation, https://github.com/BhuvaneshBhatt/funcprops#readme
+Project-URL: Repository, https://github.com/BhuvaneshBhatt/funcprops
+Keywords: sympy,symbolic mathematics,symbolic computation,function analysis,function properties,real analysis,complex analysis,domains,ranges,zeros,root isolation,monotonicity,convexity,continuity,differentiability,smoothness,singularities,branch cuts,injectivity,surjectivity,bijectivity,sign analysis,semialgebraic,certified computation,exact computation
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: sympy>=1.14
+Requires-Dist: mpmath>=1.3
+Requires-Dist: semialg>=1.0.0
+Provides-Extra: test
+Requires-Dist: pytest>=8; extra == "test"
+Requires-Dist: hypothesis>=6; extra == "test"
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == "dev"
+Requires-Dist: hypothesis>=6; extra == "dev"
+Requires-Dist: ruff>=0.8; extra == "dev"
+Dynamic: license-file
+
+# funcprops
+
+`funcprops` is a SymPy-backed package for global function properties.
+It combines a conditional function property registry, exact semialgebraic reasoning from the semialgebraic geometry package `semialg`, transcendental interval analysis, special-function zero geometry, and branch-cut/singularity analysis.
+
+The package is careful: parameter conditions are retained instead of guessed, piecewise branches are analyzed on their effective domains, incomplete numerical searches are never promoted to exact proofs, and undecidable comparisons remain unknown.
+
+## Installation
+
+```bash
+pip install funcprops
+```
+
+The core runtime requires SymPy, mpmath, and semialg 1.0.0 or newer.
+
+## Quick start
+
+```python
+import sympy as sp
+from funcprops import (
+    function_analytic,
+    function_branchcuts,
+    function_continuous,
+    function_convexity,
+    function_domain,
+    function_homogeneity,
+    function_meromorphic,
+    function_monotonicity,
+    function_periodicity,
+    function_poles,
+    function_range,
+    function_symmetry,
+)
+
+x, y = sp.symbols("x y", real=True)
+z = sp.Symbol("z")
+
+function_domain(sp.sqrt(x - 1), x)
+# x >= 1
+
+function_range(x**2, x, y)
+# y >= 0
+
+function_monotonicity(sp.exp(x), x)
+# Monotonicity.STRICTLY_INCREASING
+
+function_convexity(x**2, x)
+# Convexity.STRONGLY_CONVEX
+
+function_periodicity(sp.sin(2 * x) + sp.cos(3 * x), x, details=True).period
+# 2*pi
+
+function_symmetry((x - 2) ** 2, x, center=None, details=True).center
+# 2
+
+function_homogeneity(x**2 + y**4, (x, y), weights=(2, 1), details=True).degree
+# 4
+
+function_branchcuts(sp.log(1 - z), z)
+# structural pullback of the principal logarithm cut
+
+function_poles(sp.sin(z) / z**3, z)[0].multiplicity
+# 2
+
+function_analytic(sp.log(z), z, domain=sp.S.Complexes)
+# Analyticity.ANALYTIC on the principal branch's natural domain
+
+function_meromorphic(sp.log(z), z)
+# Meromorphicity.NOT_MEROMORPHIC
+
+function_continuous(sp.Abs(x), x)
+# Continuity.CONTINUOUS
+```
+
+## Property model
+
+API functions return exact classifications when the available proof machinery is sufficient. `PropertyResult` and `ConditionalValue` are the common representation for parameter strata across real and complex properties, so unresolved guards are preserved instead of being collapsed into a single answer. `PropertyResult.as_piecewise()` provides a Piecewise-style view when useful.
+
+Three-valued reasoning is used throughout proof-oriented code. An undecidable set relation, domain implication, branch-locus intersection, or symbolic comparison is not treated as false merely because Python cannot decide it.
+
+## Real-domain analysis
+
+`funcprops` owns the property vocabulary. For semialgebraic functions on semialgebraic real domains `funcprops` delegates exact domain, range, sign, monotonicity, convexity, smoothness, and mapping-property problems to `semialg`, while retaining stronger exact `funcprops` results when they are already certified. A shared sign engine is the main inequality proof primitive: derivative signs feed monotonicity and convexity, while relation queries reduce comparisons to the sign of a difference. Transcendental expressions are handled compositionally using primitive facts, exact domain restrictions, periodic reductions, derivative geometry, and certified interval reasoning.
+
+Mixed variable/parameter domains are split once by the shared stratification layer and each variable-domain branch is analyzed independently. Finite `Piecewise` expressions likewise use one effective-branch representation. Consumers add only the interface conditions their property requires: monotonicity checks jump direction, convexity checks continuity and derivative ordering, and sign and boundedness combine exact branch classifications.
+
+The main real-analysis APIs include:
+
+- `function_domain()` and `function_range()`;
+- `function_sign()`;
+- `function_boundedness()`;
+- `function_monotonicity()`;
+- `function_oscillation()`;
+- `function_convexity()` with normalized `ConvexityCertificate` evidence;
+- `function_injective()`, `function_surjective()`, and `function_bijective()`;
+- `function_continuous()`, `function_differentiability()`, `function_smoothness()`, and `function_analytic()`;
+- `function_periodicity()`, `function_symmetry()`, and `function_homogeneity()`.
+
+Multivariate APIs normalize variable collections explicitly rather than treating a tuple as one symbolic atom. Constant-Hessian convexity and affine mapping cases are handled exactly; unsupported nonlinear multivariate mapping questions give unknown.
+
+## Monotonic partitions and exact inverse solving
+
+`MonotonicPartition` is the shared exact interval representation used by monotonicity, range, injectivity, inverse solving, oscillation, and extrema. Finite partitions retain exact critical points, endpoint limits, and endpoint attainment. Infinite oscillatory partitions retain indexed zero geometry without guessing an unsupported increasing/decreasing phase.
+
+`solve_monotonic_inverse()` first attempts a whole-domain exact solve. If that is insufficient, it uses monotonic cells and exact image pruning. On a strict finite cell, an unresolved symbolic inverse can still be completed by certified endpoint signs and a rational isolating interval. `certified_monotonic_inverse()` is the explicit certification-oriented spelling of the same reusable primitive. The same partition can be passed explicitly to consumers or reused through the bounded proof cache.
+
+## Certified real-root backends
+
+Real root isolation is domain-cell aware: denominator zeros, logarithm boundaries, noninteger-power branch boundaries, Piecewise switch points, and other exact domain boundaries split the problem before any interval certificate is constructed. Identically-zero interval cells are retained as ordinary parts of the mathematical zero set.
+
+For finite elementary cells, an outward-rounded interval evaluator can prove that zero is excluded from the function image, or from the derivative image. The latter certifies strict monotonicity even when symbolic monotonicity is unresolved. Point signs use `robust_real_sign()`, which combines exact SymPy sign reasoning with an audited exp/log interval fallback to avoid overflow and underflow.
+
+`exponential_fourier_count()` provides a restricted derivative-sequence root counter for real exponential polynomials. After multiplication by a positive exponential factor, each derivative step removes the lowest exponential term. When every derivative root and endpoint/critical sign is exact, recursive Rolle/monotonicity reasoning certifies the number of distinct roots on the requested interval.
+
+## Certified complex root isolation
+
+`function_complex_zeros` isolates zeros in finite complex rectangles. It uses exact complex solving when available and otherwise a validated argument-principle contour: structural holomorphy certification, adaptive complex-interval boundary enclosures that exclude zero, winding-number counting, and count-preserving rational rectangle subdivision. Uncertified numerical winding estimates remain diagnostic only.
+
+## Zero geometry and oscillatory extrema
+
+Special-function zeros are represented symbolically when closed forms are not available. `IndexedZero`, `ZeroOrdering`, `ZeroInterlacing`, and `ZeroGeometryCertificate` describe exact support, simplicity, ordering, interlacing, and completeness information.
+
+Derivative-zero geometry feeds interval decomposition. A finite exact root set produces concrete cells; a complete infinite family can produce an indexed alternating-cell structure. This allows exact reasoning about Airy, Bessel, and classical orthogonal-polynomial behavior without truncating an infinite zero sequence numerically.
+
+`IndexedExtremumValue` and `ExtremumEnvelope` represent exact critical values and infinite extremum families. `symbolic_extremum_range()` combines them with exact endpoint values or limits. For supported Airy and Bessel families, analytic ordering theorems reduce infinite extremum envelopes to finite exact candidates.
+
+`IndexedTailIndex` and indexed-tail inversion represent the least zero/extremum index entering a semi-infinite domain. Same-family cutoffs and certified interlacing can reduce the symbolic selector to an ordinary integer; otherwise it remains exact as a symbolic set-theoretic minimum.
+
+## Periodicity, symmetry, and homogeneity
+
+Periodicity propagates exact common periods through commensurate sums, products, and compositions. Parameter-dependent affine frequencies retain their nonzero frequency condition, and a returned period is not called fundamental unless minimality is established.
+
+Symmetry supports a specified reflection center as well as exact center discovery for supported polynomial and affine-trigonometric forms. Detail results can retain families of equivalent even/odd centers and central point symmetry.
+
+Homogeneity supports ordinary and weighted multivariate scaling. Polynomial analysis preserves exact parameter strata when coefficients determine which weighted-degree blocks survive, including the identically zero case.
+
+## Singularities and branch cuts
+
+`function_singularity_analysis()` performs condition-aware structural traversal of poles, removable singularities, essential singularities, branch points, branch cuts, definition cuts, and discontinuities. Piecewise guards and parameter guards are retained. Unknown primitive heads are recorded instead of silently treated as regular.
+
+`function_branchcuts()` provides inexpensive structural pullback of principal cuts. Boundary-value and jump computations are available under `funcprops.branchcuts`.
+
+Real analyticity and complex holomorphy are kept distinct from meromorphicity. For example, the principal logarithm is locally holomorphic on its natural complex domain but is not meromorphic on the complex plane because of its branch structure.
+
+## Special-function property registry
+
+The conditional registry contains SymPy/mpmath family metadata from an audited property catalogue. Catalogue values and guards are stored in deterministic SymPy constructor syntax, so rule loading does not depend on a second expression grammar. Concrete SymPy overloads are matched before guards are instantiated, and more-specific rules take precedence over generic ones. Literal pattern failures do not count as matches.
+
+Selected special-function facts are cross-checked against the NIST Digital Library of Mathematical Functions (DLMF). The audit distinguishes direct formula-backed facts from derived wrapper/helper facts and from merely related DLMF material. The machine-readable manifest is `src/funcprops/data/dlmf_audit.json`.
+
+## Proof cache and certificate replay
+
+Reusable proof primitives are coordinated through a lazy `PropertyProofContext`. Constructing a context does no mathematical work. Independent bounded LRU caches hold raw and factored derivatives, natural domains, sign results, endpoint limits, zero geometry, singularity analyses, and monotonic partitions.
+
+Cache-key normalization is intentionally inexpensive and syntactic; it does not run quantifier elimination or expensive logical simplification simply to form a key. Raw and factored derivatives use separate cache slots so callers that need only a derivative do not pay for factorization.
+
+Certificates can be replayed with `verify_certificate()` and specialized verifiers. Convexity uses one `ConvexityCertificate` shape for ordinary, strict, and strong classifications; strong certificates additionally carry the certified modulus. Replay is conservative: an undecidable comparison never counts as a successful verification.
+
+## Documentation
+
+- [Function property reference](https://github.com/BhuvaneshBhatt/funcprops/blob/main/docs/properties/index.md) — comprehensive definitions, API contracts, examples, applications, proof strategies, and limitations for every public `function_*` query.
+- [Function properties tutorial notebook](https://github.com/BhuvaneshBhatt/funcprops/blob/main/docs/notebooks/function-properties-tour.ipynb) — an executable tour built from the same tested examples as the reference documentation.
+- [Architecture](https://github.com/BhuvaneshBhatt/funcprops/blob/main/docs/architecture.md)
+- [DLMF audit methodology](https://github.com/BhuvaneshBhatt/funcprops/blob/main/docs/dlmf_audit.md)
+- [Source repository](https://github.com/BhuvaneshBhatt/funcprops)
+
+## Development
+
+Run the test suite against the source tree with:
+
+```bash
+PYTHONPATH=src pytest
+```
+
+The package intentionally keeps exact fast paths ahead of heavier partition, root-isolation, or semialgebraic machinery. Refactors should preserve that order unless a benchmark and correctness argument justify changing it.
+
+## License
+
+funcprops is licensed under the GNU General Public License version 3 only
+(`GPL-3.0-only`). See [LICENSE](https://github.com/BhuvaneshBhatt/funcprops/blob/main/LICENSE).

funcprops-0.1.0.dist-info/RECORD

@@ -0,0 +1,56 @@
+funcprops/__init__.py,sha256=gzGoGBBiTD-uo_-GfL9X_trGYAOGCxCw9hHEySHraek,6832
+funcprops/_semialg.py,sha256=04IlXW1SLas-qqRNpU7OSd-s3i8nOqyzefJW65F8Q0g,8169
+funcprops/api.py,sha256=oD4W_-kiuZzVt6kdNUuHG9m0SWMlfxQSXsQ4cRwbp2c,2205
+funcprops/conditions.py,sha256=d0ni0VVlksAfzle_wFdYK5eDRcWWJGZGvH-niUjo9H0,2377
+funcprops/dlmf.py,sha256=NAwz49M80Zi7hP2w3Z_rzyJU4wkmpPU7Z9DhLuLVn9A,778
+funcprops/engine.py,sha256=Z0uJ7J8Qdf-cfUwqDlF9LTNGDkArqq1r6QrNJqXOVk0,10468
+funcprops/exceptions.py,sha256=ZejGRT6XaGtH6Ix1jeG8QeEG6unkNbrO0pVrb83elSs,1220
+funcprops/proof_cache.py,sha256=ZSjiKRvexNcgzq0e15mkBs7XsGjsUcnn7aFSh_rm2iI,11912
+funcprops/registry.py,sha256=1EuQ3vn36vFbRHqXIW6BXfvcpRmkJqcQxR6gb_Sg3Mc,8504
+funcprops/results.py,sha256=h22ulm7AQwACPI8UsTaJTOwAFCcTMNf_2QS44Z4aQJo,6486
+funcprops/singularities.py,sha256=bu_TOlvB__gJ1OqnTSLaSDUtanpTCs-oUNZ63fPM_4Y,62140
+funcprops/stratification.py,sha256=DdqOEXf4cJabneX5UwdxLrhuglYlrezD9KbafZ9SXRI,17448
+funcprops/sympy_compare.py,sha256=j2zRRJPQLwmfgyUBWHECqPe0BIGbTKxCTImjpaC-rpM,1879
+funcprops/verification.py,sha256=obC7qJPaVBHwiXDwDKuUtQvcsdBmnvHD1PiEu55-7jM,14278
+funcprops/branchcuts/__init__.py,sha256=xsZ-PXkvLe5MuiaCln3LaVp6x81dZ3PrFwzNwyoQufM,4171
+funcprops/branchcuts/computation.py,sha256=rxJRC198IMhdjLMmurcU4RjoHWPs2Hppf3ShiXsHkXU,21800
+funcprops/branchcuts/core.py,sha256=ZEBdt_xyuZlHA6syzaSz6NxxH9LZ_Vd1eRSgDeIAiAs,33469
+funcprops/branchcuts/post_simplify.py,sha256=_dGDGasbrm3OjFnFZaYXtLPeBV5gR-NnlZqFv5JKoBo,14633
+funcprops/data/catalogue.json,sha256=Ycj8Gu5lX8tU4lySrNPxVJd4iF9scANpectCh2qE3PI,5269115
+funcprops/data/dlmf_audit.json,sha256=HlK_-uIcJgwtFmmyflFW_LaYsauXt64WEjYTTc1rdU0,92775
+funcprops/real_analysis/__init__.py,sha256=zi8cTlFhDs9qxHA5-EdGx_Vr4qXrHoJdr9Sxcrc1ryo,1595
+funcprops/real_analysis/advanced_convexity.py,sha256=fCQNcoiYx39UUbwSM-LzRLVYheGxoEhi33YDbzgATgs,8320
+funcprops/real_analysis/boundedness.py,sha256=MmFnkzVfKzHPxRrDItJfJj-Q44kIWryJuvWlNuXliVU,6561
+funcprops/real_analysis/common.py,sha256=8e01kciN91APhn1HAumh-i_M1p_xuF-SGja0Fyv-iEE,9288
+funcprops/real_analysis/convexity.py,sha256=Q5witapGOuv2HisK3rC0JDyY7wJyNDMQvi9qn3ndgE4,24439
+funcprops/real_analysis/differentiability.py,sha256=2ba3b5hGxZbcV0AB2HreoNs7VGJbFc1lrzTG2poHdaU,4268
+funcprops/real_analysis/domain.py,sha256=HZyAUV9l5tlIMew5OAAVAxsDs1jtGe_ox66D-7RNM_A,7593
+funcprops/real_analysis/mapping.py,sha256=YHBrM5fXQaFbRdIbAwLaVZV4lPXqf-yXAra0dlpThRw,13841
+funcprops/real_analysis/monotonic_certificates.py,sha256=nsF-QhTSINg8TGCtLHwmJFIES_WMATPFidAjMyKYFnM,29458
+funcprops/real_analysis/monotonicity.py,sha256=r_nlgYcgPQ1-G6MtvR4IWLaVXvHrzByiCGiVxXJsvhs,25145
+funcprops/real_analysis/oscillation.py,sha256=qXayFA7-iPW6iUqd179LXz1nFM5HEh_cO9kodcL0iGw,5133
+funcprops/real_analysis/piecewise.py,sha256=DJSqxt71M437-Skv4P2mrrB4jXuXiEZQZ43_66lUQt4,6413
+funcprops/real_analysis/range.py,sha256=QdVRVryF590_c0TLJG7e0mPbV7tm0kz4YIOsqrY6fD4,20158
+funcprops/real_analysis/sign.py,sha256=trRj15zD85s5FS6qL65M3AGBs9TpzQIsvT05m4jxURs,19146
+funcprops/real_analysis/smoothness.py,sha256=1dDf7UOWJmMRuIIc-dHmNzQ5ohFZg5FLpEABv_0BRS4,9118
+funcprops/real_analysis/special_functions.py,sha256=yAmQFoqQ0Zt1JStuvzKKXr_tjIAvF47CZ6oAKvRKVBg,16644
+funcprops/real_analysis/structural_properties.py,sha256=GyxqxH2hqidjJIRvMuML__0NUB2ftCwUiNFJ28lDQ1I,20110
+funcprops/real_analysis/zeros.py,sha256=dUUAln-YW72kYM9cqsPkSmMRL2QmYI6ueAKeFK1Nflc,11057
+funcprops/transcendental/__init__.py,sha256=TiNrrKrpZBwlmVty2paqsAS7LzW41qYThTLesMyNfyM,3648
+funcprops/transcendental/algebraize.py,sha256=VmKAWKKS4vYbv6qV1vE5bdqGW3qhg2947hADGmAJGns,6032
+funcprops/transcendental/analytic.py,sha256=DZ22HGn-aZ3VCy50yARmOmOF8lzIhGf-9ACuers7_xI,7973
+funcprops/transcendental/complex_roots.py,sha256=Ks3dWVmr84-fTzFziiZaO9y9OKz6nv3xzDfbCS0hz9o,15974
+funcprops/transcendental/exp_fourier.py,sha256=C_U5s18U89PmwJU1pFQWNr_IF80ZkLQHVuKEVco2ywI,6977
+funcprops/transcendental/extrema.py,sha256=fg1z3G6zRkA2Wsnp-aFNXulff5vC9ajJmn5SPX2XF7I,29285
+funcprops/transcendental/periodic.py,sha256=E83TmL_hR_YfgvH5ovji66ZpTxqvHMsYXBEEcZ75InQ,7276
+funcprops/transcendental/proof.py,sha256=UbAcJgdK17VxTElCHzKlAMwKduoC25TGxxosRvGLG0g,3050
+funcprops/transcendental/real_interval.py,sha256=dV8m4q1O0pnNgAJKke1erd4l3b9NUIpc9meLzsvuD5g,3765
+funcprops/transcendental/real_sign.py,sha256=gS-WLexzlw2txLJktgqUg0A3jptKWCeFWrTK-5g6ViY,3702
+funcprops/transcendental/reduce.py,sha256=AmC1fEZRVE015xT2x2trrIIMX3ljXhdGMQhQm577lcU,9593
+funcprops/transcendental/roots.py,sha256=HXVT_OOWdGdD5nkrDIkoOB5jUQ7gZeGEZTJTvUvzfiE,48303
+funcprops/transcendental/zero_geometry.py,sha256=oCKOor-UEYnWb_LhMeIkI9vJ5UF5fpsdo-TG0iq6Gs4,38801
+funcprops-0.1.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+funcprops-0.1.0.dist-info/METADATA,sha256=YfrjmYtndK-6rDh9nnqcuML8D1K27pFcUnMimcUAzKA,14263
+funcprops-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+funcprops-0.1.0.dist-info/top_level.txt,sha256=jk186mdxNzdJCigjKQx_lwqvKSd2CrSWAQZWWlWrDsw,10
+funcprops-0.1.0.dist-info/RECORD,,

funcprops-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+