Foundation Recognition Signature Gauge Recognition Signature Gauge Certificate H

The certificate's content

The declaration recognitionSignatureGaugeCertificate_holds is a formal guarantee about how the framework's recognition events, the discrete records of what an observer can distinguish, relate to the states they describe. It proves three things at once. First, two states are physically identical exactly when every admitted observable, every measurement the framework allows, gives the same result on both. Second, any such observable can be expressed as a function on the quotient, the set of equivalence classes of indistinguishable states, without losing information. Third, if a family of observables can tell every pair of distinct states apart, then the map from states to their full recognition signatures is injective: no two different states share a complete profile.

The certificate's real bite appears in what it does not claim. A single Boolean coordinate, one yes-or-no question about a state, is not complete in general. The framework proves this with a concrete counterexample on the state space Bool × Bool, the set of two bits. The recognizer that reads only the first bit cannot distinguish (false, false) from (false, true), even though these are different states. The same failure afflicts a scalar cost, a single real number meant to summarize a state: the first-bit cost function assigns 1 to every state whose first bit is true and 0 otherwise, so it also conflates the two distinct states. Completeness holds only under a separate hypothesis, named ScalarCostCompleteFor, which explicitly requires that equal costs coincide with equal recognition signatures.

In Recognition Science, the certificate is the correction prompted by a June 2026 audit of Boolean shadows, the coarse one-bit projections of a state space. The audit found that a single Boolean distinction is an atomic recognition floor, the smallest possible unit of observable difference, but not a complete encoding of an arbitrary state space. The complete observable object, when it exists, is the family of recognizers and its full signature. The certificate packages this insight into a reusable theorem: for any family of observables, the quotient is exact, observables descend, and a separating family yields an injective projection. A companion result, booleanShadowCompletenessBoundary_holds, shows that two coordinate recognizers do separate the two-bit state space, so the boundary sits precisely at one bit.

What the certificate changes is the status of scalar-cost equality in the framework. Without the completeness hypothesis, two states with equal cost are not necessarily the same state; the cost is a gauge invariant only under that extra condition. The certificate makes the default failure explicit and gives the framework a precise tool for saying when a summary statistic is trustworthy. It does not, however, claim that any particular family of observables is complete, nor that a full recognition signature always exists for every state space. Those remain open targets, and the certificate's value is in marking the boundary clearly rather than pretending it is not there.

/-- The physical quotient induced by a family of recognizers is exactly equality
of the full recognition signature. -/
theorem signature_forced_quotient_iff (F : Set (X → C)) (x y : X) :
    proj F x = proj F y ↔ SameRecognitionSignature F x y :=
  forced_iff F x y

/-- One Boolean coordinate fails to separate the two states with the same first
bit and different second bit. -/
theorem one_boolean_coordinate_not_complete :
    ∃ x y : PairBoolState,
      x ≠ y ∧ SameRecognitionSignature firstBitFamily x y := by
  refine ⟨(false, false), (false, true), ?_, ?_⟩
  · decide
  · intro f hf
    have hf' : f = firstBit := hf
    rw [hf']
    rfl

/-- Under the explicit completeness hypothesis, the scalar-cost kernel matches
the full recognition-signature equivalence.  Without this hypothesis, scalar
cost equality is only a cost observable. -/
theorem scalar_cost_kernel_eq_signature_of_complete
    (F : Set (X → C)) (cost : X → ℝ) (hcomplete : ScalarCostCompleteFor F cost)
    (x y : X) :
    cost x = cost y ↔ SameRecognitionSignature F x y :=
  hcomplete x y

/-- The two coordinate Boolean recognizers separate all states of `Bool × Bool`. -/
theorem pairBitFamily_separating :
    ∀ x y : PairBoolState, SameRecognitionSignature pairBitFamily x y → x = y := by
  intro x y hsig
  cases x with
  | mk x₁ x₂ =>
    cases y with
    | mk y₁ y₂ =>
      have h₁ : x₁ = y₁ := by
        exact hsig firstBit (Or.inl rfl)
      have h₂ : x₂ = y₂ := by
        exact hsig secondBit (Or.inr rfl)
      cases h₁
      cases h₂
      rfl

What this page does not claim

The certificate does not claim that any particular family of observables is complete. It does not claim that a full recognition signature exists for every state space. It does not claim that scalar-cost equality is a complete gauge invariant without the separate completeness hypothesis.

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