Foundation Recognition Signature Gauge Boolean Shadow Completeness Boundary Hold

The one-bit boundary

A Boolean distinction is a single yes-or-no answer, like a switch that is on or off. The declaration booleanShadowCompletenessBoundary_holds records a boundary about such distinctions: one Boolean coordinate is never enough to completely describe a state, while two coordinates can be. The framework models this with a state space of two switches, Bool × Bool, which has four possible states. Reading only the first switch collapses the four states into two groups, so states like (false, false) and (false, true) become indistinguishable. The theorem proves this failure explicitly: there exist two distinct states that share the same value on the first coordinate.

The boundary is not just about switches. The framework also defines a scalar cost, a single real number assigned to each state, and proves that one such number suffers the same incompleteness. Two distinct states can carry the same cost, so a single scalar value cannot tell them apart. Completeness arrives only with the full family of observables. The theorem shows that the pair of coordinate recognizers, the functions that read the first and second switches, does separate every state: if two states agree on both coordinates, they are the same state. The full recognition signature, the record of all observables, therefore gives an injective projection onto the quotient of states.

In Recognition Science, the declaration bundles these facts into a single certificate. It asserts that one-bit observations are an atomic floor, a minimal unit of recognition, but not a complete encoding. Scalar-cost equality is only a complete gauge invariant under a separate completeness hypothesis, not by default. The certificate also ties the boundary to the quotient theorem: physical identification is equality of the full recognition signature, and every admitted observable descends to the quotient. The result has 0 sorry and 0 project axiom, meaning the machine-checked library of formal theorems verifies it without unproved assumptions.

What the declaration does not claim is just as important. It does not say that the full signature is always obtainable or that a separating family always exists; the certificate states the conditional, that a separating family gives an injective projection. It does not claim that one Boolean coordinate is complete in any special case; the theorem proves the opposite for the two-switch space. And it does not assert that scalar cost alone ever suffices without the completeness hypothesis. The boundary is a precise limit on what a single bit can know, and a precise condition for when two bits can know everything.

/-- 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

/-- 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

/-- Scalar cost equality alone is not a complete physical quotient unless a
separate completeness theorem is supplied. -/
theorem first_bit_scalar_cost_not_complete :
    ∃ x y : PairBoolState, x ≠ y ∧ firstBitScalarCost x = firstBitScalarCost y := by
  refine ⟨(false, false), (false, true), ?_, ?_⟩
  · decide
  · rfl

/-- 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

/-- The corrected T0 boundary is machine-checkable: one bit is atomic, not
complete; a full signature quotient is theorem-grade; scalar cost completeness
requires an extra completeness hypothesis. -/
theorem booleanShadowCompletenessBoundary_holds :
    BooleanShadowCompletenessBoundary where
  one_bit_not_complete := one_boolean_coordinate_not_complete
  scalar_cost_not_complete := first_bit_scalar_cost_not_complete
  two_bit_signature_injective := pairBitFamily_projection_injective
  full_signature_quotient_exact := fun F x y => signature_forced_quotient_iff F x y

What this page does not claim

The full recognition signature is always obtainable for every state space. A single Boolean coordinate is complete in any special case. Scalar cost alone ever suffices without the 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: