Foundation Non Triviality From Distinguishability Const Zero Not Distinguishable

The constant-zero comparison

In Recognition Science, a comparison operator is a rule that assigns a cost to any pair of positive quantities, a number meant to capture how far apart they are. The framework's foundational laws of logic, which include identity, non-contradiction, and scale invariance, are satisfied by a trivial operator: the one that returns zero for every pair. This constant-zero operator is a genuine solution to those laws, and it is a problem. If comparison always costs nothing, then no two quantities are ever distinguished, and the entire edifice of recognition collapses into a single undifferentiated point.

The declaration constZero_not_distinguishable states that this constant-zero operator fails a specific property called distinguishability. Distinguishability is the requirement that comparison is not vacuous: there exists at least one pair of distinct positive quantities whose comparison cost is non-zero. The constant-zero operator, by definition, returns zero for every pair, so it cannot satisfy this. The theorem is a direct consequence of the definition, and it is proved in the machine-checked library of formal theorems that the framework uses.

The point of this theorem is to show what the framework must assume, not what it can prove. The constant-zero operator satisfies the four Aristotelian conditions of identity, non-contradiction, excluded middle, and scale invariance. Without an extra commitment, the framework cannot rule it out. Distinguishability is that commitment. It is a natural one: it says that comparison actually does something. The theorem constZero_not_distinguishable shows that the constant-zero operator is the precise obstacle that distinguishability removes.

The framework then proves an equivalence: under the laws of logic, distinguishability is exactly the same as the earlier, more algebraic condition of non-triviality, which stated that the cost function is not identically zero. This means the framework can replace a technical posit with a genuinely Aristotelian one. Instead of saying "the cost function is not identically zero," it says "comparison is operative." The constant-zero operator is the counterexample that motivates this replacement, and the theorem names it explicitly.

What the theorem does not claim is that the constant-zero operator is the only operator that fails distinguishability, nor does it say that distinguishability is sufficient to force the full cost function. It only establishes that the constant-zero operator is not distinguishable, and that this is the gap the framework must fill. The theorem is a negative result that clears the ground for the positive construction of the cost function.

In the wider framework, this result is a small but necessary step. It shows that the foundation is honest about its assumptions: it does not pretend to derive everything from nothing. The constant-zero operator is a real possibility that must be explicitly excluded, and the theorem names it. This is what makes the framework's later results, such as the derivation of the cost function, stand on a clear and explicit foundation.

The consequence for the reader is a clear picture of the framework's first move. It does not claim that the laws of logic alone force a non-trivial comparison. It claims that the laws of logic plus one explicit condition, distinguishability, do. The constant-zero operator is the boundary case that makes this condition necessary, and the theorem constZero_not_distinguishable is the proof that it is a real boundary.

/-- The constant-zero comparison operator. -/
def constZero : ComparisonOperator := fun _ _ => 0

/-- Constant zero satisfies identity. -/
theorem constZero_identity : Identity constZero := by
  intro x _; rfl

/-- Constant zero satisfies non-contradiction. -/
theorem constZero_nonContradiction : NonContradiction constZero := by
  intro x y _ _; rfl

/-- Constant zero is continuous on the positive quadrant. -/
theorem constZero_continuous : ExcludedMiddle constZero := by
  unfold ExcludedMiddle
  exact continuousOn_const

/-- Constant zero is scale-invariant. -/
theorem constZero_scaleInvariant : ScaleInvariant constZero := by
  intro _ _ _ _ _ _; rfl

/-- Constant zero fails distinguishability. -/
theorem constZero_not_distinguishable : ¬ Distinguishability constZero := by
  intro ⟨_, _, _, _, h⟩
  exact h rfl

/-- **Equivalence theorem**: under scale invariance, distinguishability
and non-triviality are the same condition. -/
theorem nonTrivial_iff_distinguishability
    (C : ComparisonOperator) (hSI : ScaleInvariant C) :
    NonTrivial C ↔ Distinguishability C :=
  ⟨distinguishability_of_nonTrivial C, nonTrivial_of_distinguishability C hSI⟩

What this page does not claim

The constant-zero operator is the only operator that fails distinguishability. Distinguishability alone is sufficient to derive the full cost function. The framework derives the laws of logic from nothing.

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/NonTrivialityFromDistinguishability.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: