funcprops 0.1.0__py3-none-any.whl

funcprops/transcendental/algebraize.py

@@ -0,0 +1,201 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import sympy as sp
+from sympy import S
+
+from ..exceptions import SYMBOLIC_QUERY_ERRORS
+from ..real_analysis.common import is_semialgebraic_expression
+
+
+@dataclass(frozen=True)
+class AlgebraizationResult:
+    expression: sp.Expr
+    substitutions: tuple[tuple[sp.Symbol, sp.Expr], ...]
+    constraints: sp.Basic = S.true
+    exact: bool = True
+    method: str = "none"
+    source_domain: object = S.Reals
+    relations: tuple[sp.Basic, ...] = ()
+    inverse_substitutions: tuple[tuple[sp.Symbol, sp.Expr], ...] = ()
+
+    @property
+    def changed(self):
+        return bool(self.substitutions)
+
+
+def _linear_coeff(expr, var):
+    try:
+        p = sp.Poly(sp.expand(expr), var)
+        if p.degree() <= 1:
+            return p.nth(1), p.nth(0)
+    except SYMBOLIC_QUERY_ERRORS:
+        pass
+    return None
+
+
+def _exp_generator(expr, var):
+    exps = list(expr.atoms(sp.exp))
+    if not exps:
+        return None
+    coeffs = []
+    for e in exps:
+        lc = _linear_coeff(e.args[0], var)
+        if lc is None:
+            return None
+        a, b = lc
+        if a == 0 or a.is_rational is not True or b.is_real is not True:
+            return None
+        coeffs.append((e, a, b))
+    slopes = [sp.Rational(a) for _, a, _ in coeffs]
+    from math import gcd, lcm
+
+    L = 1
+    for a in slopes:
+        L = lcm(L, int(a.q))
+    ints = [int(a * L) for a in slopes]
+    g = abs(ints[0])
+    for n in ints[1:]:
+        g = gcd(g, abs(n))
+    slope = sp.Rational(g, L)
+    return coeffs, slope if slope else None
+
+
+def algebraize_exponentials(expr, var):
+    expr = sp.sympify(expr)
+    data = _exp_generator(expr, var)
+    if data is None:
+        return AlgebraizationResult(expr, ())
+    coeffs, slope = data
+    u = sp.Dummy("u", real=True)
+    repl = {}
+    for e, a, b in coeffs:
+        power = sp.simplify(a / slope)
+        if power.is_Integer is not True:
+            return AlgebraizationResult(expr, ())
+        repl[e] = sp.exp(b) * u**power
+    new = sp.cancel(expr.xreplace(repl))
+    if not is_semialgebraic_expression(new, u):
+        return AlgebraizationResult(expr, ())
+    return AlgebraizationResult(
+        new,
+        ((u, sp.exp(slope * var)),),
+        u > 0,
+        True,
+        "exponential_substitution",
+        S.Reals,
+        (),
+        ((var, sp.log(u) / slope),),
+    )
+
+
+def rewrite_hyperbolic_to_exp(expr):
+    expr = sp.sympify(expr)
+    if expr.has(sp.sinh, sp.cosh, sp.tanh, sp.coth, sp.sech, sp.csch):
+        try:
+            return sp.cancel(expr.rewrite(sp.exp))
+        except SYMBOLIC_QUERY_ERRORS:
+            return expr
+    return expr
+
+
+def algebraize_trigonometric(expr, var, *, source_domain=None):
+    """Tangent-half-angle algebraization on a single branch.
+
+    Exact on ``(-pi, pi)`` (or a supplied subset thereof):
+    ``u=tan(x/2)``, ``sin(x)=2u/(1+u^2)``, ``cos(x)=(1-u^2)/(1+u^2)``.
+    """
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    if not expr.has(sp.sin(var), sp.cos(var)):
+        return AlgebraizationResult(expr, ())
+    # Only direct sin(x), cos(x); affine phases are handled by periodic reduction first.
+    bad = [a for a in expr.atoms(sp.sin, sp.cos) if a.args[0] != var]
+    if bad:
+        return AlgebraizationResult(expr, ())
+    u = sp.Dummy("t", real=True)
+    new = expr.xreplace(
+        {sp.sin(var): 2 * u / (1 + u**2), sp.cos(var): (1 - u**2) / (1 + u**2)}
+    )
+    new = sp.cancel(new)
+    # rational in u is semialgebraic away from its denominator; 1+u^2 is positive.
+    dom = (
+        sp.Interval.open(-sp.pi, sp.pi)
+        if source_domain is None
+        else sp.Intersection(sp.sympify(source_domain), sp.Interval.open(-sp.pi, sp.pi))
+    )
+    return AlgebraizationResult(
+        new,
+        ((u, sp.tan(var / 2)),),
+        S.true,
+        True,
+        "tangent_half_angle",
+        dom,
+        (),
+        ((var, 2 * sp.atan(u)),),
+    )
+
+
+def algebraize_trig_circle(expr, var):
+    """Algebraize direct sin/cos dependence over a full phase using s^2+c^2=1.
+
+    This transform is exact for existential range/sign questions over a full
+    period, but callers must respect the returned relation.
+    """
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    if not (expr.has(sp.sin(var)) or expr.has(sp.cos(var))):
+        return AlgebraizationResult(expr, ())
+    if any(a.args[0] != var for a in expr.atoms(sp.sin, sp.cos)):
+        return AlgebraizationResult(expr, ())
+    s = sp.Dummy("s", real=True)
+    c = sp.Dummy("c", real=True)
+    new = expr.xreplace({sp.sin(var): s, sp.cos(var): c})
+    return AlgebraizationResult(
+        new,
+        ((s, sp.sin(var)), (c, sp.cos(var))),
+        sp.Eq(s**2 + c**2, 1),
+        True,
+        "trig_circle",
+        sp.Interval.Ropen(0, 2 * sp.pi),
+        (sp.Eq(s**2 + c**2, 1),),
+    )
+
+
+def algebraize_common_subexpressions(expr, var):
+    expr = sp.sympify(expr)
+    counts = {}
+    for node in sp.preorder_traversal(expr):
+        if isinstance(node, sp.Function) and node.has(var):
+            counts[node] = counts.get(node, 0) + 1
+    repeated = [e for e, n in counts.items() if n > 1]
+    if not repeated:
+        return AlgebraizationResult(expr, ())
+    repl = {
+        e: sp.Dummy(f"t{i}", real=True)
+        for i, e in enumerate(sorted(repeated, key=sp.default_sort_key), 1)
+    }
+    return AlgebraizationResult(
+        expr.xreplace(repl),
+        tuple((v, k) for k, v in repl.items()),
+        S.true,
+        False,
+        "common_subexpression",
+    )
+
+
+def algebraize(expr, var, *, domain=None, allow_trig=False):
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    if is_semialgebraic_expression(expr, var):
+        return AlgebraizationResult(expr, ())
+    rewritten = rewrite_hyperbolic_to_exp(expr)
+    r = algebraize_exponentials(rewritten, var)
+    if r.changed:
+        return r
+    if allow_trig:
+        r = algebraize_trigonometric(expr, var, source_domain=domain)
+        if r.changed:
+            return r
+    return AlgebraizationResult(expr, ())

funcprops/transcendental/analytic.py

@@ -0,0 +1,261 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+import sympy as sp
+from sympy import S
+
+from ..exceptions import SYMBOLIC_QUERY_ERRORS
+
+
+@dataclass(frozen=True)
+class AnalyticNeighborhoodCertificate:
+    holomorphic: bool | None
+    region: object
+    method: str = "unknown"
+    obstructions: tuple[object, ...] = ()
+    evidence: tuple[object, ...] = ()
+
+    @property
+    def certified(self):
+        return self.holomorphic is not None
+
+
+_ENTIRE = (sp.exp, sp.sin, sp.cos, sp.sinh, sp.cosh, sp.erf, sp.erfc, sp.erfi)
+
+
+def _truth3(expr):
+    if expr in (True, S.true):
+        return True
+    if expr in (False, S.false):
+        return False
+    try:
+        q = sp.simplify(expr)
+        if q is S.true:
+            return True
+        if q is S.false:
+            return False
+    except SYMBOLIC_QUERY_ERRORS:
+        pass
+    return None
+
+
+def _all3(values):
+    unknown = False
+    for v in values:
+        if v is False:
+            return False
+        if v is None:
+            unknown = True
+    return None if unknown else True
+
+
+def _rect_contains(rect, z):
+    a, b = rect
+    z = sp.sympify(z)
+    tests = (
+        sp.Le(sp.re(a), sp.re(z)),
+        sp.Le(sp.re(z), sp.re(b)),
+        sp.Le(sp.im(a), sp.im(z)),
+        sp.Le(sp.im(z), sp.im(b)),
+    )
+    vals = [_truth3(t) for t in tests]
+    if any(v is False for v in vals):
+        return False
+    if all(v is True for v in vals):
+        return True
+    return None
+
+
+def _affine_data(g, var):
+    try:
+        p = sp.Poly(sp.expand(g), var)
+        if p.degree() > 1:
+            return None
+        c = p.nth(1)
+        d = p.nth(0)
+        if c.has(var) or d.has(var):
+            return None
+        return c, d
+    except SYMBOLIC_QUERY_ERRORS:
+        return None
+
+
+def _affine_image_bounds(g, var, rect):
+    # exact rectangular enclosure for affine g(z)=c*z+d
+    cd = _affine_data(g, var)
+    if cd is None:
+        return None
+    c, d = cd
+    try:
+        a, b = rect
+        corners = [
+            sp.re(a) + sp.I * sp.im(a),
+            sp.re(a) + sp.I * sp.im(b),
+            sp.re(b) + sp.I * sp.im(a),
+            sp.re(b) + sp.I * sp.im(b),
+        ]
+        vals = [sp.expand_complex(c * q + d) for q in corners]
+        rs = [sp.re(v) for v in vals]
+        ims = [sp.im(v) for v in vals]
+        if not all(v.is_real is True for v in rs + ims):
+            return None
+        # default_sort_key is syntactic, not numerical ordering.  Min/Max keep
+        # the bound exact and simplify when comparisons are decidable.
+        return sp.Min(*rs), sp.Max(*rs), sp.Min(*ims), sp.Max(*ims)
+    except SYMBOLIC_QUERY_ERRORS:
+        return None
+
+
+def _avoids_negative_real_axis(g, var, rect):
+    b = _affine_image_bounds(g, var, rect)
+    if b is None:
+        return None
+    r0, _r1, i0, i1 = b
+    # definitely above/below real axis, or entirely right of 0
+    if i0.is_positive is True or i1.is_negative is True or r0.is_positive is True:
+        return True
+    intersects_box = (
+        r0.is_nonpositive is True
+        and i0.is_nonpositive is True
+        and i1.is_nonnegative is True
+    )
+    if not intersects_box:
+        return None
+    # Bounding-box intersection does not prove intersection of a rotated
+    # parallelogram with the cut.  It *is* exact for real/pure-imaginary affine
+    # maps, whose image of an axis-aligned rectangle is axis-aligned.
+    cd = _affine_data(g, var)
+    if cd is not None:
+        c, _ = cd
+        axis_aligned = c.is_real is True or sp.simplify(sp.re(c)) == 0
+        if axis_aligned:
+            return False
+    return None
+
+
+def _nonzero_on_rectangle(g, var, rect):
+    if not g.has(var):
+        z = sp.simplify(g)
+        if z.is_zero is True:
+            return False
+        if z.is_zero is False:
+            return True
+        return None
+    try:
+        sol = sp.solveset(sp.Eq(g, 0), var, domain=S.Complexes)
+        if isinstance(sol, sp.FiniteSet):
+            unknown = False
+            for r in sol:
+                q = _rect_contains(rect, r)
+                if q is True:
+                    return False
+                if q is None:
+                    unknown = True
+            if not unknown:
+                return True
+    except SYMBOLIC_QUERY_ERRORS:
+        pass
+    b = _affine_image_bounds(g, var, rect)
+    if b is not None:
+        r0, r1, i0, i1 = b
+        if (
+            r0.is_positive is True
+            or r1.is_negative is True
+            or i0.is_positive is True
+            or i1.is_negative is True
+        ):
+            return True
+    return None
+
+
+def holomorphic_on_rectangle(expr, var, rectangle):
+    """Conservatively certify principal-branch holomorphy on a closed rectangle.
+
+    Returns ``holomorphic=None`` when the current symbolic tests cannot certify
+    either outcome.  No floating sampling is used for a positive certificate.
+    """
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    rect = tuple(map(sp.sympify, rectangle))
+    obs = []
+    ev = []
+
+    def rec(e):
+        if not e.has(var) or e == var:
+            return True
+        if e.func in _ENTIRE:
+            return _all3(rec(a) for a in e.args)
+        if e.func in (sp.Add, sp.Mul):
+            return _all3(rec(a) for a in e.args)
+        if e.func is sp.Pow:
+            b, p = e.args
+            sub = _all3((rec(b), rec(p)))
+            if sub is False:
+                return False
+            if p.is_Integer:
+                if p.is_nonnegative:
+                    return sub
+                nz = _nonzero_on_rectangle(b, var, rect)
+                ev.append(("nonzero", b, nz))
+                if nz is False:
+                    obs.append(sp.Eq(b, 0))
+                    return False
+                return _all3((sub, nz))
+            av = _avoids_negative_real_axis(b, var, rect)
+            ev.append(("principal_power_cut", b, av))
+            if av is False:
+                obs.append(("negative_real_axis", b))
+                return False
+            return _all3((sub, av))
+        if e.func is sp.log:
+            sub = rec(e.args[0])
+            if sub is False:
+                return False
+            av = _avoids_negative_real_axis(e.args[0], var, rect)
+            ev.append(("log_cut", e.args[0], av))
+            if av is False:
+                obs.append(("negative_real_axis", e.args[0]))
+                return False
+            return _all3((sub, av))
+        if e.func in (sp.tan,):
+            sub = rec(e.args[0])
+            if sub is False:
+                return False
+            nz = _nonzero_on_rectangle(sp.cos(e.args[0]), var, rect)
+            ev.append(("tan_poles", nz))
+            if nz is False:
+                obs.append(sp.Eq(sp.cos(e.args[0]), 0))
+                return False
+            return _all3((sub, nz))
+        if e.func in (sp.gamma,):
+            sub = rec(e.args[0])
+            if sub is False:
+                return False
+            # finite exact preimages of nonpositive integers need a dedicated
+            # pole-set proof; do not turn uncertainty into non-holomorphy.
+            return None
+        return None
+
+    ans = rec(expr)
+    return AnalyticNeighborhoodCertificate(
+        ans, rect, "structural_rectangle", tuple(obs), tuple(ev)
+    )
+
+
+def analytic_neighborhood(expr, var, interval, radius=None):
+    """Certify a complex rectangular neighborhood of a finite real interval."""
+    interval = sp.sympify(interval)
+    if (
+        not isinstance(interval, sp.Interval)
+        or interval.start in (-sp.oo, sp.oo)
+        or interval.end in (-sp.oo, sp.oo)
+    ):
+        return AnalyticNeighborhoodCertificate(None, interval, "unsupported_interval")
+    if radius is None:
+        radius = sp.Rational(1, 100)
+    r = sp.sympify(radius)
+    if r.is_positive is not True:
+        return AnalyticNeighborhoodCertificate(None, interval, "invalid_radius")
+    rect = (interval.start - sp.I * r, interval.end + sp.I * r)
+    return holomorphic_on_rectangle(expr, var, rect)