Foundation Maximal Forcing Admissible Realization Admissibility Class

The admissible class

An admissible class is a set of candidate realizations, the possible worlds or models a theory is willing to consider. The declaration AdmissibilityClass packages this idea as a pair: a predicate that picks out which realizations are admissible, and a human-readable label. The type of realizations is deliberately abstract, so the same machinery can govern strict logical structures, costed models, physical models, or domain-specific objects. This is the framework's way of saying: before asking what is true, say what is on the table.

The machinery's real work is in the tightening operation, a narrowing from a wider class A to a narrower class B. A tightening is a proof obligation, not a free choice. It must show that every B-admissible realization is also A-admissible, and it may carry a witness of strictness. The framework then proves a monotonicity theorem: if a claim is forced on the wider class, it remains forced after any tightening. This is the formal backbone of the framework's maximal-forcing stance, which never concedes a degree of freedom lazily. If a claim is not forced on the current class, the next move is either to add a deeper law that reality must satisfy, or to prove independence by constructing a countermodel.

Later definitions sharpen the tightening into a legitimate tightening, which adds two proof obligations beyond the subset order. It must demonstrate that the tightening does real work, meaning some realization admissible for the wider class is excluded by the narrower one. And it must supply a deeper law, a named, proved theorem that justifies the added constraint, so the narrowing is forced by a deeper law instead of being chosen freely. The framework proves that if a claim is independent over the wider class but forced over the narrower one, then the wider class necessarily contains a realization that fails the claim, which cannot be admissible in the narrower class. This is the independence-to-forcing flip that turns a narrowing into a genuine discovery instead of an arbitrary selection.

In Recognition Science, the framework models, these classes are how the forcing chain advances: each stage of the chain tightens the admissible class by a proved deeper law, and the theorems forced on the wider class carry over to the narrower one. The declaration itself establishes only the container and the order; it does not establish which deeper laws exist, nor does it prove that any particular claim is forced. The legitimacy of a tightening is a separate, discharged proof obligation, not a stored assumption. What the page shows is the formal skeleton: what it means to narrow a class, what it means for a narrowing to be justified, and why a claim forced on a wider class survives the narrowing.

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

/-- Tightening from `A` to `B`: every `B`-admissible realization is
`A`-admissible. The optional strictness witness is a separate field so the core
order remains usable even when strictness is not yet known. -/
structure Tightening {R : Type u} (A B : AdmissibilityClass R) where
  subset : ∀ r : R, r ∈ B.admissible -> r ∈ A.admissible
  strict_witness : Prop

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

The declaration does not establish which deeper laws exist or prove that any particular claim is forced. The declaration does not prove that any specific tightening is legitimate, only what legitimacy requires. The declaration does not define what a realization is, only the class structure over an abstract type.

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: