Foundation Tminus1 Forced From Distinction Bool Certificate Forced From Distinct

A certificate from a difference

In mathematics, a distinction is simply the fact that two things are not the same. Given any collection with at least two distinct elements, one can label one element as "base" and another as "alt". The Recognition Science declaration bool_certificate_forced_from_distinction proves that from this single fact, a complete two-valued logical structure follows. It constructs a Boolean projection, an equivalence relation, and a two-class quotient, all without assuming any additional structure.

The proof works by building a marked pair from the distinction, then defining a function that sends the base element to false and the alt element to true. This projection generates an equivalence relation: two elements are equivalent if they map to the same Boolean value. The quotient of the original collection by this relation is then shown to be equivalent to the two-element Boolean type. The theorem forcedBooleanCoordinates_unique_up_to_bool_aut establishes that this coordinate system is unique up to a Boolean automorphism, meaning the structure is canonical.

The declaration bool_certificate_forced_from_distinction itself states that the Boolean type carries a RealityCertificate. This certificate is the framework's formal record that a structure satisfies the minimal requirements for recognition. The proof is grounded in the machine-checked library of formal theorems, which verifies each step. The result is that the Boolean/observable floor is not an extra measure: once a distinction is given, the two-valued structure is forced.

This result matters because it shows the framework's foundational layer is minimal. The primitive is not an external admissibility package but a distinction witness. If there is no object-level distinction, there is no object-level forcing. But once the distinction is given, the Boolean floor follows necessarily. The theorem forced_distinction_certificate_decomposes further shows that the certificate decomposes into distinction-supplied and upstream-supplied fields, clarifying what is forced and what is assumed.

What the declaration does not claim is that this structure is unique in any absolute sense. The uniqueness is up to Boolean automorphism, not up to a single canonical choice. It also does not claim that the Boolean type itself is the only possible two-valued structure, only that it is the one generated by the distinction. Finally, it does not claim that the distinction witness itself is derived; it is supplied as a hypothesis. The theorem shows what follows from a distinction, not that a distinction must exist.

/-- The Boolean projection forced by a chosen distinction witness. -/
noncomputable def forcedBoolProjection
    {K : Type*} (h : ∃ x y : K, x ≠ y) : K → Bool :=
  boolProjection (markedPairOfDistinction h)

/-- The observable equivalence relation forced by a distinction: two
representatives are equivalent exactly when the forced Boolean projection gives
the same value on them. -/
noncomputable def forcedObservableSetoid
    {K : Type*} (h : ∃ x y : K, x ≠ y) : Setoid K where
  r x y := forcedBoolProjection h x = forcedBoolProjection h y
  iseqv := by
    constructor
    · intro x
      rfl
    · intro x y hxy
      exact hxy.symm
    · intro x y z hxy hyz
      exact hxy.trans hyz

/-- The observable quotient generated by a distinction is equivalent to Bool. -/
noncomputable def forcedQuotientEquivBool
    {K : Type*} (h : ∃ x y : K, x ≠ y) :
    Quotient (forcedObservableSetoid h) ≃ Bool where
  toFun := forcedQuotientToBool h
  invFun := forcedBoolRepresentative h
  left_inv := forcedBoolRepresentative_left_inv h
  right_inv := forcedQuotientToBool_representative h

/-- Boolean coordinates forced by the same distinction are unique up to Boolean
automorphism. -/
theorem forcedBooleanCoordinates_unique_up_to_bool_aut
    {K : Type*} {h : ∃ x y : K, x ≠ y}
    (c₁ c₂ : ForcedBooleanCoordinates h) :
    c₂.coord = c₁.coord.trans (forcedBooleanCoordinateChange c₁ c₂) := by
  ext q
  simp [forcedBooleanCoordinateChange]

/-- The Boolean distinction yields the recognition-chain certificate. -/
theorem bool_certificate_forced_from_distinction :
    RealityCertificate Bool :=
  recognition_certificate_forced_from_distinction Bool bool_distinction

/-- Decomposition audit for the stronger formulation: the distinction forces
the T−1 floor interface; the remaining certificate fields are the already
proved upstream forcing-chain theorems. -/
theorem forced_distinction_certificate_decomposes
    (K : Type) [Nonempty K]
    (h : ∃ x y : K, x ≠ y) :
    DistinctionSuppliedFields K ∧ UpstreamSuppliedFields :=
  bundling_decomposition K h

What this page does not claim

The declaration does not prove that a distinction must exist in any given collection. The uniqueness of Boolean coordinates is only up to automorphism, not absolute. The Boolean type is not claimed to be the only possible two-valued structure.

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