Foundation Bool From Logic Decoy Swapped Bool Map Rejected

The swapped map test

A distinction has two sides and nothing else. In the framework's ledger, a discrete record of events, the primitive act of distinguishing produces exactly two bare outcomes: affirm and deny, meaning only "this side" and "the other side" of one cut. They carry no numeric content. The formal object LogicBool captures this two-constructor structure, and a theorem proves the two sides are not equal: affirm ≠ deny.

The framework then asks what happens if one tries to map these two sides onto ordinary Boolean true and false in the wrong order. The candidate map, called swappedMap, sends affirm to false and deny to true. The declaration decoy_swapped_bool_map_rejected establishes that this swapped map cannot respect the logical operation of conjunction. Specifically, the theorem proves it is false that for all a and b, swappedMap (land a b) = (swappedMap a && swappedMap b). In plain terms: if you swap the labels, the conjunction of two sides no longer behaves like ordinary Boolean AND.

The proof is short and direct. It takes the specific case where a is affirm and b is deny. Under the swapped map, land affirm deny evaluates to deny, which maps to true. But swappedMap affirm && swappedMap deny is false && true, which is false. Since true and false are distinct, the universal claim fails. This is a machine-checked proof in the framework's library of formal theorems, not a paper argument.

What the declaration does not claim is broader. It does not say the swapped map is useless or that no correspondence between the two-sided distinction and Boolean values exists. In fact, the framework separately proves a correct correspondence: the standard map sending affirm to true and deny to false is a full equivalence, with both directions verified. The rejected theorem only rules out one specific decoy, the swapped labeling, as a structure-preserving translation of conjunction. It leaves open whether other operations, such as disjunction or negation, might survive the swap; the proof targets only the conjunction law.

The consequence is a precise boundary on how the framework's primitive two-sided structure can be translated into ordinary logic. A reader now sees that the distinction's two sides are not interchangeable placeholders: the labels carry real logical roles, and flipping them breaks the most basic operation. This is a small but foundational check, one of the first stones in the framework's account of how recognition gives rise to Boolean structure.

/-- **Decoy 1 (swapped reading rejected)**: reading `affirm` as `false`
does not turn the meet into Boolean `and`. On the pair `(affirm, deny)`
the meet is `deny` (swapped ↦ `true`), while `false && true = false`.
So the swapped map is not a conjunction homomorphism. -/
theorem decoy_swapped_bool_map_rejected :
    ¬ (∀ a b : LogicBool,
        swappedMap (land a b) = (swappedMap a && swappedMap b)) := by
  intro h
  exact absurd (h affirm deny) (by decide)

/-- **Decoy 1 (swapped reading rejected)**: reading `affirm` as `false`
does not turn the meet into Boolean `and`. On the pair `(affirm, deny)`
the meet is `deny` (swapped ↦ `true`), while `false && true = false`.
So the swapped map is not a conjunction homomorphism. -/
theorem decoy_swapped_bool_map_rejected :
    ¬ (∀ a b : LogicBool,
        swappedMap (land a b) = (swappedMap a && swappedMap b)) := by
  intro h
  exact absurd (h affirm deny) (by decide)

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

What this page does not claim

The swapped map is useless for all purposes. The two sides of a distinction are interchangeable. The rejected theorem applies to operations other than conjunction.

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: