Cost Ndim Projector Fapply Metallic Apply

The metallic family

In linear algebra, a projector is an operator that, when applied twice, gives the same result as applying it once: it flattens vectors onto a subspace and then leaves them alone. From any such projector P, one can form a reflection-like operator F = 2P - I, which sends each vector to its mirror image across that subspace. The Recognition Science framework's machine-checked library of formal theorems packages this construction in a finite-dimensional setting, starting from a covector β and an inverse metric kernel hInv, and derives the algebraic consequences.

The declaration FApply_MetallicApply is one of those consequences. It states a commutation rule: when the reflection operator F is applied to the output of a metallic operator M, the result equals a specific linear combination of F applied to the original vector and the vector itself. The metallic operator is defined as M(v) = (p/2)v + (√(p²+4q)/2)F(v), where p and q are real parameters. The theorem proves that F(M(v)) = (p/2)F(v) + (√(p²+4q)/2)v. This is not a numerical coincidence; it is a proved identity in the library, derived from the definitions of the operators and the fact that F is its own inverse (F(F(v)) = v) when the scalar mu is nonzero.

The classical background here is the theory of quadratic equations and their associated number systems. The golden ratio φ satisfies φ² = φ + 1, and the metallic means generalize this: for integers p and q, the positive root of x² = px + q is called a metallic mean. The framework's construction reproduces this algebra at the level of operators. The golden operator G is the special case with p = 1, q = 1, and the theorem FApply_GApply is the corresponding commutation rule for that case. The metallic family extends the same pattern to all p and q, subject to the condition that p² + 4q is nonnegative so the square root is real.

What the declaration does not claim is just as important as what it proves. It does not assert that any particular metallic mean is physically realized or that the parameters p and q have empirical meaning. The theorem is a statement about the algebra of operators defined in the framework; it says nothing about measurements, particles, or the fine-structure constant. It also does not claim that the metallic operator itself satisfies a quadratic law; that is a separate theorem, MetallicApply_square, which requires the additional condition that p² + 4q ≥ 0. The commutation rule holds under the single condition that mu is nonzero, which ensures the projector is well-defined.

In Recognition Science, this operator algebra is part of the machinery that connects the cost function to dimensional structure. The framework models recognition events as discrete records in a ledger, and the cost of recognition is forced to take a specific form. From that cost function, the framework derives the golden ratio as the unique self-similar scaling, and from there an eight-tick cycle and three spatial dimensions. The projector and metallic operators are the linear-algebraic tools that carry this structure in finite-dimensional spaces. The FApply_MetallicApply theorem is a small but load-bearing piece: it shows that the reflection operator interacts cleanly with the entire metallic family, not just with the golden case, which keeps the algebraic edifice consistent as the framework extends from one dimension to many.

theorem FApply_MetallicApply {n : ℕ}
    (p q lam : ℝ) (hInv : Fin n → Fin n → ℝ) (β : Vec n)
    (hμ : mu lam hInv β ≠ 0) (v : Vec n) :
    FApply lam hInv β (MetallicApply p q lam hInv β v)
      = (p / 2) • FApply lam hInv β v
        + (Real.sqrt (p ^ 2 + 4 * q) / 2) • v := by
  unfold MetallicApply
  rw [FApply_add, FApply_smul, FApply_smul, FApply_square _ _ _ hμ]

/-- The metallic family derived from the same almost-product operator. -/
noncomputable def MetallicApply {n : ℕ}
    (p q lam : ℝ) (hInv : Fin n → Fin n → ℝ) (β : Vec n) : Vec n → Vec n :=
  fun v => (p / 2) • v + (Real.sqrt (p ^ 2 + 4 * q) / 2) • FApply lam hInv β v

/-- The induced golden operator. -/
noncomputable def GApply {n : ℕ}
    (lam : ℝ) (hInv : Fin n → Fin n → ℝ) (β : Vec n) : Vec n → Vec n :=
  fun v => ((1 : ℝ) / 2) • v + (Real.sqrt 5 / 2) • FApply lam hInv β v

theorem FApply_GApply {n : ℕ}
    (lam : ℝ) (hInv : Fin n → Fin n → ℝ) (β : Vec n)
    (hμ : mu lam hInv β ≠ 0) (v : Vec n) :
    FApply lam hInv β (GApply lam hInv β v)
      = ((1 : ℝ) / 2) • FApply lam hInv β v + (Real.sqrt 5 / 2) • v := by
  unfold GApply
  rw [FApply_add, FApply_smul, FApply_smul, FApply_square _ _ _ hμ]

What this page does not claim

The theorem does not assert that any metallic mean is physically realized. The parameters p and q have no empirical meaning in this declaration. The commutation rule does not by itself imply the metallic operator satisfies a quadratic law.

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/Cost/Ndim/Projector.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: