03-EFT.WP.Core.Parameters v1.0 | Chapter 3 — Boundaries, Constraints, and Transforms

Home ／ Docs-Technical WhitePaper ／ 03-EFT.WP.Core.Parameters v1.0

Chapter 3 — Boundaries, Constraints, and Transforms

I. Aims and Scope

• Establish unified conventions for parameter bounds lb/ub, constraints C_eq / C_ineq, and transforms T_map, ensuring feasibility, identifiability, and numerical stability of the parameter set Theta.
• All parameter names, set names, and formulas use English in plain text; inline symbols are wrapped in backticks.
• Output anchors in this chapter: postulates P33-*, workflow Mx-1, implementation use cases I30 2 and I30 4. Cross-volume citations: Core.Equations S20-*, S40-*, etc.

II. Objects and Notation

• Parameters and domain: theta = (theta_1, ..., theta_p), Theta is the parameter domain; D_valid is the valid set, D_forbid is the forbidden set.
• Bounds: lb = (lb_1, ..., lb_p), ub = (ub_1, ..., ub_p), with lb_i = -inf or ub_i = +inf made explicit as appropriate.
• Constraints: C_eq(theta) = 0, C_ineq(theta) ≤ 0; feasible set Theta = { theta | C_eq = 0, C_ineq ≤ 0, lb ≤ theta ≤ ub }.
• Transforms: phi = T_map(theta), componentwise phi_i = T_i(theta_i); available families include identity, log, logit, softplus, zscore(x; mu, sigma).
• Derivatives and information: J = ∂f/∂theta, H = ∂^2 f/∂theta^2, Fisher(theta).

III. Bound Declaration Standards

• P33-1 Uniqueness: every theta_i must explicitly declare bounds lb_i ≤ theta_i ≤ ub_i or declare unboundedness with justification (e.g., symmetric prior, scale uncertainty).
• P33-2 Closure: open/closed intervals must be written consistently, e.g., theta_i ∈ (0, +inf); do not replace formal bounds with mixed semantics.
• P33-3 Inheritance: for derived parameters theta_j def= g(theta_k), derive bounds from the image of g and declare them explicitly.
• P33-4 Dimensional closure: units of lb/ub must match those of theta_i; bare constants are forbidden. Call check_dim(expr:str) when needed.

IV. Constraint Expressions and Feasible Set

1. Constraint mother form: Theta = { theta | C_eq(theta) = 0, C_ineq(theta) ≤ 0, lb ≤ theta ≤ ub }.
2. Constraint priority:
   • C_eq (hard constraints)
   • lb/ub (hard bounds)
   • C_ineq (hard or soft; for soft constraints, specify penalty/barrier parameters)
3. Composite constraint patterns:
   • Linear equality: A theta - b = 0
   • Linear inequality: G theta - h ≤ 0
   • Nonlinear: g(theta) = 0 or g(theta) ≤ 0, with availability of ∂g/∂theta stated
4. Sharing and coupling: write sharing explicitly as theta_a = theta_b or theta_a def= r * theta_b (with r given or included in theta).

V. Transform Library and Properties

1. identity: phi = theta, domain/range isomorphic; invertibility is trivial.
2. log (positive domain): phi = log(theta - lb), domain (lb, +inf), inverse theta = lb + exp(phi), d theta/d phi = exp(phi).
3. logit (bounded interval): let s = (theta - lb)/(ub - lb), phi = log(s / (1 - s)); inverse theta = lb + (ub - lb) * (1 / (1 + exp(-phi))), d theta/d phi = (ub - lb) * σ(phi) * (1 - σ(phi)), where σ(•) is the logistic.
4. softplus (unbounded to positive): phi = log(exp(theta) + 1); commonly used for nonnegative quantities with ub = +inf, lb = 0, inverse theta = log(exp(phi) - 1).
5. zscore (standardization): phi = (theta - mu)/sigma, inverse theta = mu + sigma * phi; used for numerical scale normalization.
6. Selection guidance:
   • Only lower bound (e.g., scale/rate): prefer log(theta - lb)
   • Known lower and upper bounds: prefer interval mapping logit
   • Need smoothness near zero but allow zero: use softplus with offset theta = softplus(raw) + lb

VI. Impact of Transforms on Priors and Likelihood

1. One-dimensional density transform: if phi = T(theta) is invertible, then
   p_phi(phi) = p_theta(theta(phi)) * | d theta / d phi |。
2. Multivariate Jacobian:
   p_phi(phi) = p_theta(theta(phi)) * | det( ∂theta / ∂phi ) |。
3. Interval prior mapping: for a uniform prior on theta ∈ (lb, ub), under logit
   p_phi(phi) = Uniform(0,1)(σ(phi)) * (ub - lb) * σ(phi)*(1-σ(phi))，where Uniform(0,1)(•) denotes the interval-density indicator。
4. Recommended practices:
   • When implementing set_prior and set_transform, inject Jacobian corrections automatically to avoid missing factors.
   • Log-posterior writing:
     log post(phi | data) = log L(data | theta(phi)) + log prior_theta(theta(phi)) + log | det( ∂theta / ∂phi ) | - log Z。

VII. Chain Rule and Sensitivities

• First-order chain rule: ∂f/∂phi = (∂f/∂theta) * (∂theta/∂phi)。
• Second-order chain rule (directional form):
  H_phi = J^T H_theta J + Σ_i (∂f/∂theta_i) * (∂^2 theta_i / ∂phi ∂phi^T)，with J = ∂theta/∂phi。
• Fisher under transform: F_phi = J^T F_theta J (common approximation ignoring second-order terms)。

VIII. Path-Explicit Parameters for Arrival Time

1. For any parameter related to T_arr (e.g., c_ref, hyper-parameters of n_eff), derivations and calibration must use the fully parenthesized form with explicit path and measure:
   • Constant-factored: T_arr = ( 1 / c_ref ) * ( ∫ n_eff d ell )
   • General form: T_arr = ( ∫ ( n_eff / c_ref ) d ell )
2. Path notation: declare gamma(ell) and d ell, and provide L_gamma = ∫_gamma 1 d ell; it is forbidden to write ∫ n d ell / c or omit parentheses (these are rejected by validate_equation).

IX. Feasibility Check Workflow (Mx-1)

• Collect candidate parameter set theta_free, import bounds lb/ub and constraints C_eq / C_ineq.
• Choose and register transforms T_map; validate availability of phi = T_map(theta) and its inverse theta = T_map^{-1}(phi).
• Build the feasible set Theta, run validate_param_set(codes) and semantic checks for add_constraint.
• For samples or initial values, execute proj_Theta(theta_0); if constraints are violated, return the minimal correction or diagnosable information.
• Generate Jacobians required for calibration/inference and the images of bounds in transform space: lb_phi/ub_phi = T_map(lb/ub).
• Output the check report: boundary coverage, constraint residuals, transform numerical stability (overflow/underflow statistics).

X. Implementation Binding Use Cases (I30 2 / I30 4)

1. Bounds and constraints (I30 2):
   • set_bounds(code="n_eff.alpha", lb=0.0, ub=+inf)
   • add_constraint(code="n_eff.alpha", kind="ineq", expr="theta - 1.0 ≤ 0")
   • validate_param_set(codes=["n_eff.alpha","c_ref"]) -> true
2. Transform and invertibility (I30 4):
   • set_transform(code="n_eff.alpha", name="log", args={"lb":0.0})
   • forward_transform(code="n_eff.alpha", x=1.2) -> phi
   • inverse_transform(code="n_eff.alpha", y=phi) -> 1.2

XI. Bound–Transform Construction Templates

• Only lower bound lb:
  Canonical: phi = log(theta - lb)；Inverse: theta = lb + exp(phi)；Initialization: phi_0 = log(max(theta_0 - lb, eps))
• Both bounds (lb, ub):
  Canonical: phi = log( (theta - lb) / (ub - theta) )；Inverse: theta = lb + (ub - lb) * σ(phi)
• Unbounded but standardize:
  Canonical: phi = (theta - mu)/sigma；Inverse: theta = mu + sigma * phi

XII. Misuse and Conflict List

• Do not mix T_fil (tension) with T_trans (transmission coefficient).
• Never interchange n and n_eff.
• Never write ∫ n d ell / c or an integral without parentheses; always use ( ∫ ( n_eff / c_ref ) d ell ) or ( 1 / c_ref ) * ( ∫ n_eff d ell ).
• Inconsistent transform domain: if theta_i ∈ (0,1), do not use log; use logit.
• Ignoring Jacobian corrections: after transforms, MAP/MCMC must include |det(∂theta/∂phi)|.

XIII. Cross-Volume Binding and Examples

• Binding to Core.Equations Chapter 2 (S20- Arrival Time):* hyper-parameters of c_ref and n_eff enter propagate_time(n_eff_path, ds, c_ref) after T_map transforms; consistency metrics include T_arr.
• Binding to Core.Equations Chapter 4 (S40- Tension Field):* if n_eff def= F_map(T_fil, ...), then the bounds and transforms of F_map parameters follow this chapter’s rules and maintain dimensional closure in weak forms and discretizations.

XIV. Output Anchors and Reuse

• Postulates: P33-1…P33-4 (uniqueness of bounds, closure, inheritance, dimensional closure).
• Workflow: Mx-1 (feasibility check).
• Implementation: I30 2, I30 4 (interface use cases).
• These anchors can be cited directly in parameter entries, inference scripts, and regression baselines.