Shunyaya Symbolic Mathematics — Multivariate lifts & aggregators (2.44)

Abstract
We lift multi-argument functions f: R^k -> R to symbolic tuples x_i = (m_i, a_i) by acting on the magnitudes and aggregating alignments with a rapidity-weighted mean. The default weights reflect local sensitivity (|∂f/∂m_i|) modulated by scale (|m_i|^gamma). This preserves collapse, behaves well under monotone maps, and yields reproducible summaries for means, products, and norms.

Definition (k-ary lift with alignment aggregation)

Let x = ( (m_1, a_1), …, (m_k, a_k) ), and define

f*( x ) = ( f(m_1,…,m_k) , a' )

with the default alignment aggregator

u_i  = atanh( clamp(a_i, -1+eps, +1-eps) ),  eps = 1e-6
w_i  = |∂f/∂m_i|(m_1,…,m_k) * |m_i|^gamma            # gamma >= 0 (default 1)
a'   = tanh(  (Σ_i w_i * u_i) / (Σ_i w_i)  )         # if Σ w_i > 0
Fallback if Σ w_i = 0: a' = tanh( mean(u_i) )        # or a' = +1 (declare)
  • Collapse check. phi( f*(x) ) = f(m_1,…,m_k).
  • Weights. The gradient factor emphasizes inputs that most affect f; |m_i|^gamma adds scale sensitivity (default gamma = 1). Set gamma = 0 for pure sensitivity weights.
  • Guards. Evaluate ∂f/∂m_i on the magnitude domain where it exists; if not differentiable, use a subgradient magnitude or a problem-specific proxy weight.

Domains and examples of f

  • Arithmetic mean: f = (Σ m_i)/k (domain R^k). Here |∂f/∂m_i| = 1/k, so w_i ∝ |m_i|^gamma.
  • Geometric mean: f = (∏ m_i)^{1/k} with domain m_i > 0. Here |∂f/∂m_i| = (1/k) * f / m_i, giving w_i ∝ f * |m_i|^{gamma-1} (equal weights when gamma = 1).
  • p-norm (p ≥ 1): f = (Σ |m_i|^p)^{1/p} (domain R^k). Then |∂f/∂m_i| = |m_i|^{p-1} / f^{p-1} for m_i ≠ 0, so w_i ∝ |m_i|^{p-1+gamma} (the common f factor cancels).

Zero/flat directions. If all |∂f/∂m_i| = 0 at a point (e.g., f locally flat), use the fallback rule.

Ordering and monotonicity notes

  • If f is increasing in coordinate i on a domain D, then increasing m_i (with others fixed) increases phi( f*(x) ). The alignment a' may shift toward a_i when w_i grows, reflecting the increased influence of that coordinate.
  • For symmetric aggregators (means, norms), permutation of inputs leaves the magnitude unchanged and leaves a' unchanged when the weights are symmetric (e.g., equal after evaluation).
  • Branchwise monotonicity. If f changes monotonicity across regions (e.g., involves absolute values), make order claims within each region where f is monotone.

Stability semantics

  • Consensus vs conflict. If alignments point in opposite directions (e.g., some Nearo, some Pearo), a' reports the weighted compromise. Large |m_i| or high sensitivity |∂f/∂m_i| can dominate.
  • Robustness. Using rapidity (atanh) guarantees |a'| < 1 and makes the aggregator associative under regrouping when weights are recomputed at the final m (record policy below).

Worked examples

A) Arithmetic mean (k = 3, gamma = 1).
m = (1, 4, 5), a = (0.3, 0.9, -0.2).
Magnitude:

f = (1 + 4 + 5)/3 = 10/3 ≈ 3.3333

Weights w_i ∝ |m_i|: (1, 4, 5); rapidities u ≈ (0.3095, 1.4722, -0.2027).
Alignment:

u' = (1*0.3095 + 4*1.4722 + 5*(-0.2027)) / (1+4+5) ≈ 0.518
a' = tanh(0.518) ≈ 0.477
Result: f*(x) ≈ ( 3.3333 , 0.477 )

B) Geometric mean (domain m_i > 0, gamma = 1).
m = (2, 8), a = (0.5, 0.1).
Magnitude: f = (2*8)^{1/2} = 4. With gamma = 1, weights equal ⇒ average rapidity.
u = (atanh(0.5), atanh(0.1)) ≈ (0.5493, 0.1003)
u' = (0.5493 + 0.1003)/2 = 0.3248 → a' ≈ 0.314.
Result: ( 4 , 0.314 ).

C) Euclidean norm (p = 2, gamma = 1).
m = (-3, 4), a = (0.6, 0.2).
Magnitude: f = sqrt(9 + 16) = 5. Weights w_i ∝ |m_i|^{p-1+gamma} = |m_i|^2 ⇒ (9, 16).
u ≈ (0.6931, 0.2027) →
u' = (9*0.6931 + 16*0.2027) / 25 ≈ 0.379 → a' ≈ 0.362.
Result: ( 5 , 0.362 ).

Policy and reproducibility (manifest)

aggregator = f_name           # "mean", "geomean", "pnorm", "custom"
weights.w_i = |∂f/∂m_i| * |m_i|^gamma
gamma = 1                     # 0 for pure sensitivity, tune per use
weights.normalize = "divide_by_sum"       # to form a convex average
fallback_when_sum_w_zero = "mean_u" | "+1"
align_internal_space = "rapidity"         # use atanh/tanh
recompute_weights = "final_m"             # or "per_stage" in staged pipelines
domain_guards = { geomean: "m_i>0", pnorm: "p>=1" }
zero_policy = "canonical_zero"            # (0,+1) for exact zeros in magnitude

Optional alternatives:

  • Uniform weights: w_i = 1 (simple average of rapidities).
  • Application weights: e.g., costs/sensitivities supplied externally; then w_i = c_i * |∂f/∂m_i|.

Notes on continuity and limits

  • If f is continuous and w_i are continuous where defined, then f* is continuous in (m, u) under product metrics.
  • If f is differentiable and weights use |∂f/∂m_i|, a' varies smoothly except at kinks of f (record any subgradient convention).

Takeaway

Multivariate lifts apply f to magnitudes and combine alignments by a rapidity-weighted mean tuned by local sensitivity and scale. This captures which inputs truly drive f, is stable and bounded, and reduces to the classical f under collapse.

Navigation
Previous → Logistic/sigmoid, softplus, softsign (2.43)
Next → Implicit & inverse functions (2.45)

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.