Foundation Boolean Projection From Mark Boolean Projection From Mark Cert

The marked pair

A Boolean projection is a way of collapsing a collection of things into a two-valued shadow: each thing is sorted into one of two buckets, often written false and true. For a set with at least two elements, many such shadows exist, because any choice of which element lands in the false bucket and which in the true bucket gives a different sorting. The Recognition Science declaration booleanProjectionFromMarkCert packages two proved facts about when such a shadow is canonical, meaning uniquely forced rather than arbitrary.

The first fact is that a canonical shadow appears as soon as you name a marked pair: two distinct elements of the set, one called the base and one called the alternative. Given that mark, the projection is forced: the base maps to false, and every other element, including the alternative, maps to true. The framework's library proves this as a theorem, so the sorting is not a choice once the mark is fixed. The second fact is the negative side: without such a mark, a set with three or more elements admits at least two different projections, so non-singletonness alone does not select one. The certificate bundles both facts into a single statement, and the declaration that produces it is itself theorem-backed, not a definitional assumption.

The practical consequence is a precise division of labor. A two-valued floor for a structure is canonical only after a distinguishing mark has been chosen; the mark is the input that breaks symmetry. This matters for the framework's broader program because it shows exactly where a Boolean foundation becomes forced and where it remains underdetermined. The certificate does not claim that any particular mark is the right one, nor that a set alone, without a named element, yields a unique two-valued shadow. It claims only the conditional: given a mark, the projection is canonical; without one, it is not.

For a reader new to the framework, the takeaway is a clean boundary. If you want a forced two-valued sorting, you must supply a distinguished element; the framework proves that this is both sufficient and necessary. The certificate is a small but load-bearing piece of the foundation, because it states in machine-checked form the exact point where a Boolean floor stops being a choice and becomes a consequence.

/-- Given a marked pair, the induced Boolean projection sends the marked base
to `false` and the marked alternative to `true`. -/
theorem boolProjection_canonical_given_mark {K : Type*} (m : MarkedPair K) :
    boolProjection m m.base = false ∧ boolProjection m m.alt = true := by
  classical
  constructor
  · simp [boolProjection]
  · have halt_ne_base : m.alt ≠ m.base := fun h => m.distinct h.symm
    simp [boolProjection, halt_ne_base]

/-- Without a mark, a three-point carrier has multiple inequivalent Boolean
shadows. This witnesses that non-singletonness alone does not canonically
select a Boolean floor projection. -/
theorem bool_projection_not_canonical_without_mark :
    ∃ (K : Type) (m1 m2 : MarkedPair K),
      boolProjection m1 ≠ boolProjection m2 := by
  classical
  let m1 : MarkedPair (Fin 3) :=
    { base := 0
      alt := 1
      distinct := by decide }
  let m2 : MarkedPair (Fin 3) :=
    { base := 1
      alt := 0
      distinct := by decide }
  refine ⟨Fin 3, m1, m2, ?_⟩
  intro h
  have h0 := congrArg (fun f : Fin 3 → Bool => f 0) h
  simp [boolProjection, m1, m2] at h0

/-- The Boolean-projection certificate is theorem-backed. -/
theorem booleanProjectionFromMarkCert : BooleanProjectionFromMarkCert where
  marked_pair_projection := boolProjection_canonical_given_mark
  no_canonical_projection_without_mark :=
    bool_projection_not_canonical_without_mark

What this page does not claim

The certificate does not claim that any particular mark is the correct or intended one. The certificate does not claim that a set alone, without a named element, yields a unique two-valued shadow. The certificate does not address how marks are chosen in physical applications of the framework.

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