Cost Ndim Neutrality Aggregate Eq One Iff

The neutrality test

In the Recognition Science framework, a ledger (a discrete record of events) assigns to each entry a positive weight and a positive value. The framework's cost (a measure of how far the record departs from perfect balance) is built from these weights and values. The theorem aggregate_eq_one_iff gives a clean test for when that cost is zero: the aggregate equals one exactly when the weighted sum of logarithms of the values is zero.

Written symbolically, for any dimension n, weights α, and values x, the statement is: aggregate α x = 1 if and only if dot α (logVec x) = 0. Here logVec applies the natural logarithm to each value, and dot is the weighted sum. The proof is short: it rewrites the aggregate as the exponential of the weighted log sum, then uses the fact that the exponential function is injective. So the condition "aggregate equals one" is exactly the condition that the weighted log sum vanishes.

The same file proves two equivalent forms. Zero cost is equivalent to the weighted log sum being zero, and zero cost is equivalent to the aggregate being one. Chained together, the three statements say the same thing from three angles: balance in the ledger, a vanishing weighted log sum, and an aggregate value of one.

What the theorem does not claim: it does not say that the weighted log sum being zero is the only way to get zero cost, nor does it claim anything about the values of the cost when the aggregate is not one. It is a logical equivalence, not a numerical approximation. It also does not assert that such a balanced ledger exists for any particular choice of weights and values; it only states the condition under which balance occurs.

/-- Aggregate equals one exactly when the weighted log sum is zero. -/
theorem aggregate_eq_one_iff {n : ℕ} (α x : Vec n) :
    aggregate α x = 1 ↔ dot α (logVec x) = 0 := by
  unfold aggregate
  constructor
  · intro h
    have : Real.exp (dot α (logVec x)) = Real.exp 0 := by simpa using h
    exact Real.exp_injective this
  · intro h
    simp [h]

/-- Zero-cost iff weighted log sum vanishes. -/
theorem zero_cost_iff_dot_zero {n : ℕ} (α x : Vec n) :
    JcostN α x = 0 ↔ dot α (logVec x) = 0 :=
  JcostN_eq_zero_iff α x

/-- Zero-cost iff aggregate equals one. -/
theorem zero_cost_iff_aggregate_one {n : ℕ} (α x : Vec n) :
    JcostN α x = 0 ↔ aggregate α x = 1 := by
  constructor
  · intro h
    exact (aggregate_eq_one_iff α x).2 ((zero_cost_iff_dot_zero α x).1 h)
  · intro h
    exact (zero_cost_iff_dot_zero α x).2 ((aggregate_eq_one_iff α x).1 h)

What this page does not claim

The theorem does not prove that a balanced ledger exists for any particular weights and values. The theorem does not say anything about the cost values when the aggregate is not one. The theorem does not relate the aggregate to the golden ratio or the forcing chain.

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/Ndim/Neutrality.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: