Foundation Bool From Logic From Bool To Bool

The round trip

In logic, a distinction is a cut with two sides and nothing else: this side, and the other side. The Recognition Science framework starts there, building its account of structure from that primitive act of distinguishing. It calls the two sides affirm and deny, names that carry no numeric content, only the sense of "this side" and "the other side" of one cut. The framework's machine-checked library of formal theorems then shows that this two-sided structure is exactly the Boolean structure that ordinary computer logic uses: the familiar true and false.

The bridge between the two is a pair of maps. One map, called toBool, sends affirm to true and deny to false. The other, called fromBool, sends true back to affirm and false back to deny. The declaration fromBool_toBool proves that this round trip is a perfect circle: if you start with any side of a distinction, send it to the Boolean world, and send it back, you get exactly the side you started with. Formally, for every a in the distinction type, fromBool (toBool a) = a. The proof is immediate: there are only two cases, and each one checks by definition. The same library also proves the reverse direction, that sending a Boolean to the distinction world and back leaves it unchanged.

What this establishes is a structural identity, not a new discovery about computers. The framework's claim is that the two-sided cut, with no extra data, already has the shape of Boolean logic. The round trip theorem is the hinge: it shows the two descriptions, the philosophical one and the computational one, are interchangeable. Nothing is lost in translation, and nothing is added. The distinction type and the Boolean type are equivalent, in the precise sense that a bijection exists between them with both round trips behaving as identity.

The declaration does not claim that this equivalence is surprising or deep. It is a simple fact, proved by checking two cases. It does not claim that affirm and deny are the same as true and false in any metaphysical sense; they are two different types, and the theorem only says the translation between them is reversible. It also does not claim that this two-sided structure is the only possible foundation for logic, only that within this framework it is the Boolean structure. The value of the result is architectural: it lets the framework use ordinary Boolean reasoning wherever a distinction appears, and it lets a reader move freely between the language of cuts and the language of bits.

For a reader, the practical consequence is simple. When the framework speaks of affirm and deny, it is speaking of the same two-valued logic that every programmer knows. The round trip theorem is the guarantee that no meaning is lost when the framework translates its distinctions into the Boolean world, which is the world where the rest of its proofs live.

theorem fromBool_toBool : ∀ a : LogicBool, fromBool (toBool a) = a := by
  intro a; cases a <;> rfl

/-- **Recovery theorem (carrier)**: `LogicBool` and `Bool` are in
bijection. The two sides of a single distinction are exactly the two
Boolean values. -/
def equivBool : LogicBool ≃ Bool where
  toFun := toBool
  invFun := fromBool
  left_inv := fromBool_toBool
  right_inv := toBool_fromBool

/-- The two sides of a single distinction δ.

`affirm` and `deny` are the two bare outcomes of the primitive act of
distinguishing. They carry no numeric content; they are only "this
side" and "the other side" of one cut. The two-constructor structure
mirrors the split that δ performs. -/
inductive LogicBool : Type
  | affirm : LogicBool
  | deny   : LogicBool
  deriving DecidableEq, Repr

What this page does not claim

This answer does not claim that affirm and deny are identical to true and false, only that the translation between them is reversible. This answer does not claim that the two-sided distinction is the only possible foundation for logic. This answer does not claim that the round trip theorem is deep or surprising; it is a simple proof by cases.

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