Foundation Primitive Recognition Calculus Prime Axis Coherence Weights Aligned

WeightsAligned

In number theory, a completely multiplicative function is one where f(mn) = f(m)f(n) for all positive integers m and n. The Recognition Science framework builds such functions from prime numbers: it assigns a real number, called a weight, to each prime, and then extends that assignment to all integers by multiplying the weights of the prime factors. The definition WeightsAligned in the framework's machine-checked library of formal theorems states that two such weight assignments, a and w, are aligned if there exists a single real number c such that for every prime p, a(p) = c · w(p). In plain terms, the weights of a are all exactly proportional to the weights of w, with the same constant c for every prime.

The importance of this definition comes from a theorem the library proves: a character obeys a single global power law against a reference scale if and only if its prime weights are aligned to that scale. A power law here means there is an exponent c such that the character's value at any integer n equals n raised to the power c. The theorem, named powerLaw_iff_aligned, shows that the seemingly local condition of proportionality on each prime is exactly equivalent to the global condition of a single power law across all integers. This is the mathematical content: independent prime axes, once locked to a common scale, produce one coherent power map.

The library also proves that with the reference weights w(p) = log p, the log-character becomes exactly the real logarithm, and an aligned character with exponent c is exactly the function n ↦ n^c. This is the canonical case. The framework's broader narrative is that a continuity or order condition selects this log scale, and then the alignment condition forces the synchronized power law. But the definition itself, and the equivalence theorem, are purely mathematical statements about real-valued functions on the natural numbers.

In Recognition Science, this is a step in a larger story about how independent degrees of freedom collapse into a single scale. The framework models this as a primitive recognition calculus, where prime axes represent independent coordinates. The theorem shows that the only way to get a global power law is to have all axes aligned. This is a mathematical result, not a physical one; it says nothing about which reference scale to choose, and it does not by itself derive any physical constant. The choice of w(p) = log p as the canonical scale is a separate identification, not a consequence of the alignment definition alone.

What WeightsAligned does not claim is broader than what it does. It does not claim that any particular weight assignment is physically realized, nor that the reference scale w is unique. It does not claim that alignment is forced by the definition; the definition merely states what alignment means. The theorem shows the equivalence with a power law, but it does not show that any character must be aligned. Finally, the framework's own physical bridge, from this formal calculus to actual three-dimensional space, is an open target, not a proved consequence of this declaration.

/-- The prime weights of `a` are aligned to the reference `w` if a single
exponent `c` has `a p = c · w p` on every prime. -/
def WeightsAligned (a w : ℕ → ℝ) : Prop :=
  ∃ c : ℝ, ∀ p : ℕ, p.Prime → a p = c * w p

/-- **Prime-Axis Coherence Theorem.** A character obeys a single global power law
against the reference scale `w` if and only if its prime weights are all aligned
to `w`. The continuum/order condition that forces a global power law is exactly
the condition that synchronizes the independent prime axes into one common scale. -/
theorem powerLaw_iff_aligned (a w : ℕ → ℝ) : IsPowerLaw a w ↔ WeightsAligned a w := by
  constructor
  · rintro ⟨c, hc⟩
    refine ⟨c, ?_⟩
    intro p hp
    have h := hc p hp.ne_zero
    rwa [logChar_prime a hp, logChar_prime w hp] at h
  · rintro ⟨c, hc⟩
    refine ⟨c, ?_⟩
    intro n hn
    unfold logChar
    rw [Finsupp.sum, Finsupp.sum, Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro p hp
    have hpp : p.Prime := by
      rw [Nat.support_factorization] at hp
      exact Nat.prime_of_mem_primeFactors hp
    rw [hc p hpp]
    ring

/-- With the reference weights `w(p) = log p`, the log-character is exactly the
real logarithm. This is the scale that the order/continuum condition selects. -/
theorem logChar_log (n : ℕ) (hn : n ≠ 0) :
    logChar (fun p => Real.log p) n = Real.log n := by
  unfold logChar
  rw [Finsupp.sum]
  have hself : n.factorization.prod (fun p k => p ^ k) = n :=
    Nat.factorization_prod_pow_eq_self hn
  have hcast : (n : ℝ) = ∏ p ∈ n.factorization.support, ((p : ℝ) ^ (n.factorization p)) := by
    conv_lhs => rw [← hself, Finsupp.prod]
    push_cast
    rfl
  rw [hcast, Real.log_prod]
  · apply Finset.sum_congr rfl
    intro p hp
    rw [Real.log_pow]
  · intro p hp
    have hpp : p.Prime := by
      rw [Nat.support_factorization] at hp
      exact Nat.prime_of_mem_primeFactors hp
    have : (0 : ℝ) < (p : ℝ) ^ (n.factorization p) := by
      apply pow_pos
      exact_mod_cast hpp.pos
    exact ne_of_gt this

/-- **The synchronized character is a power map.** Under the log reference scale,
an aligned character with exponent `c` is exactly `n ↦ n^c`. The independent
prime axes, once locked to one scale, produce a single global power law on the
positive rationals. -/
theorem character_is_rpow {a : ℕ → ℝ} {c : ℝ}
    (haligned : ∀ p : ℕ, p.Prime → a p = c * Real.log p)
    (n : ℕ) (hn : n ≠ 0) :
    Real.exp (logChar a n) = (n : ℝ) ^ c := by
  have hpl : logChar a n = c * Real.log n := by
    have hdirect : logChar a n = c * logChar (fun p => Real.log p) n := by
      unfold logChar
      rw [Finsupp.sum, Finsupp.sum, Finset.mul_sum]
      apply Finset.sum_congr rfl
      intro p hp
      have hpp : p.Prime := by
        rw [Nat.support_factorization] at hp
        exact Nat.prime_of_mem_primeFactors hp
      rw [haligned p hpp]; ring
    rw [hdirect, logChar_log n hn]
  rw [hpl]
  have hnpos : (0 : ℝ) < n := by exact_mod_cast Nat.pos_of_ne_zero hn
  rw [Real.rpow_def_of_pos hnpos]
  congr 1
  ring

What this page does not claim

WeightsAligned does not claim that any particular weight assignment is physically realized. The definition does not claim that alignment is forced; it only states what alignment means. The framework's physical bridge from this calculus to three-dimensional space is an open target, not a proved consequence.

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: