funcprops 0.1.0__py3-none-any.whl

funcprops/real_analysis/differentiability.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import sympy as sp
+
+from ..results import ConditionalValue, Continuity, Differentiability, PropertyResult
+from ..stratification import normalize_cases
+from .smoothness import function_smoothness
+
+
+def _differentiability_implications(
+    primary: Differentiability,
+) -> tuple[Differentiability, ...]:
+    """Return strictly weaker differentiability properties implied by ``primary``."""
+    if primary is Differentiability.SMOOTH:
+        return (Differentiability.CK, Differentiability.DIFFERENTIABLE)
+    if primary is Differentiability.CK:
+        return (Differentiability.DIFFERENTIABLE,)
+    return ()
+
+
+def _classify_smoothness(smoothness, order):
+    """Map a regularity certificate to the public differentiability class."""
+    verified = smoothness.differentiability_order
+    if order is not None:
+        if verified is sp.oo or verified == sp.oo:
+            return Differentiability.SMOOTH
+        if isinstance(verified, int) and verified >= order:
+            return (
+                Differentiability.DIFFERENTIABLE if order == 1 else Differentiability.CK
+            )
+        if smoothness.continuity is Continuity.DISCONTINUOUS or (
+            smoothness.smooth is False
+            and isinstance(verified, int)
+            and verified < order
+        ):
+            return Differentiability.NOT_DIFFERENTIABLE
+        return Differentiability.UNKNOWN
+    if verified is sp.oo or verified == sp.oo or smoothness.smooth is True:
+        return Differentiability.SMOOTH
+    if smoothness.continuity is Continuity.DISCONTINUOUS:
+        return Differentiability.NOT_DIFFERENTIABLE
+    if isinstance(verified, int) and verified >= 2:
+        return Differentiability.CK
+    if verified == 1:
+        return Differentiability.DIFFERENTIABLE
+    if smoothness.smooth is False and verified == 0:
+        return Differentiability.NOT_DIFFERENTIABLE
+    return Differentiability.UNKNOWN
+
+
+def function_differentiability(
+    expr,
+    var,
+    *,
+    domain=True,
+    order=None,
+    all_properties=False,
+    details=False,
+    max_order=6,
+):
+    """Classify differentiability on the requested real domain.
+
+    Unlike a syntactic ``diff`` test, this query requires the relevant
+    derivatives to be continuous on the whole requested domain. ``order=k``
+    asks whether the function is at least :math:`C^k`; without an order the
+    strongest certified class is returned. Parameter strata are preserved.
+    """
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    if order is not None:
+        if not isinstance(order, int) or isinstance(order, bool) or order < 1:
+            raise ValueError("order must be a positive integer or None")
+        probe_order = max(max_order, order)
+    else:
+        probe_order = max_order
+    if (
+        not isinstance(probe_order, int)
+        or isinstance(probe_order, bool)
+        or probe_order < 1
+    ):
+        raise ValueError("max_order must be a positive integer")
+
+    # Differentiability is a derivative-based property.  Populate the shared raw
+    # derivative cache before the higher-level smoothness analysis so callers
+    # consistently reuse the unfactored derivative proof object.  Keep
+    # factorization lazy: several structural smoothness rules (for example Abs)
+    # can otherwise bypass the derivative layer entirely.
+    from ..proof_cache import cached_derivative
+
+    cached_derivative(expr, var, order=1)
+    smoothness = function_smoothness(expr, var, domain=domain, max_order=probe_order)
+    if isinstance(smoothness, PropertyResult):
+        out = normalize_cases(
+            (
+                ConditionalValue(_classify_smoothness(c.value, order), c.condition)
+                for c in smoothness.cases
+            ),
+            source="differentiability-parameter-stratification",
+            evidence=smoothness.evidence,
+        )
+        return out
+
+    primary = _classify_smoothness(smoothness, order)
+    if all_properties or details:
+        return PropertyResult(
+            primary=primary,
+            all_properties=_differentiability_implications(primary),
+            source="smoothness-analysis",
+            exceptions=smoothness.exceptional_loci,
+            evidence=(smoothness,),
+        )
+    return primary

funcprops/real_analysis/domain.py

@@ -0,0 +1,188 @@
+from __future__ import annotations
+
+import sympy as sp
+from sympy import S
+
+from .. import _semialg
+from ..engine import evaluate_property, simplify_condition
+from ..exceptions import SYMBOLIC_QUERY_ERRORS
+from ..results import PropertyResult
+from ..stratification import (
+    semantic_condition,
+    stratify_boolean_by_parameters,
+)
+from .common import is_semialgebraic_expression
+
+
+def _pow_real_domain(expr, var):
+    base, exponent = expr.args
+    inner = _function_domain_impl(base, var)
+    if exponent.is_Integer:
+        if exponent.is_negative:
+            return sp.And(inner, sp.Ne(base, 0))
+        return inner
+    if exponent.is_Rational:
+        p, q = int(exponent.p), int(exponent.q)
+        if q % 2 == 0:
+            # Even root: nonnegative base. A negative exponent also excludes 0.
+            rel = base > 0 if p < 0 else base >= 0
+            return sp.And(inner, rel)
+        # Odd root is real for all real bases, but negative powers exclude zero.
+        return sp.And(inner, sp.Ne(base, 0)) if p < 0 else inner
+    # Irrational real powers use the principal real branch only for positive base.
+    if exponent.is_real is True:
+        return sp.And(inner, base > 0)
+    return inner
+
+
+def _function_domain_impl(expr, var, *, domain=S.Reals, stratified=False):
+    """Largest supported real/complex domain condition for ``expr`` in ``var``.
+
+    funcprops owns transcendental structural rules. semialg is invoked only for
+    expressions that are structurally semialgebraic.
+    """
+    expr = sp.sympify(expr)
+    var = sp.sympify(var)
+    real_mode = domain in (S.Reals, "real", "reals", "R", "RR")
+    complex_mode = domain in (S.Complexes, "complex", "complexes", "C", "CC")
+    if not (real_mode or complex_mode):
+        raise ValueError("domain must be Reals or Complexes")
+    if expr == var or not expr.has(var):
+        return S.true
+
+    if real_mode and isinstance(expr, sp.Piecewise):
+        clauses = []
+        covered = S.false
+        for value, cond in expr.args:
+            active = (
+                sp.And(cond, sp.Not(covered)) if cond is not S.true else sp.Not(covered)
+            )
+            clauses.append(
+                sp.And(active, _function_domain_impl(value, var, domain=S.Reals))
+            )
+            covered = sp.Or(covered, cond)
+        return sp.simplify(sp.Or(*clauses)) if clauses else S.false
+
+    if real_mode and expr.func is sp.Pow:
+        if is_semialgebraic_expression(expr, var):
+            try:
+                return sp.sympify(_semialg.function_domain(expr, var))
+            except SYMBOLIC_QUERY_ERRORS:
+                pass
+        # Symbolic exponents have genuinely parameter-dependent real domains
+        # (integer, negative-integer, and noninteger cases).  The catalogue is
+        # substantially more informative than the conservative x>0 fallback.
+        if expr.exp.free_symbols:
+            reg = evaluate_property(expr, "RealDomain", var=var, mode="real")
+            if reg.primary is not None:
+                dom = semantic_condition(reg.primary)
+                # SymPy defines x**0 as 1 even at x=0; the catalogue-derived
+                # source treats 0^0 as indeterminate.  SymPy semantics take
+                # precedence in funcprops.
+                return sp.Or(sp.Eq(expr.exp, 0), dom)
+        return simplify_condition(_pow_real_domain(expr, var))
+
+    # Ordinary arithmetic is defined wherever its varying operands are.
+    # This exact fallback keeps basic domain reasoning independent of semialg.
+    if real_mode and expr.func in (sp.Add, sp.Mul):
+        ds = []
+        for a in expr.args:
+            if a.has(var):
+                d = _function_domain_impl(a, var, domain=S.Reals)
+                if isinstance(d, PropertyResult):
+                    return d
+                ds.append(d)
+        return simplify_condition(sp.And(*ds)) if ds else S.true
+
+    # Trigonometric reciprocal/pole domains are clearer and more useful in
+    # structural form than the equivalent integer-membership catalogue rule.
+    if (
+        real_mode
+        and expr.func in (sp.tan, sp.sec, sp.cot, sp.csc)
+        and len(expr.args) == 1
+    ):
+        a = expr.args[0]
+        inner = (
+            _function_domain_impl(a, var, domain=S.Reals)
+            if a.has(var) and a != var
+            else S.true
+        )
+        denom = sp.cos(a) if expr.func in (sp.tan, sp.sec) else sp.sin(a)
+        return simplify_condition(sp.And(inner, sp.Ne(denom, 0)))
+
+    constraints = []
+
+    # semialg is an exact backend for semialgebraic expressions only.
+    if real_mode and is_semialgebraic_expression(expr, var):
+        try:
+            constraints.append(sp.sympify(_semialg.function_domain(expr, var)))
+        except _semialg.SemialgUnavailable:
+            pass
+        except SYMBOLIC_QUERY_ERRORS:
+            pass
+
+    mode = "real" if real_mode else "complex"
+    prop = "RealDomain" if real_mode else "ComplexDomain"
+    reg = evaluate_property(expr, prop, var=var, mode=mode)
+    if reg.primary is not None:
+        constraints.append(sp.sympify(reg.primary))
+    elif reg.cases:
+        # Preserve parameter-dependent domains as a Boolean piecewise equivalent:
+        # OR(guard AND domain-value). Unknown default stays unasserted.
+        terms = []
+        for case in reg.cases:
+            if case.value in (S.true, S.false) or isinstance(
+                case.value, (sp.logic.boolalg.Boolean, sp.core.relational.Relational)
+            ):
+                terms.append(sp.And(case.condition, case.value))
+        if terms:
+            constraints.append(sp.Or(*terms))
+
+    # Explicit elementary rules not represented as standalone SymPy heads in the registry.
+    if real_mode:
+        if expr.func is sp.exp:
+            constraints.append(S.true)
+        elif expr.func is sp.log and len(expr.args) == 1:
+            constraints.append(expr.args[0] > 0)
+        elif expr.func is sp.asin or expr.func is sp.acos:
+            a = expr.args[0]
+            constraints.append(sp.And(a >= -1, a <= 1))
+        elif expr.func is sp.acosh:
+            constraints.append(expr.args[0] >= 1)
+        elif expr.func is sp.atanh:
+            a = expr.args[0]
+            constraints.append(sp.And(a > -1, a < 1))
+
+    # Every varying argument must itself be defined.
+    for arg in getattr(expr, "args", ()):
+        if arg == var or not getattr(arg, "has", lambda *_: False)(var):
+            continue
+        d = _function_domain_impl(
+            arg, var, domain=S.Reals if real_mode else S.Complexes
+        )
+        if not isinstance(d, PropertyResult):
+            constraints.append(sp.sympify(d))
+
+    if not constraints:
+        return PropertyResult(primary="unknown_domain", source="funcprops")
+    try:
+        result = simplify_condition(sp.And(*constraints))
+    except SYMBOLIC_QUERY_ERRORS:
+        result = sp.And(*constraints)
+    if stratified and real_mode:
+        return stratify_boolean_by_parameters(
+            result, var, source="domain-parameter-stratification"
+        )
+    return result
+
+
+def function_domain(expr, var, *, domain=S.Reals, stratified=False):
+    """Cached public wrapper around the lazy real/complex domain prover."""
+    from ..proof_cache import property_proof_context
+
+    complex_mode = domain in (S.Complexes, "complex", "complexes", "C", "CC")
+    if not (complex_mode or domain in (S.Reals, "real", "reals", "R", "RR")):
+        raise ValueError("domain must be Reals or Complexes")
+    return property_proof_context(expr, var).natural_domain(
+        complex_domain=complex_mode, stratified=stratified
+    )

funcprops/real_analysis/mapping.py

@@ -0,0 +1,374 @@
+from __future__ import annotations
+
+import sympy as sp
+from sympy import S
+
+from .. import _semialg
+from ..exceptions import SYMBOLIC_QUERY_ERRORS
+from ..results import ConditionalValue, Monotonicity, PropertyResult, TruthValue
+from ..stratification import (
+    combine_truth_results,
+    exact_set_equal,
+    guarded_result,
+    normalize_cases,
+)
+from ..transcendental.periodic import positive_period
+from .common import (
+    combine_natural_domain_condition,
+    condition_to_set,
+    is_semialgebraic_condition,
+    is_semialgebraic_expression,
+    normalize_variables,
+)
+from .domain import function_domain
+from .monotonic_certificates import (
+    injectivity_from_monotonic_partition,
+    monotonic_partition,
+)
+from .monotonicity import function_monotonicity
+from .range import function_range
+
+
+def _combined_domain(expr, var, domain):
+    return combine_natural_domain_condition(function_domain(expr, var), domain, var)
+
+
+def _semialg_mapping_result(expr, var, domain, *, codomain=True):
+    """Return semialg mapping metadata when the whole problem is semialgebraic."""
+    if not (
+        is_semialgebraic_expression(expr, var)
+        and is_semialgebraic_condition(domain, var)
+    ):
+        return None
+    # semialg's mapping-properties query is currently nonparametric. Preserve
+    # funcprops' guarded parameter strata instead of quantifying/collapsing free
+    # coefficients as part of an ordinary mapping query.
+    problem_symbols = sp.sympify(expr).free_symbols | sp.sympify(domain).free_symbols
+    if problem_symbols - {var}:
+        return None
+    y = sp.Dummy("_semialg_y", real=True)
+    target = True
+    if codomain not in (S.Reals, True, None, S.true):
+        if isinstance(codomain, sp.Set):
+            try:
+                target = codomain.as_relational(y)
+            except (TypeError, ValueError, NotImplementedError):
+                return None
+        else:
+            target = sp.sympify(codomain).xreplace({var: y})
+        if not is_semialgebraic_condition(target, y):
+            return None
+    try:
+        return _semialg.function_mapping_properties(
+            expr, var, domain=domain, codomain=target, image_variable=y
+        )
+    except (_semialg.SemialgUnavailable, *SYMBOLIC_QUERY_ERRORS):
+        return None
+
+
+def _truth_from_backend(value):
+    return _semialg.normalize_truth(value)
+
+
+def _domain_at_most_one_point(dom, var):
+    ds = condition_to_set(dom, var)
+    if ds is S.EmptySet:
+        return True
+    if isinstance(ds, sp.FiniteSet):
+        return len(ds) <= 1
+    return False
+
+
+def _injectivity_from_monotonicity(m, dom, var):
+    if m in (Monotonicity.STRICTLY_INCREASING, Monotonicity.STRICTLY_DECREASING):
+        return TruthValue.TRUE
+    if m is Monotonicity.CONSTANT:
+        return (
+            TruthValue.TRUE if _domain_at_most_one_point(dom, var) else TruthValue.FALSE
+        )
+    return TruthValue.UNKNOWN
+
+
+def _multivariate_affine_map(expr, variables):
+    """Return (A,b) for an affine map, else None.
+
+    ``expr`` may be scalar or a tuple/list/Matrix. Coefficients may contain
+    parameters but must not depend on the mapped variables.
+    """
+    vv = tuple(variables)
+    if isinstance(expr, sp.MatrixBase):
+        outs = tuple(expr)
+    elif isinstance(expr, (tuple, list, sp.Tuple)):
+        outs = tuple(map(sp.sympify, expr))
+    else:
+        outs = (sp.sympify(expr),)
+    rows = []
+    offsets = []
+    for f in outs:
+        try:
+            row = [sp.simplify(sp.diff(f, v)) for v in vv]
+            if any(a.has(*vv) for a in row):
+                return None
+            b = sp.simplify(f - sum(a * v for a, v in zip(row, vv, strict=False)))
+            if b.has(*vv):
+                return None
+        except SYMBOLIC_QUERY_ERRORS:
+            return None
+        rows.append(row)
+        offsets.append(b)
+    return sp.Matrix(rows), sp.Matrix(offsets)
+
+
+def _full_rank_condition(A, rank):
+    """Return the exact symbolic condition that ``A`` has at least ``rank``."""
+    from itertools import combinations
+
+    m, n = A.shape
+    if rank == 0:
+        return S.true
+    if rank > min(m, n):
+        return S.false
+    minors = []
+    for rows in combinations(range(m), rank):
+        for cols in combinations(range(n), rank):
+            det = sp.simplify(A.extract(rows, cols).det())
+            if det.is_zero is False:
+                return S.true
+            if det.is_zero is not True:
+                minors.append(sp.Ne(det, 0))
+    return sp.Or(*minors) if minors else S.false
+
+
+def _rank_truth_result(A, required_rank, *, source):
+    condition = sp.simplify(_full_rank_condition(A, required_rank))
+    if condition is S.true:
+        return TruthValue.TRUE
+    if condition is S.false:
+        return TruthValue.FALSE
+    return normalize_cases(
+        (
+            ConditionalValue(TruthValue.TRUE, condition),
+            ConditionalValue(TruthValue.FALSE, sp.Not(condition)),
+        ),
+        source=source,
+    )
+
+
+def _multivariate_mapping_truth(
+    expr, variables, *, mode, domain=True, codomain=S.Reals
+):
+    # Exact support currently covers the natural full-real affine map. More
+    # complicated restricted multivariate domains must not be guessed.
+    if domain not in (True, None, S.true, S.Reals):
+        return TruthValue.UNKNOWN
+    aff = _multivariate_affine_map(expr, variables)
+    if aff is None:
+        return TruthValue.UNKNOWN
+    A, _ = aff
+    m, n = A.shape
+    if mode == "injective":
+        return _rank_truth_result(A, n, source="affine-rank-injectivity")
+    if mode == "surjective":
+        if codomain not in (S.Reals, True, None):
+            return TruthValue.UNKNOWN
+        return _rank_truth_result(A, m, source="affine-rank-surjectivity")
+    if mode == "bijective":
+        if m != n:
+            return TruthValue.FALSE
+        return _rank_truth_result(A, n, source="affine-rank-bijectivity")
+    return TruthValue.UNKNOWN
+
+
+def _affine_output_transform(expr, var):
+    """Return ``(scale, inner, offset)`` for a nontrivial affine output map."""
+    offset, dependent = expr.as_independent(var, as_Add=True)
+    scale, inner = dependent.as_independent(var, as_Add=False)
+    if inner == expr or (inner == dependent and scale == 1 and offset == 0):
+        return None
+    if scale.has(var) or offset.has(var) or not inner.has(var):
+        return None
+    return sp.simplify(scale), inner, sp.simplify(offset)
+
+
+def _injective_structural_closure(expr, var, domain, partition):
+    """Apply exact injectivity-preserving composition and affine-output rules."""
+    transform = _affine_output_transform(expr, var)
+    if transform is not None:
+        scale, inner, _ = transform
+        if scale.is_nonzero is True:
+            return function_injective(inner, var, domain=domain, partition=partition)
+        if scale.is_zero is True:
+            return (
+                TruthValue.TRUE
+                if _domain_at_most_one_point(domain, var)
+                else TruthValue.FALSE
+            )
+        if scale.free_symbols:
+            nonzero = function_injective(inner, var, domain=domain, partition=partition)
+            zero = (
+                TruthValue.TRUE
+                if _domain_at_most_one_point(domain, var)
+                else TruthValue.FALSE
+            )
+            nz = guarded_result(
+                nonzero, sp.Ne(scale, 0), source="affine-output-injectivity"
+            )
+            z = guarded_result(
+                zero, sp.Eq(scale, 0), source="affine-output-injectivity"
+            )
+            return normalize_cases(
+                (*nz.cases, *z.cases), source="affine-output-injectivity"
+            )
+    # These outer real functions are strictly increasing on their natural real
+    # domains, so composition preserves and reflects injectivity of the inner map.
+    if (
+        expr.func in {sp.exp, sp.log, sp.sinh, sp.asinh, sp.atan}
+        and len(expr.args) == 1
+    ):
+        inner = expr.args[0]
+        if inner != var and inner.has(var):
+            return function_injective(inner, var, domain=domain, partition=partition)
+    return TruthValue.UNKNOWN
+
+
+def function_injective(expr, var, *, domain=True, partition=None):
+    """Classify injectivity on the requested domain using exact witnesses.
+
+    Scalar functions reuse monotonicity and monotonic partitions before trying
+    exact equation solving. Multivariate cases use only supported structural
+    criteria and otherwise return ``UNKNOWN``.
+    """
+    vv = normalize_variables(var)
+    if len(vv) > 1:
+        return _multivariate_mapping_truth(expr, vv, mode="injective", domain=domain)
+    expr = sp.sympify(expr)
+    var = vv[0]
+    dom = _combined_domain(expr, var, domain)
+    backend = _semialg_mapping_result(expr, var, dom)
+    if backend is not None and backend.injective is not None:
+        return _truth_from_backend(backend.injective)
+    structural = _injective_structural_closure(expr, var, dom, partition)
+    if structural is not TruthValue.UNKNOWN:
+        return structural
+    m = function_monotonicity(expr, var, domain=dom, partition=partition)
+    if isinstance(m, PropertyResult):
+        cases = []
+        for c in m.cases:
+            v = _injectivity_from_monotonicity(c.value, dom, var)
+            if v is not TruthValue.UNKNOWN:
+                cases.append(ConditionalValue(v, c.condition))
+        if cases:
+            return normalize_cases(
+                cases, source="monotonicity-injectivity-stratification"
+            )
+    else:
+        direct = _injectivity_from_monotonicity(m, dom, var)
+        if direct is not TruthValue.UNKNOWN:
+            return direct
+
+    # Reuse the exact monotonic partition instead of solving derivative zeros
+    # again.  Same-direction strict cells cover stationary inflections; a
+    # certified direction reversal gives an exact noninjectivity proof.
+    part = (
+        partition
+        if partition is not None
+        and getattr(partition, "domain", None) == condition_to_set(dom, var)
+        else monotonic_partition(expr, var, domain=dom)
+    )
+    pv = injectivity_from_monotonic_partition(part)
+    if pv is not TruthValue.UNKNOWN:
+        return pv
+    if not expr.has(var):
+        return (
+            TruthValue.TRUE if _domain_at_most_one_point(dom, var) else TruthValue.FALSE
+        )
+
+    # Periodicity is an exact disproof only when the requested interval contains
+    # a pair x,x+p.  Merely having width == p is insufficient for a half-open
+    # interval without additional continuity information.
+    p = positive_period(expr, var)
+    if p is not None:
+        ds = condition_to_set(dom, var)
+        if ds is S.Reals:
+            return TruthValue.FALSE
+        if isinstance(ds, sp.Interval) and ds.measure.is_number:
+            d = sp.simplify(ds.measure - p)
+            if d.is_positive is True:
+                return TruthValue.FALSE
+            if d.is_zero is True and not ds.left_open and not ds.right_open:
+                return TruthValue.FALSE
+
+    # Symmetry is a cheap exact disproof on symmetric domains, provided the
+    # domain contains some nonzero point.
+    ds = condition_to_set(dom, var)
+    symmetric = ds is S.Reals or (
+        isinstance(ds, sp.Interval) and sp.simplify(ds.start + ds.end) == 0
+    )
+    if symmetric:
+        try:
+            if sp.simplify(expr.xreplace({var: -var}) - expr) == 0 and expr.has(var):
+                if ds is S.Reals or (isinstance(ds, sp.Interval) and ds.measure != 0):
+                    return TruthValue.FALSE
+        except SYMBOLIC_QUERY_ERRORS:
+            pass
+    return TruthValue.UNKNOWN
+
+
+def _surjectivity_from_range(cond, y, target):
+    rs = condition_to_set(cond, y)
+    if rs is None:
+        return TruthValue.UNKNOWN
+    return exact_set_equal(rs, target)
+
+
+def function_surjective(expr, var, *, domain=True, codomain=S.Reals):
+    vv = normalize_variables(var)
+    if len(vv) > 1:
+        return _multivariate_mapping_truth(
+            expr, vv, mode="surjective", domain=domain, codomain=codomain
+        )
+    expr = sp.sympify(expr)
+    var = vv[0]
+    dom = _combined_domain(expr, var, domain)
+    backend = _semialg_mapping_result(expr, var, dom, codomain=codomain)
+    if backend is not None and backend.surjective is not None:
+        return _truth_from_backend(backend.surjective)
+    y = sp.Dummy("_y", real=True)
+    target = codomain if isinstance(codomain, sp.Set) else condition_to_set(codomain, y)
+    if target is None:
+        return TruthValue.UNKNOWN
+    try:
+        r = function_range(expr, var, y, constraints=dom)
+    except SYMBOLIC_QUERY_ERRORS:
+        return TruthValue.UNKNOWN
+    if isinstance(r, PropertyResult):
+        return normalize_cases(
+            (
+                ConditionalValue(
+                    _surjectivity_from_range(c.value, y, target), c.condition
+                )
+                for c in r.cases
+            ),
+            primary=_surjectivity_from_range(r.primary, y, target)
+            if r.primary is not None
+            else None,
+            source="range-surjectivity-stratification",
+        )
+    return _surjectivity_from_range(r, y, target)
+
+
+def function_bijective(expr, var, *, domain=True, codomain=S.Reals):
+    vv = normalize_variables(var)
+    if len(vv) > 1:
+        return _multivariate_mapping_truth(
+            expr, vv, mode="bijective", domain=domain, codomain=codomain
+        )
+    expr = sp.sympify(expr)
+    var = vv[0]
+    dom = _combined_domain(expr, var, domain)
+    backend = _semialg_mapping_result(expr, var, dom, codomain=codomain)
+    if backend is not None and backend.bijective is not None:
+        return _truth_from_backend(backend.bijective)
+    i = function_injective(expr, var, domain=dom)
+    s = function_surjective(expr, var, domain=dom, codomain=codomain)
+    return combine_truth_results(i, s, op="and", source="bijectivity-stratification")