26-EFT.WP.STG.Lensing v1.0 | Chapter 8 — Multi-Layer Lenses and Algebra (Series / Parallel / Residual / Gated)

Home ／ Docs-Technical WhitePaper ／ 26-EFT.WP.STG.Lensing v1.0

Chapter 8 — Multi-Layer Lenses and Algebra (Series / Parallel / Residual / Gated)

One-sentence goal: Establish an algebra for lens operators that delivers computable, auditable implementations of series, parallel, residual, and gated compositions under parallel spectral–variational forms, with guarantees for stability and traceability.

I. Scope & Objects

1. Inputs
   • Graph & operators: G = (V, E, w); L_* ∈ { L, L^vis, L_ani } (see Chapters 4/5), unit(L_*) = 1.
   • Primitive lenses: K_l = g_l(L_*), l = 1..L; each g_l(λ) designed per Chapters 5/6.
   • Structure spec: struct ∈ { series, parallel, residual, gated }; parallel weights { w_l }, residual weights { β_l }, gating parameters θ_g.
   • Observation or input: x_in (feature or signal), optional reference y (for supervision/calibration).
2. Outputs
   • Composite output: x_out = K_eff x_in or x_out = F_gated(x_in).
   • Algebra metadata: K_eff.kind / params / hash; dual-form gap delta_form_comp.
3. Boundaries & constraints
   unit(x_out) = unit(x_in); weights are dimensionless; if path gating is used, write ( ∫_{gamma(ell)} • d ell ) explicitly with L_gamma.

II. Terms & Variables

• Series (cascade): K_eff^series = Π_{l=1}^L K_l; if L_* is co-diagonalizable, the spectral kernel is g_eff(λ) = ∏_l g_l(λ).
• Parallel (weighted sum): K_eff^parallel = ∑_{l=1}^L w_l K_l, with w_l ≥ 0, ∑ w_l = 1 ⇒ g_eff(λ) = ∑ w_l g_l(λ).
• Residual (skip): K_eff^res = I + ∑_{l=1}^L β_l K_l, β_l ≥ 0; spectral kernel g_eff(λ) = 1 + ∑ β_l g_l(λ).
• Gated (data-dependent): F_gated(x) = G(x; θ_g) • (K_b x) + (I − G(x; θ_g)) • (K_s x), with G(x) = diag( σ( h(x; θ_g) ) ).
• Dual-form gap: delta_form_comp = || x_spec − x_var ||_2.
• Stability radius: ρ(•) is the spectral radius; ||•||_2 the spectral norm.

III. Postulates P718-*

• P718-1 (Parallel dual forms): Every composite lens must output both spectral and variational results, recording delta_form_comp.
• P718-2 (Bounded stability): Require ρ(K_eff) ≤ 1 + ε (default ε = 0.02). For series, enforce layerwise || K_l ||_2 ≤ 1 + ε_l and ∏ (1 + ε_l) ≤ 1 + ε.
• P718-3 (Parallel shape-preserving): Parallel weights are non-negative and sum to 1; maintain unit(x_out) = unit(x_in).
• P718-4 (Non-commutativity logging): If [ K_i, K_j ] ≠ 0, persist the actual execution order and hashes.
• P718-5 (Monotone gating): The gate nonlinearity σ maps to [0, 1] with Lip(σ) ≤ 1; G(x) does not alter dimensions/units.
• P718-6 (Explicit path measure): For path-gated or path-residual designs, declare gamma(ell) and ( ∫_{gamma} • d ell ).

IV. Minimal Equations S718-*

1. S718-1 (Composite kernels — spectral form)
   • Series: x_spec = ( U g_eff(Λ) U^T ) x_in, with g_eff(λ) = ∏_l g_l(λ).
   • Parallel: x_spec = ( U ( ∑_l w_l g_l(Λ) ) U^T ) x_in.
   • Residual: x_spec = ( U ( 1 + ∑_l β_l g_l(Λ) ) U^T ) x_in.
2. S718-2 (Variational equivalences — sum/product to energies)
   • Parallel ↔ additive regularization:
     x_var = argmin_x ( (1/2) || x − x_in ||_2^2 + ∑_l μ_l R_l(x) ),
     quadratic case with R_l(x) = (1/2) x^T L_*^{p_l} x corresponds to g_l(λ) = (1 + μ_l λ^{p_l})^{−1}.
   • Series ↔ cascaded proximals:
     x_var = prox_{μ_L R_L} ∘ … ∘ prox_{μ_1 R_1}( x_in );
     in the quadratic case, this matches spectral series via kernel products.
   • Residual ↔ skip-regularized:
     compute x_var = argmin_x ( (1/2) || x − x_in ||_2^2 + ∑_l μ_l R_l(x) ), then set
     x_out = x_in + ∑_l β_l ( x_in − x_var^{(l)} ) (equivalent in the linear case).
3. S718-3 (Variational expression for gating)
   x_var = argmin_x ( (1/2) || x − x_in ||_2^2 + μ_s || W_s^{1/2} ( x − K_s x_in ) ||_2^2 + μ_b || W_b^{1/2} ( x − K_b x_in ) ||_2^2 ),
   with W_b = G(x_in), W_s = I − G(x_in); first-order linearization around x_in matches spectral gating.
4. S718-4 (Composite stability bounds)
   Series: || K_eff^series ||_2 ≤ ∏_l || K_l ||_2;
   Parallel: || K_eff^parallel ||_2 ≤ ∑_l w_l || K_l ||_2;
   Residual: || K_eff^res ||_2 ≤ 1 + ∑_l β_l || K_l ||_2.
5. S718-5 (Dual-form gap)
   delta_form_comp = || x_spec − x_var ||_2, with delta_form_comp ≤ tol_comp (see contracts).

V. Metrology Pipeline M71-8 (Design → Compose → Solve → Verify → Persist)

1. Design primitives: per Chapters 5/6, choose { g_l }, L_*, and bandwidth/orders; declare RefCond = { λ_max, order_l }.
2. Choose algebraic structure: struct, { w_l }, { β_l }, θ_g (for gating), and whether to enable path terms.
3. Spectral realization: for each g_l, build Chebyshev/Lanczos approximations; implement apply_series / parallel / residual / gated matvec compositions.
4. Variational realization:
   • Parallel: solve ∑ μ_l R_l(x) via CG (quadratic) or PDHG/ADMM (with L1/TV).
   • Series: use cascaded prox or fixed-point “unrolling.”
   • Gated: freeze G(x_in) for one variational step; alternate updates of G and x if needed.
5. Stability & parameter selection: choose { w_l, β_l, μ_l } based on ρ(K_eff), cond(*), and target SNR/PSNR; tune θ_g on a validation set.
6. Checks: compute delta_form_comp, ρ(K_eff), err_spec∞, lat_ms, u_c(x_out); if y exists, evaluate || K_eff x_in − y ||.
7. Persist:
   manifest.lens.compose.* = { struct, L_*.hash, { g_l.hash }, { w_l }, { β_l }, θ_g.hash, ρ, err_spec∞, delta_form_comp, contracts.*, signature }.

VI. Contracts & Assertions C71-8x (suggested thresholds)

• C71-81 (Stability radius): ρ(K_eff) ≤ 1.02; with gating, sup_x ρ( F_gated'(x) ) ≤ 1.05.
• C71-82 (Parallel weights): w_l ≥ 0, ∑ w_l = 1; otherwise refuse execution.
• C71-83 (Residual magnitude): ∑_l β_l || K_l ||_2 ≤ 0.2 (default) to prevent overshoot.
• C71-84 (Dual-form gap): delta_form_comp ≤ 1e−3 || x_in ||_2 (purely quadratic); relax to 3e−3 when L1/gating is present.
• C71-85 (Non-commutativity record): if || K_i K_j − K_j K_i ||_2 / || K_i K_j ||_2 > 1e−3, fix the order and persist order.hash.
• C71-86 (Gating bounds): 0 ≤ G_ii(x) ≤ 1 and Lip(G) ≤ 1; for path gating, provide gamma.hash and L_gamma > 0.
• C71-87 (Unit check): check_dim( x_out − x_in ) = "[same]".

VII. Implementation Bindings I71-8* (interfaces, I/O, invariants)

• compose_lenses_spectral( L_*, { g_l }, struct, { w_l }, { β_l }, θ_g? ) -> { apply, K_eff_meta }, report
• solve_composite_variational( struct, priors, params, x_in[, y] ) -> x_var, report
• measure_stability( K_eff_apply, probes ) -> { rho, norm2 }, diag
• gate_builder( G, θ_spec ) -> G_fn, meta (supports node/edge/path gating; σ optional)
• eval_delta_form( x_spec, x_var ) -> delta_form_comp
• assert_composite_contracts( ds, rules ) -> report
• emit_lens_manifest( results, policy ) -> manifest.lens
  Invariants: λ_max > 0; polynomial order_l ≥ 0; ∑ w_l = 1; if struct = series, the order is immutable; all hash(*) fields are required.

VIII. Cross-References

• Lens kernels & spectral realizations: Chapter 5 of this volume; features & gating sources: Chapter 6.
• Graph operators & kernel approximations: EFT.WP.STG.Dynamics v1.0, Chapter 4; numerical stability: Chapter 9.
• Path/topology priors: EFT.WP.Particle.TopologyAtlas v1.0, Chapters 7/9 (paths and spectral coordinates).
• Runtime publication & dashboard spec: EFT.WP.STG.Dynamics v1.0, Chapter 14.

IX. Quality & Risk Control

1. SLI/SLO: rho_p95, delta_form_comp_p99, err_spec∞_p95, latency_p95, matvec_per_call, overshoot_rate.
2. Fallbacks:
   • If ρ(K_eff) exceeds bounds → shrink { β_l / w_l } or add extra smoothing kernels;
   • If delta_form_comp is high → increase approximation order or unify on the variational form;
   • If gating is unstable → freeze G to a constant or degrade to parallel;
   • If non-commutativity is strong → switch to a parallel structure or reorder and log.
3. Audit: persist sampled g_eff(λ), weight/gate trajectories, ordering & hashes, contract pass rates, outliers, and rollback reasons.

Summary

• Defines a multi-layer lens algebra: series = kernel product, parallel = kernel sum, residual = identity skip, gated = data-dependent mixing.
• Provides equivalences to variational energies / cascaded proximals and stability bounds.
• Achieves traceable, auditable deployment via manifest.lens.compose.* and delta_form_comp.