Foundation Maximal Forcing Admissible Realization

The Forcing Strategy

Maximal forcing is a strategy for building a theory of reality from the ground up. The idea is that when a claim is not yet forced by the rules you have, you do not simply accept it as a free choice. Instead, you have two options: tighten the rules by adding a deeper law that reality must satisfy, or prove that the claim is genuinely independent by finding a countermodel. This framework defines the machinery for that first option, the tightening of admissible classes.

An admissible class, a set of possible realizations that count as valid under the current rules, is the arena where claims are tested. A tightening from class A to class B is defined: every realization admissible under B is also admissible under A, so B is a stricter set of rules. The key theorem, forced_of_forced_under_tightening, shows that if a claim is forced on the wider class A, it remains forced on the narrower class B. This is the monotonicity property: adding constraints cannot un-force a claim.

The framework then addresses the question of when a tightening is legitimate. A mere tightening with no justification is a free selection, which maximal forcing rejects. A legitimate tightening must do real work: there must exist a realization admissible under A that is excluded by B. This is derived from an independence-to-forcing flip. If a claim is independent over A but forced over B, then the A-admissible realization that fails the claim cannot be B-admissible, since everything B-admissible satisfies it. The theorem tightening_does_work proves this existence.

Finally, a legitimate tightening must be justified by a deeper law. The structure LegitimateTightening carries a proof of the deeper law and a label for audit. The smart constructor legitimateTightening_of_flip assembles a legitimate tightening from an independence-to-forcing flip plus a named, proved deeper law. This replaces a placeholder with a discharged proof obligation: legitimacy is now a demonstrated fact, not an assumption.

In Recognition Science, this framework establishes the formal scaffolding for how the framework grows its laws. It does not itself prove any physical law; it provides the proof discipline for adding constraints. The consequence is that every tightening in the framework's development is either justified by a deeper proved law or rejected as a free choice. This is how the framework maintains the claim that its structure is forced, not selected.

/-- A class of admissible realizations. The type `R` is deliberately abstract:
different phases may instantiate it with strict logic realizations, costed
realizations, physical models, or domain-specific structures. -/
structure AdmissibilityClass (R : Type u) where
  admissible : Set R
  label : String

/-- If a claim is forced on a wider admissible class, it remains forced after
tightening. -/
theorem forced_of_forced_under_tightening {R : Type u}
    {A B : AdmissibilityClass R} {C : RealityClaim R}
    (hT : Tightening A B) (hA : Forced A.admissible C) :
    Forced B.admissible C := by
  intro r hr
  exact hA r (hT.subset r hr)

/-- A tightening does real work when some realization admissible for the wider
class `A` is excluded by the narrower class `B`. This is derived from a genuine
independence-to-forcing flip: if a claim is independent over `A` but forced over
`B`, then the `A`-admissible realization that *fails* the claim cannot be
`B`-admissible, since everything `B`-admissible satisfies it. -/
theorem tightening_does_work {R : Type u} {A B : AdmissibilityClass R}
    {C : RealityClaim R}
    (hIndep : Independent A.admissible C) (hForced : Forced B.admissible C) :
    ∃ r : R, r ∈ A.admissible ∧ r ∉ B.admissible := by
  obtain ⟨_r0, r1, _h0, h1, _hC0, hnotC1⟩ := hIndep
  exact ⟨r1, h1, fun hr1B => hnotC1 (hForced r1 hr1B)⟩

/-- A **legitimate** tightening. Beyond the subset order it carries:

* `does_work`: a proof the gate is non-vacuous (some `A`-admissible realization is
  excluded by `B`); and
* `deeper_law` together with `deeper_law_proof`: the actual RS forcing theorem that
  justifies the added constraint, so the tightening is forced by a deeper law, not
  chosen freely. `deeper_law_label` names it for the audit.

This replaces `strict_witness := True`: legitimacy is now a discharged proof
obligation, not a stored `True`. -/
structure LegitimateTightening {R : Type u} (A B : AdmissibilityClass R) where
  subset : ∀ r : R, r ∈ B.admissible -> r ∈ A.admissible
  does_work : ∃ r : R, r ∈ A.admissible ∧ r ∉ B.admissible
  deeper_law : Prop
  deeper_law_proof : deeper_law
  deeper_law_label : String

What this page does not claim

This framework does not prove any physical law or constant. A tightening with a stored True placeholder is not legitimate; legitimacy requires a discharged proof obligation.

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/MaximalForcing/AdmissibleRealization.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: