Foundation Primitive Recognition Calculus Prime Axis Coherence Log Char Prime

The log-character at a prime

A log-character, in the Recognition Science framework, is a function that assigns a real number to every positive integer by adding up contributions from its prime factors. The framework models a discrete record of events, its ledger, as such an assignment. For any choice of weights on the primes, the log-character of a number is the sum of those weights, each multiplied by how many times its prime appears in the factorization. The declaration logChar_prime proves a simple fact about this construction: at a prime number, the log-character equals exactly the weight assigned to that prime. In symbols, if p is prime and a is any weight function, then logChar a p = a p.

This is not a deep result, but it is a load-bearing one. The theorem is part of a larger argument in the framework's machine-checked library of formal theorems, where the goal is to show how independent prime axes can synchronize into a single scale. The fact that a log-character reads back its weight at a prime means the prime weights are genuine coordinates: no information is lost when passing from weights to the character. A companion theorem, faithful, states that two log-characters agreeing on all positive integers must agree on every prime weight. Together they establish that the prime axes are independent, with no relation forced among them before additional coherence conditions enter.

The theorem does not claim that any particular weight function is used, nor that the primes are aligned to a common scale. It merely states the definitional behavior of the construction at primes. The framework's later results, such as the Prime-Axis Coherence Theorem, add the condition under which a global power law emerges: the weights must be aligned to a reference scale. With the canonical reference scale w(p) = log p, the log-character becomes exactly the real logarithm, and an aligned character becomes a power map n ↦ n^c. But logChar_prime itself says nothing about alignment, power laws, or the logarithm; it is a lemma about the basic definition.

What this means for a reader is that the framework's account of prime axes starts with a clean, verifiable foundation: each prime contributes independently to the ledger, and the character reads those contributions back without distortion. The theorem is a small but necessary step in showing that the framework's structure is not arbitrary, and that any later synchronization is an added constraint, not a hidden assumption. The independence of the prime axes is what makes the later coherence theorem meaningful, because it shows that a global power law is a real restriction on the weights, not a tautology.

/-- A log-character reads back exactly its weight at a prime. -/
theorem logChar_prime (a : ℕ → ℝ) {p : ℕ} (hp : p.Prime) : logChar a p = a p := by
  unfold logChar
  rw [hp.factorization]
  rw [Finsupp.sum_single_index (by simp)]
  simp

/-- **Independence of the axes.** Two log-characters that agree on all naturals
agree on every prime weight. The prime weights are genuine independent
coordinates of the character. -/
theorem faithful {a b : ℕ → ℝ} (h : ∀ n, logChar a n = logChar b n)
    {p : ℕ} (hp : p.Prime) : a p = b p := by
  have := h p
  rwa [logChar_prime a hp, logChar_prime b hp] at this

/-- **Phase 5 headline.** Freedom then collapse, in one statement. Independent
prime weights always define a multiplicative character (`logChar_mul`), distinct
weights give distinct characters (`faithful`), and a global power law against any
fixed reference scale holds iff the prime weights are aligned to it
(`powerLaw_iff_aligned`). Coherence is the synchronization of independent prime
axes into one scale. -/
theorem prime_axis_coherence :
    (∀ (a : ℕ → ℝ) (m n : ℕ), m ≠ 0 → n ≠ 0 →
        logChar a (m * n) = logChar a m + logChar a n)
      ∧ (∀ (a b : ℕ → ℝ), (∀ n, logChar a n = logChar b n) →
          ∀ (p : ℕ), p.Prime → a p = b p)
      ∧ (∀ a w : ℕ → ℝ, IsPowerLaw a w ↔ WeightsAligned a w) := by
  refine ⟨?_, ?_, ?_⟩
  · intro a m n hm hn; exact logChar_mul a hm hn
  · intro a b h p hp; exact faithful h hp
  · exact powerLaw_iff_aligned

What this page does not claim

The theorem does not claim that any particular weight function is used or that the primes are aligned to a common scale. The theorem does not claim that a global power law holds for all characters. The theorem does not claim that the framework derives the fine-structure constant or any specific physical constant.

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/PrimitiveRecognitionCalculus/PrimeAxisCoherence.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: