Foundation Discrete Logic Realization Bool Orbit Interpret

The Boolean carrier

In mathematics, a Boolean algebra is a structure with two values, typically true and false, and operations like AND, OR, and NOT. It is the simplest possible carrier for logical reasoning, the discrete cousin of the continuous number line. The declaration boolOrbitInterpret belongs to this classical setting: it maps a sequence of logical steps onto the two Boolean values by parity, so that an even number of steps lands on false and an odd number lands on true.

The definition is direct. The identity step, the operation of doing nothing, maps to false. Each subsequent step flips the value, so the first step gives true, the second gives false, and the alternation continues indefinitely. This is a standard construction in discrete mathematics, where parity arguments distinguish two states. The declaration itself is a definition, not a theorem; it chooses a particular interpretation of a logical orbit in a two-valued system.

What the framework adds is a claim about what this simple carrier forces. The machine-checked library of formal theorems shows that this Boolean realization has the same arithmetic structure as every other realization in the framework. Specifically, it proves that the Boolean carrier has a non-trivial identity-step shadow and that its forced arithmetic satisfies the Peano surface, meaning it behaves like the natural numbers. This is the framework's central assertion: even the most minimal two-value logic system cannot escape the arithmetic that the framework derives from its cost function.

In Recognition Science, a recognition is a discrete record of events, and the cost of recognition is forced, not chosen. The Boolean carrier is the first non-continuous test case for this forcing. The framework proves that the arithmetic arising from this two-value system is equivalent to the arithmetic arising from any other realization, a result it calls the arithmetic invariant. This means the framework's arithmetic is not an accident of a particular continuous model but is forced even in the discrete case.

The declaration does not claim that Boolean logic itself is the foundation of arithmetic. It does not claim that the parity interpretation is unique or that it models all of logic. It only establishes one specific mapping and, through the framework's theorems, shows that this mapping yields the same forced arithmetic as every other realization. The definition is a choice; the invariance is the proved result.

/-- Interpret the free step orbit in the Boolean carrier by parity. -/
def boolOrbitInterpret : ArithmeticFromLogic.LogicNat → Bool
  | ArithmeticFromLogic.LogicNat.identity => false
  | ArithmeticFromLogic.LogicNat.step n => Bool.not (boolOrbitInterpret n)

/-- The discrete realization has a non-trivial identity-step shadow. -/
theorem bool_hasIdentityStep : boolRealization.hasIdentityStep :=
  LogicRealization.hasIdentityStep_of_nontrivial boolRealization

/-- The Boolean realization's forced arithmetic has the Peano surface. -/
theorem bool_peano_surface :
    ArithmeticOf.PeanoSurface (UniversalForcing.arithmeticOf boolRealization) :=
  UniversalForcing.peano_surface boolRealization

/-- Boolean realization has the same forced arithmetic as every realization. -/
noncomputable def bool_arithmetic_invariant (R : LogicRealization.{0, 0}) :
    (UniversalForcing.arithmeticOf boolRealization).peano.carrier
      ≃ (UniversalForcing.arithmeticOf R).peano.carrier :=
  ArithmeticOf.equivOfInitial
    (UniversalForcing.arithmeticOf boolRealization) (UniversalForcing.arithmeticOf R)

What this page does not claim

The parity interpretation is the only possible mapping from logical steps to Boolean values. Boolean logic itself is the foundation of arithmetic within the framework. The declaration proves anything about the continuous cost function J; it only concerns the discrete carrier.

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