Foundation Logic Realization Logic Realization

A common object for logic

LogicRealization is a structure in the Recognition Science framework's machine-checked library. It defines a common object into which different settings, such as continuous positive ratios, discrete propositions, or categorical structures, can be mapped. The point is not to finish a grand program in one stroke, but to create a shared interface so that distinct systems can be studied through what they have in common. The structure carries a carrier, a comparison cost, an identity element, and a step action, along with the structural laws the Universal Forcing program needs.

The key idea is that the invariant target is not the ambient carrier itself. A realization might live in a topological space, an ordered set, or a category, but what matters is the arithmetic object extracted from its identity and step data. The library proves that any nontrivial realization has an identity step: there exists an element whose comparison with zero is nonzero. This is a theorem, not an assumption. The library also defines a faithful arithmetic interpretation, a property that holds when the internal forced arithmetic embeds injectively into the carrier, meaning distinct internal elements stay distinct in the ambient space. Periodic realizations, such as modular carriers, need not satisfy this; their internal orbit can still be free while the carrier interpretation is periodic.

For the continuous positive-ratio case, the library constructs a concrete realization from a comparison operator and a proof that it satisfies the laws of logic. It then proves that this realization has an identity step, that its orbit interpretation is injective, and that it is faithful. These are proved in the machine-checked library. The construction folds over a discrete natural-number-like type, mapping identity to the real number 1 and each step to multiplication by a chosen non-trivial generator. The injectivity proof shows that distinct internal elements map to distinct positive reals, and the faithfulness proof shows that the zero element never collapses with a step element.

What LogicRealization does not claim is important. It does not claim that any particular setting is the one true logic. It does not claim that the Universal Forcing program is complete. It does not claim that periodic realizations are impossible or that every carrier must be faithful. The structure is an interface, a shared vocabulary, not a conclusion about which logic is correct. The results about the positive-ratio case are specific to that setting; they show that this particular realization fits the interface, not that all realizations must behave the same way. The library is honest about this: the docstring says the point is to create a common object, not to finish the program in one stroke.

For a reader, the practical upshot is that LogicRealization is a tool for comparison. It lets the framework ask what different logical settings have in common, by extracting arithmetic from their identity and step structure. It is a foundation stone, not a finished building. The results it proves are real, but they are about the interface, not about the world. The framework's larger claims, about forcing specific constants or dimensions, depend on further steps that LogicRealization alone does not establish.

/-- A Law-of-Logic realization: a carrier with comparison cost, identity
element, step/generator action, and the structural laws needed by the
Universal Forcing program.

The fields are intentionally lean: each realization supplies its own topology,
order, category, or discrete structure through the propositions carried here.
The invariant target is not the ambient carrier; it is the arithmetic object
extracted from the identity/step data. -/
structure LogicRealization where
  Carrier : Type u
  Cost : Type v
  zeroCost : Zero Cost
  compare : Carrier → Carrier → Cost
  zero : Carrier
  step : Carrier → Carrier
  Orbit : Type u
  orbitZero : Orbit
  orbitStep : Orbit → Orbit
  interpret : Orbit → Carrier
  interpret_zero : interpret orbitZero = zero
  interpret_step : ∀ n : Orbit, interpret (orbitStep n) = step (interpret n)
  orbit_no_confusion : ∀ n : Orbit, orbitZero ≠ orbitStep n
  orbit_step_injective : Function.Injective orbitStep
  orbit_induction :
    ∀ P : Orbit → Prop,
      P orbitZero →
      (∀ n, P n → P (orbitStep n)) →
      ∀ n, P n
  orbitEquivLogicNat : Orbit ≃ LogicNat
  orbitEquiv_zero : orbitEquivLogicNat orbitZero = LogicNat.zero
  orbitEquiv_step : ∀ n : Orbit,
    orbitEquivLogicNat (orbitStep n) = LogicNat.succ (orbitEquivLogicNat n)
  identity : ∀ x : Carrier, compare x x = 0
  nonContradiction : ∀ x y : Carrier, compare x y = compare y x
  excludedMiddle : Prop
  composition : Prop
  actionInvariant : Prop
  nontrivial : ∃ x : Carrier, compare x zero ≠ 0

theorem hasIdentityStep_of_nontrivial (R : LogicRealization) :
    R.hasIdentityStep :=
  R.nontrivial

/-- Continuous positive-ratio Law-of-Logic realizations embed into the
setting-independent interface. -/
noncomputable def ofPositiveRatioComparison
    (C : ComparisonOperator) (h : SatisfiesLawsOfLogic C) :
    LogicRealization where
  Carrier := {x : ℝ // 0 < x}
  Cost := ℝ
  zeroCost := inferInstance
  compare := fun x y => C x.1 y.1
  zero := ⟨1, one_pos⟩
  step := fun x =>
    let γ : ℝ := Classical.choose h.non_trivial
    ⟨γ * x.1, mul_pos (Classical.choose_spec h.non_trivial).1 x.2⟩
  Orbit := LogicNat
  orbitZero := LogicNat.zero
  orbitStep := LogicNat.succ
  interpret := positiveRatioOrbitInterpret C h
  interpret_zero := rfl
  interpret_step := by
    intro n
    rfl
  orbit_no_confusion := by
    intro n hzero
    exact LogicNat.zero_ne_succ n hzero
  orbit_step_injective := LogicNat.succ_injective
  orbit_induction := by
    intro P h0 hs n
    exact LogicNat.induction (motive := P) h0 hs n
  orbitEquivLogicNat := Equiv.refl LogicNat
  orbitEquiv_zero := rfl
  orbitEquiv_step := by intro n; rfl
  identity := by
    intro x
    exact h.identity x.1 x.2
  nonContradiction := by
    intro x y
    exact h.non_contradiction x.1 y.1 x.2 y.2
  excludedMiddle := ExcludedMiddle C
  composition := RouteIndependence C
  actionInvariant := ScaleInvariant C
  nontrivial := by
    rcases h.non_trivial with ⟨x, hx, hcost⟩
    exact ⟨⟨x, hx⟩, hcost⟩

/-- The continuous positive-ratio realization satisfies the abstract
identity-step predicate. -/
theorem positiveRatio_hasIdentityStep
    (C : ComparisonOperator) (h : SatisfiesLawsOfLogic C) :
    (ofPositiveRatioComparison C h).hasIdentityStep :=
  hasIdentityStep_of_nontrivial _

/-- The continuous positive-ratio orbit interpretation is injective. -/
theorem positiveRatio_interpret_injective
    (C : ComparisonOperator) (h : SatisfiesLawsOfLogic C) :
    Function.Injective (positiveRatioOrbitInterpret C h) := by
  intro a b hab
  have hval := congrArg Subtype.val hab
  rw [positiveRatioOrbitInterpret_val, positiveRatioOrbitInterpret_val] at hval
  exact ArithmeticFromLogic.embed_injective
    (ArithmeticFromLogic.generatorOfLawsOfLogic h) hval

/-- The continuous positive-ratio realization interprets its forced arithmetic
faithfully into the positive real carrier. -/
theorem positiveRatio_faithful
    (C : ComparisonOperator) (h : SatisfiesLawsOfLogic C) :
    FaithfulArithmeticInterpretation (ofPositiveRatioComparison C h) where
  injective := by
    intro a b hab
    exact positiveRatio_interpret_injective C h hab
  zero_step_noncollapse := by
    intro n hcollapse
    exact LogicNat.zero_ne_succ n (positiveRatio_interpret_injective C h hcollapse)

What this page does not claim

LogicRealization does not claim that any particular logical setting is the correct one. LogicRealization does not claim that the Universal Forcing program is complete. LogicRealization does not claim that all realizations are faithful; periodic carriers are explicitly allowed.

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