Cost Real Character Factorization Real Character Candidate Principal On Pos Int

The principal character on positive integers

The declaration realCharacterCandidate_principal_on_pos_int is a theorem in the Recognition Science framework's machine-checked library of formal theorems. It concerns a function called the nontrivial character value, which is a real number extracted from a cost function that satisfies the framework's basic hypotheses. The theorem states that if the cost function's trace at the value 2 is not equal to 2, then for every positive integer n, the nontrivial character value at n is greater than or equal to 1.

This is a statement about a specific candidate for what the framework calls a real character, a function that behaves like a multiplicative homomorphism. The theorem does not claim that this candidate is the unique character, nor that it is the one realized by the actual cost function J(x) = (x + 1/x)/2 - 1. It only establishes a property of this particular candidate under a condition that excludes the special case where the trace at 2 is exactly 2, which corresponds to the principal character that is identically 1 on positive integers.

The theorem is proved in the Lean 4 proof assistant, meaning it is a formal result with no unproven axioms beyond the standard ones. It is part of a larger effort to classify all possible real characters that can arise from the cost function, and this particular result pins down the behavior of the candidate on the positive integers, showing it is bounded below by 1. This is a necessary step toward understanding whether this candidate can be the principal character, which would be identically 1, or whether it is a nontrivial character that takes values greater than 1.

What the theorem does not claim is equally important. It does not assert that the nontrivial character value is exactly 1 for any n, nor does it claim that the candidate is the principal character. It does not say anything about the character's values on negative integers or zero. The condition that the trace at 2 is not equal to 2 is a hypothesis, not a conclusion; the theorem does not show that this condition holds for any particular cost function. It is a conditional statement: if the trace at 2 is not 2, then the candidate is bounded below by 1 on positive integers.

In the broader context of the framework, this theorem is a technical lemma. It is not a headline result like the uniqueness of the cost function or the forcing of three dimensions. Its role is to provide a piece of the classification of real characters, which is a mathematical structure that the framework uses to understand the possible forms of the cost function. The theorem is a precise, narrow statement that contributes to a larger proof, and it is valuable precisely because it is so tightly scoped.

theorem nontrivialCharacterValue_principal_on_nat
    {F : RatioOrbit → RatioOrbit} (hF : SansAnchorHypotheses F)
    (hnontrivial : rationalTrace F 2 ≠ 2) :
    ∀ n : ℕ, 1 ≤ n → 1 ≤ nontrivialCharacterValue F n := by
  intro n hn
  let u := nontrivialCharacterValue F n
  let r := anchorRoot F
  have hu : 0 < u := nontrivialCharacterValue_pos_on_nat hF hnontrivial hn
  have hr : 1 < r := anchorRoot_gt_one hF hnontrivial
  by_contra hprincipal
  have hu1 : u < 1 := lt_of_not_ge hprincipal
  obtain ⟨k, hdecrease⟩ := exists_pow_trace_decrease hu hu1 hr
  have hnpowPos : 0 < n ^ k := pow_pos (by omega) k
  have hnpowOne : 1 ≤ n ^ k := hnpowPos
  have hnatMono :=
    nontrivialCharacterValue_nat_trace_mono hF hnontrivial
      hnpowOne (by omega : n ^ k ≤ 2 * n ^ k)
  have hnq : (n : ℚ) ≠ 0 := by exact_mod_cast (show n ≠ 0 by omega)
  have hpowq : (n : ℚ) ^ k ≠ 0 := pow_ne_zero k hnq
  have hcharPow := nontrivialCharacterValue_pow hF hnontrivial hnq k
  have hcharTwoPow :=
    nontrivialCharacterValue_mul hF hnontrivial
      (by norm_num : (2 : ℚ) ≠ 0) hpowq
  have hcastPow : (((n ^ k : ℕ) : ℚ)) = (n : ℚ) ^ k := by norm_num
  have hcastTwoPow :
      (((2 * n ^ k : ℕ) : ℚ)) = (2 : ℚ) * (n : ℚ) ^ k := by norm_num
  rw [hcastPow, hcastTwoPow, hcharPow, hcharTwoPow,
    nontrivialCharacterValue_two hF hnontrivial, hcharPow] at hnatMono
  change u ^ k + (u ^ k)⁻¹ ≤
    r * u ^ k + (r * u ^ k)⁻¹ at hnatMono
  exact (not_lt_of_ge hnatMono) hdecrease

theorem nontrivialCharacterValue_principal_on_nat
    {F : RatioOrbit → RatioOrbit} (hF : SansAnchorHypotheses F)
    (hnontrivial : rationalTrace F 2 ≠ 2) :
    ∀ n : ℕ, 1 ≤ n → 1 ≤ nontrivialCharacterValue F n := by
  intro n hn
  let u := nontrivialCharacterValue F n
  let r := anchorRoot F
  have hu : 0 < u := nontrivialCharacterValue_pos_on_nat hF hnontrivial hn
  have hr : 1 < r := anchorRoot_gt_one hF hnontrivial
  by_contra hprincipal
  have hu1 : u < 1 := lt_of_not_ge hprincipal
  obtain ⟨k, hdecrease⟩ := exists_pow_trace_decrease hu hu1 hr
  have hnpowPos : 0 < n ^ k := pow_pos (by omega) k
  have hnpowOne : 1 ≤ n ^ k := hnpowPos
  have hnatMono :=
    nontrivialCharacterValue_nat_trace_mono hF hnontrivial
      hnpowOne (by omega : n ^ k ≤ 2 * n ^ k)
  have hnq : (n : ℚ) ≠ 0 := by exact_mod_cast (show n ≠ 0 by omega)
  have hpowq : (n : ℚ) ^ k ≠ 0 := pow_ne_zero k hnq
  have hcharPow := nontrivialCharacterValue_pow hF hnontrivial hnq k
  have hcharTwoPow :=
    nontrivialCharacterValue_mul hF hnontrivial
      (by norm_num : (2 : ℚ) ≠ 0) hpowq
  have hcastPow : (((n ^ k : ℕ) : ℚ)) = (n : ℚ) ^ k := by norm_num
  have hcastTwoPow :
      (((2 * n ^ k : ℕ) : ℚ)) = (2 : ℚ) * (n : ℚ) ^ k := by norm_num
  rw [hcastPow, hcastTwoPow, hcharPow, hcharTwoPow,
    nontrivialCharacterValue_two hF hnontrivial, hcharPow] at hnatMono
  change u ^ k + (u ^ k)⁻¹ ≤
    r * u ^ k + (r * u ^ k)⁻¹ at hnatMono
  exact (not_lt_of_ge hnatMono) hdecrease

What this page does not claim

The theorem does not prove that the nontrivial character value is exactly 1 for any positive integer n. The theorem does not establish that the condition rationalTrace F 2 ≠ 2 actually holds for any particular cost function. The theorem says nothing about the character's values on negative integers or zero.

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: