Shunyaya Symbolic Mathematics — Hyperbolic & inverse hyperbolic (2.34)

Abstract
We lift sinh, cosh, coth and their inverses asinh, acosh, acoth to symbolic numerals (m, a) as magnitude maps with alignment carry on their valid domains. We state domains, ranges, monotonicity partitions, growth/asymptotics, and numerical guard policies for large |m|. Under collapse phi(m,a) = m, all formulas reduce to the classical hyperbolic functions.

Definitions (alignment carry on valid domains)

For a symbolic input x = (m, a):

sinh*(m, a)  = ( sinh(m)  , a )           for m in R
cosh*(m, a)  = ( cosh(m)  , a )           for m in R
coth*(m, a)  = ( coth(m)  , a )           for m in R \ {0}

asinh*(m, a) = ( asinh(m) , a )           for m in R
acosh*(m, a) = ( acosh(m) , a )           for m >= 1
acoth*(m, a) = ( acoth(m) , a )           for |m| > 1
  • Alignment is carried unchanged because each is a unary magnitude map.
  • Nonprincipal branches are not used here; declare any alternative branch policy explicitly in the manifest.

Domains, ranges, and monotonicity

sinh

  • Domain: R ; Range: R ; Odd.
  • Monotonicity: strictly increasing on R.

cosh

  • Domain: R ; Range: [1, +inf) ; Even.
  • Monotonicity: strictly decreasing on (-inf, 0], strictly increasing on [0, +inf).
    Order claims should be made branchwise (e.g., on [0, +inf)).

coth

  • Domain: R \ {0} ; Range: (-inf, -1) ∪ (1, +inf) ; Odd.
  • Monotonicity: strictly decreasing on each component (-inf, 0) and (0, +inf).

asinh

  • Domain: R ; Range: R ; Odd.
  • Monotonicity: strictly increasing on R.

acosh

  • Domain: [1, +inf) ; Range: [0, +inf) ; Not odd/even.
  • Monotonicity: strictly increasing on [1, +inf).

acoth

  • Domain: (-inf, -1) ∪ (1, +inf) ; Range: (-inf, 0) ∪ (0, +inf) ; Odd.
  • Monotonicity: strictly decreasing on (1, +inf) and strictly increasing on (-inf, -1) (equivalently, derivative 1/(1 - m^2)).

Endpoint behavior and singularities.

  • cosh(m) >= 1 with cosh(0) = 1.
  • coth(m) -> +inf as m -> 0+ and -> -inf as m -> 0-; coth(m) -> 1 as m -> +inf, -> -1 as m -> -inf.
  • acosh(1) = 0.
  • acoth(m) has no values on [-1, 1].

Collapse and order

Collapse check.

phi( f*(m, a) ) = f(m)     for f in {sinh, cosh, coth, asinh, acosh, acoth}

Order rules (magnitude channel).

  • If f is increasing on domain D (e.g., sinh, asinh, acosh on their domains): (m1,a1) <=_m (m2,a2) ⇒ f*(m1,a1) <=_m f*(m2,a2)
  • If f is decreasing on D (e.g., coth on (0, +inf)), the inequality reverses.
  • For cosh, make order claims branchwise on (-inf,0] or [0,+inf).

When magnitudes tie (e.g., cosh(-m) = cosh(m)), break ties using your declared symbolic preorder (e.g., via S_beta), not by cross-branch inference.

Growth and asymptotics (guides)

As |m| grows:

sinh(m)  ~ (1/2) * sign(m) * exp(|m|)           (odd)
cosh(m)  ~ (1/2) * exp(|m|)                      (even)
coth(m)  = cosh(m)/sinh(m) -> sign(m)            (|m| -> inf)

asinh(m) ~ sign(m) * ( log(2*|m|) )              (odd)
acosh(m) ~ log(2*m)                               for m -> +inf
acoth(m) ~ 1/m + O(1/m^3)                        (odd; small tails)

Alignment a remains bounded and is carried unchanged.

Numerical guard policies (manifest recommendations)

Use stable formulas to avoid overflow/underflow for large |m| and to preserve accuracy near singularities:

  • asinh asinh(m) = log( m + sqrt(m^2 + 1) ) For |m| large, prefer asinh(m) ≈ log(2) + log(|m|) + sign(m)*0 (or use log1p and hypot-style routines).
  • acosh acosh(m) = log( m + sqrt(m - 1) * sqrt(m + 1) ) for m >= 1 For m >> 1, use acosh(m) ≈ log(2*m) to avoid catastrophic cancellation.
  • coth
    Evaluate via coth(m) = 1 / tanh(m) when |m| is moderate; avoid m near 0 (domain excludes 0). If you must regularize for plots, declare a hole or a symmetric cutout around 0.
  • acoth acoth(m) = (1/2) * log( (m + 1) / (m - 1) ) for |m| > 1 Use log1p variants for m close to ±1 from outside to reduce roundoff.
  • cosh, sinh
    Use exp-splitting guards: sinh(m) = 0.5 * (exp(m) - exp(-m)) cosh(m) = 0.5 * (exp(m) + exp(-m)) For large |m|, compute using one-sided exp with scaling to avoid overflow.
  • Alignment handling
    Only clamp a when an algorithm needs atanh(a): a_clamped = clamp(a, -1+eps, +1-eps), eps = 1e-6. Report a unchanged in outputs.

State chosen formulas and thresholds in the reproducibility manifest.

Worked examples

A) sinh on R (increasing).
x1 = (-1.2, +0.3), x2 = (0.7, -0.4)

sinh*(x1) ≈ ( -1.5095 , +0.3 )
sinh*(x2) ≈ (  0.7586 , -0.4 )

Order is preserved: -1.2 < 0.7 ⇒ sinh(-1.2) < sinh(0.7).

B) cosh with branch tie.
y1 = (-2.0, -0.2), y2 = ( 2.0, +0.6 )

cosh*(y1) = ( cosh(2.0) , -0.2 ) ≈ ( 3.7622 , -0.2 )
cosh*(y2) = ( cosh(2.0) , +0.6 ) ≈ ( 3.7622 , +0.6 )

Magnitudes tie; the symbolic preorder (alignment first, then declared tie rule) resolves the tie.

C) acosh domain guard.
z1 = (1.5, 0.8), z2 = (0.8, 0.8)

acosh*(z1) ≈ ( 0.9624 , 0.8 )         # allowed (m >= 1)
acosh*(z2)  =>  domain_guard policy    # m < 1 (undefined by default)

D) acoth near threshold.
w1 = (2.0, +0.1), w2 = (1.05, -0.3)

acoth*(w1)  = ( 0.5 * log(3) , +0.1 )     ≈ ( 0.5493 , +0.1 )
acoth*(w2)  = ( 0.5 * log( (2.05)/(0.05) ) , -0.3 )  ≈ ( 1.6582 , -0.3 )

Both inputs satisfy |m| > 1.

Guards and policy knobs (manifest)

  • Domain guards
    • acosh*: domain_guard = error (default) for m < 1; optionally clamp_to_1 for visualizations.
    • acoth*: domain_guard = error (default) for |m| <= 1; optionally nan.
    • coth*: domain excludes m = 0; no fill-in by default.
  • Precision targets
    Specify absolute/relative tolerances for large |m| (e.g., rtol = 1e-12) and which stabilized formulas are used.
  • Zero policy
    If a result magnitude is exactly zero (e.g., sinh(0)), use the canonical zero (0, +1).

Takeaway

Hyperbolic and inverse hyperbolic functions lift cleanly with alignment carry on their natural domains. Monotonicity gives straightforward order rules (with branchwise care for cosh), asymptotics guide interpretation at large |m|, and stable formulas prevent overflow/roundoff. Under collapse, behavior is exactly classical.

Navigation
Previous → Inverse trigonometric functions (2.33)
Next → Piecewise & indicator family (2.35)

Disclaimer
Observation only. Results reproduce mathematically; domain claims require independent peer review. Defaults: mult_mode = M2, clamp_eps = 1e-6, |a| < 1. All formulas are presented in plain text. Collapse uses phi(m,a) = m.