Cost Real Character Factorization Nontrivial Character Value Nat Trace Mono

A monotone trace

A trace, in the Recognition Science framework, is a real number extracted from a cost function that measures how recognition events combine. The declaration nontrivialCharacterValue_nat_trace_mono proves a monotonicity property: for any cost function satisfying the framework's basic hypotheses, and for any positive integers m and n with m ≤ n, the value of the nontrivial character at m is at most its value at n. In plain language, the character's value never decreases as you move to larger positive integers.

The theorem is proved in the framework's machine-checked library of formal theorems. It relies on the SansAnchor hypotheses, which are the framework's basic assumptions about the cost function: reciprocal symmetry, the composition law, and related conditions, but without requiring the value at 2 to be fixed. The proof builds on earlier results, including the fact that the trace itself is monotone on positive integers (rationalTrace_nat_mono) and that the nontrivial character is positive on those inputs (nontrivialCharacterValue_pos_on_nat). The theorem does not require the anchor condition that the trace at 2 equals 2; it holds in the more general case where the trace at 2 is not 2, which is why the character is called nontrivial.

This monotonicity is not an isolated curiosity. It is a stepping stone in the framework's project of showing that any cost function satisfying the five plain conditions must equal the specific form J(x) = (x + 1/x)/2 - 1. The character values here are intermediate objects that help factor the cost function into simpler pieces. Knowing that the character is monotone on positive integers helps control its behavior and is used in later arguments that pin down the character's form.

What the theorem does not claim is just as important. It does not say that the character is strictly increasing; equality is allowed, so the value could stay flat. It does not apply to all real inputs, only to positive integers. And it does not by itself prove the full uniqueness of the cost function; that requires the entire forcing chain, of which this monotonicity is one component.

theorem rationalTrace_nat_mono
    {F : RatioOrbit → RatioOrbit} (hF : SansAnchorHypotheses F)
    {m n : ℕ} (hm : 1 ≤ m) (hmn : m ≤ n) :
    rationalTrace F m ≤ rationalTrace F n := by
  have hn : 1 ≤ n := le_trans hm hmn
  have hmono := hF.monotone (natOrbit m) (natOrbit n)
    ⟨m, hm, natOrbit_toRat m⟩ ⟨n, hn, natOrbit_toRat n⟩
    (by
      rw [natOrbit_toRat, natOrbit_toRat]
      exact_mod_cast hmn)
  change
    (F (ratioOrbitOfRat (m : ℚ))).toRat ≤
      (F (ratioOrbitOfRat (n : ℚ))).toRat at hmono
  have hmonoR :
      ((F (ratioOrbitOfRat (m : ℚ))).toRat : ℝ) ≤
        ((F (ratioOrbitOfRat (n : ℚ))).toRat : ℝ) := by
    exact_mod_cast hmono
  simp only [rationalTrace, natOrbit, traceDisplay, nativeCostDoubledTrace,
    doubledTraceValue, RatioOrbit.mul_toRat, RatioOrbit.add_toRat,
    two_toRat, RatioOrbit.one_toRat]
  push_cast
  linarith

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 character is strictly increasing on positive integers. The theorem applies to all real inputs, not just positive integers. This monotonicity alone proves the uniqueness of the cost function.

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: