Cost Real Character Factorization Sans Anchor Real Character Factorization Targe

What the target proves

In mathematics, a character is a function that turns multiplication into multiplication: the value at a product equals the product of the values. The classical example is the sign function, which sends positive numbers to 1 and negative numbers to -1. The Recognition Science declaration SansAnchorRealCharacterFactorizationTarget_proved establishes, in the framework's machine-checked library of formal theorems, that a broad class of cost functions must admit such a factorization into a real-valued character.

The setting is the framework's ledger, a discrete record of recognition events, where each event carries a cost, a number measuring the price of recognizing one ratio from another. The theorem assumes only a stripped-down version of the framework's composition law, called the reciprocal composition law (RCL), which relates the cost of a product and a quotient to the costs of the factors. The theorem drops the usual anchor at the value two, meaning it does not assume any particular cost at the ratio 2. From the RCL alone, the proof derives a doubled-trace identity: the sum of the doubled costs at a product and a quotient equals the product of the doubled costs at the factors. This identity is exactly the multiplicative property that defines a character, so the theorem shows the cost structure must factor through such a character.

The proof works by first establishing the doubled-trace identity for rational ratios, then lifting it to the full real-valued setting. The key step is a linear extraction formula that recovers the character's value at any rational from the trace values, using a root derived from the trace at 2. The theorem shows this extraction is well-defined and that the resulting character is positive and at least 1 on positive integers, matching the sign character's behavior on the positive ray. The framework's library verifies the entire argument in a machine-checked formal system, so the result holds without hidden assumptions beyond the stated ones.

What the theorem does not claim is equally important. It does not assert that the character is unique, nor that it must be the sign character. It does not derive the full cost function J(x) = (x + 1/x)/2 - 1; that requires additional anchoring conditions. It also does not claim that the RCL alone forces a specific numerical value for the cost at any ratio. The theorem only establishes the structural factorization, leaving the specific character as a free parameter subject to further constraints.

/-- The doubled-trace form of the composition law needs only the RCL. The anchor
at two is not used. -/
theorem doubledTrace_dAlembert_of_rcl
    {F : RatioOrbit → RatioOrbit}
    (hrcl : ∀ {x y : RatioOrbit}, x.toRat ≠ 0 → y.toRat ≠ 0 →
      RatioOrbit.crossEq
        (RatioOrbit.add (F (RatioOrbit.mul x y)) (F (div x y)))
        (RatioOrbit.add
          (RatioOrbit.add
            (RatioOrbit.mul two (RatioOrbit.mul (F x) (F y)))
            (RatioOrbit.mul two (F x)))
          (RatioOrbit.mul two (F y))))
    {x y : RatioOrbit} (hx : x.toRat ≠ 0) (hy : y.toRat ≠ 0) :
    RatioOrbit.crossEq
      (RatioOrbit.add (nativeCostDoubledTrace F (RatioOrbit.mul x y))
        (nativeCostDoubledTrace F (div x y)))
      (RatioOrbit.mul (nativeCostDoubledTrace F x) (nativeCostDoubledTrace F y)) := by
  have h := hrcl hx hy
  rw [RatioOrbit.crossEq_iff_toRat_eq] at h ⊢
  simp only [nativeCostDoubledTrace, doubledTraceValue, RatioOrbit.mul_toRat,
    RatioOrbit.add_toRat, two_toRat, RatioOrbit.one_toRat] at h ⊢
  linarith

theorem doubledTrace_dAlembert_of_sansAnchor
    {F : RatioOrbit → RatioOrbit}
    (hF : SansAnchorHypotheses F)
    {x y : RatioOrbit} (hx : x.toRat ≠ 0) (hy : y.toRat ≠ 0) :
    RatioOrbit.crossEq
      (RatioOrbit.add (nativeCostDoubledTrace F (RatioOrbit.mul x y))
        (nativeCostDoubledTrace F (div x y)))
      (RatioOrbit.mul (nativeCostDoubledTrace F x) (nativeCostDoubledTrace F y)) :=
  doubledTrace_dAlembert_of_rcl hF.base_sans_two.canonical_rcl hx hy

theorem nontrivialCharacterValue_pos_on_nat
    {F : RatioOrbit → RatioOrbit} (hF : SansAnchorHypotheses F)
    (hnontrivial : rationalTrace F 2 ≠ 2)
    {n : ℕ} (hn : 1 ≤ n) :
    0 < nontrivialCharacterValue F n := by
  have hnq : (n : ℚ) ≠ 0 := by exact_mod_cast (show n ≠ 0 by omega)
  have hne := nontrivialCharacterValue_nonzero hF hnontrivial hnq
  have htrace := nontrivialCharacterValue_trace hF hnontrivial hnq
  have hge := rationalTrace_nat_ge_two hF hn
  by_contra hpos
  have hle : nontrivialCharacterValue F n ≤ 0 := le_of_not_gt hpos
  have hneg : nontrivialCharacterValue F n < 0 :=
    lt_of_le_of_ne hle hne
  have hinvneg : (nontrivialCharacterValue F n)⁻¹ < 0 :=
    inv_lt_zero.mpr hneg
  linarith

What this page does not claim

The theorem does not claim the character is unique or that it must be the sign character. It does not derive the full cost function J(x) = (x + 1/x)/2 - 1. It does not claim the RCL alone forces any specific numerical cost value.

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/RealCharacterFactorization.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: