Foundation Generalized Dalembert

The d'Alembert equation

The d'Alembert functional equation, H(x+y) + H(x-y) = 2 H(x) H(y), first studied by Jean le Rond d'Alembert in the 1740s while modeling vibrating strings, asks for functions where the value at a sum and difference combine in a fixed way. Its continuous solutions are few: the constant 1, a hyperbolic cosine cosh(αx), or a trigonometric cosine cos(αx). This classification, proved by János Aczél and Pl. Kannappan in the 20th century, is a basic result of functional equations.

In Recognition Science, the framework models recognition, a discrete record of events, through a ledger that tracks the cost of comparing two states. A central question is how these costs combine when routes through the ledger are equivalent. The framework's library, a machine-checked collection of formal theorems, proves that if the combining operation is continuous, the d'Alembert classification applies directly. This replaces a stronger, polynomial restriction with a weaker, more natural one: continuity alone suffices.

The module proves the Aczél–Kannappan classification inside the framework, not as an assumption. It shows that a continuous function H with H(0) = 1 satisfying the equation must be one of the three classical forms. The proof proceeds by upgrading continuity to infinite smoothness via an integration-bootstrap construction, then deriving a second-order differential equation H'' = c·H, and finally using uniqueness of solutions in each of the three branches determined by the sign of c.

This result has a concrete payoff. The framework's cost, the price of a recognition event, when expressed on a logarithmic scale, satisfies a bilinear identity: G(t+u) + G(t-u) = 2G(t) + 2G(u) + c·G(t)G(u). The classification forces G to be one of four forms: zero, a parabola αt², cosh(αt) − 1, or 1 − cos(αt). Each form corresponds to a distinct way the ledger can combine costs, and the framework proves that a continuous combiner must be bilinear in this sense.

This is not the final word on the cost function. A counterexample, the quartic log-cost, shows that continuity alone does not automatically yield the second-derivative identity needed for the full classification. The framework therefore keeps the polynomial-degree-≤2 hypothesis as the sharp condition for the main uniqueness theorem, while the continuous version is a broader result for downstream applications.

/-- **Aczél–Kannappan classification** (proved theorem, not axiom):
every continuous solution of the d'Alembert functional equation
`H(x+y) + H(x-y) = 2 H(x) H(y)` with `H(0) = 1` is either the
constant 1, a hyperbolic cosine, or a trigonometric cosine.

The proof reduces to
`IndisputableMonolith.Cost.FunctionalEquation.dAlembert_classification`,
which assembles the integration bootstrap, universal-coefficient ODE
derivation, and ODE uniqueness lemmas into the disjunction. -/
theorem aczel_kannappan_continuous_dAlembert
    (H : ℝ → ℝ) (hCont : Continuous H) (h_one : H 0 = 1)
    (hEq : ∀ x y : ℝ, H (x + y) + H (x - y) = 2 * H x * H y) :
    (∀ x, H x = 1) ∨
    (∃ α : ℝ, ∀ x, H x = Real.cosh (α * x)) ∨
    (∃ α : ℝ, ∀ x, H x = Real.cos (α * x)) :=
  IndisputableMonolith.Cost.FunctionalEquation.dAlembert_classification
    H h_one hCont hEq

/-- Once the log-bilinear identity is known, the affine lift is classified by
the already-discharged H-side Aczél–Kannappan theorem. -/
theorem log_bilinear_affine_lift_classification
    (G : ℝ → ℝ) (c : ℝ)
    (hCont : Continuous G) (hG0 : G 0 = 0)
    (hLog : LogBilinearIdentity G c) :
    (∀ x, 1 + (c / 2) * G x = 1) ∨
    (∃ α : ℝ, ∀ x, 1 + (c / 2) * G x = Real.cosh (α * x)) ∨
    (∃ α : ℝ, ∀ x, 1 + (c / 2) * G x = Real.cos (α * x)) := by
  let H : ℝ → ℝ := fun t => 1 + (c / 2) * G t
  have hH0 : H 0 = 1 := by simp [H, hG0]
  have hHCont : Continuous H := by
    exact continuous_const.add (continuous_const.mul hCont)
  have hHdA : ∀ t u, H (t + u) + H (t - u) = 2 * H t * H u := by
    intro t u
    exact log_bilinear_affine_lift_dAlembert G c hLog t u
  simpa [H] using aczel_kannappan_continuous_dAlembert H hHCont hH0 hHdA

/-- **Continuous-combiner bilinear classification** (hypothesis-package form).

The final bilinear conclusion follows if the explicit analysis package is
provided. It is not automatic from `SatisfiesLawsOfLogicContinuous`; the
quartic log-cost refutes the proposed second-derivative input. -/
theorem continuous_combiner_bilinear_classification
    (C : ComparisonOperator)
    (h : SatisfiesLawsOfLogicContinuous C)
    (hInputs : ContinuousCombinerAnalysisInputs C h) :
    ∃ (P : ℝ → ℝ → ℝ) (c : ℝ),
      (∀ x y : ℝ, 0 < x → 0 < y →
        derivedCost C (x * y) + derivedCost C (x / y)
          = P (derivedCost C x) (derivedCost C y)) ∧
      (∀ u v, P u v = 2*u + 2*v + c*u*v) := by
  have hSmooth := continuous_combiner_log_smoothness_bootstrap C h hInputs.finite_smoothness
  have hLog := continuous_combiner_psi_affine_forcing C h hSmooth
    hInputs.second_derivative hInputs.psi_affine
  exact log_bilinear_positive_cost_bilinear (derivedCost C) hLog

What this page does not claim

The module does not prove that continuity alone forces the bilinear identity without additional analysis inputs. The framework does not claim the d'Alembert equation is the only functional equation governing recognition costs.

Verify this page

Every tagged claim above names its theorem. To check one yourself rather than trust this page, elaborate the source module with Lean 4 and audit its axiom basis:

$ lake env lean IndisputableMonolith/Foundation/GeneralizedDAlembert.lean
expected axiom basis: [propext, Classical.choice, Quot.sound] (the Lean kernel's standard three; no RS-specific axioms)

A page whose claims cannot be reproduced this way does not ship. In production, every anchor links to the exact declaration in the public source release, and this block carries the build receipt for the page itself.

Derived articles

This page is generated by a question-recursion engine: the questions its answers raise become the next pages. The current agenda, with open targets marked red: