openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Models /GroundInjectionRestrictions.lean
| import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundSmallFunctionSpaces | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Forcing.InjectionCode | |
| universe u | |
| theorem restrict {D N f Q : ZFSet.{u}} (h : InjectionCode D N f) (subset : Q ⊆ D) : | |
| InjectionCode Q N (ZFSet.sep (fun z => z ∈ ZFSet.prod Q N) f) := by | |
| refine ⟨⟨fun _ hz => (ZFSet.mem_sep.1 hz).2, ?_⟩, ?_⟩ | |
| · intro x hx | |
| obtain ⟨y, rel, unique⟩ := h.function.2 x (subset hx) | |
| have hy := (ZFSet.pair_mem_prod.1 (h.function.1 rel)).2 | |
| exact ⟨y, ZFSet.mem_sep.2 ⟨rel, ZFSet.pair_mem_prod.2 ⟨hx, hy⟩⟩, | |
| fun z hz => unique z (ZFSet.mem_sep.1 hz).1⟩ | |
| · intro x y z hx hy | |
| exact h.injective x y z (ZFSet.mem_sep.1 hx).1 (ZFSet.mem_sep.1 hy).1 | |
| end PartitionPilot.Forcing.InjectionCode | |
| namespace PartitionPilot.Forcing.TransitiveGround | |
| open SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| theorem injection_restriction_mem (separation : SeparationSchema M.sets) | |
| {Q N f : ZFSet.{u}} (hQ : Q ∈ M.sets) (hN : N ∈ M.sets) (hf : f ∈ M.sets) : | |
| ZFSet.sep (fun z => z ∈ ZFSet.prod Q N) f ∈ M.sets := by | |
| let params := extend Q (extend N Fin.elim0) | |
| have selected := M.separation_mem separation (BoundedFormula.productElementFormula 0 1 2).toFormula | |
| params (Fin.cases hQ (Fin.cases hN (fun j => Fin.elim0 j))) hf | |
| have eq : ZFSet.sep (fun z => Realize M.sets | |
| (BoundedFormula.productElementFormula 0 1 2).toFormula (extend z params)) f = | |
| ZFSet.sep (fun z => z ∈ ZFSet.prod Q N) f := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, ZFSet.mem_sep] | |
| constructor | |
| · rintro ⟨hz, rel⟩ | |
| exact ⟨hz, (BoundedFormula.truth_productElementFormula 0 1 2 _).1 | |
| ((BoundedFormula.realize_toFormula M _ _ (Fin.cases (M.transitive hf hz) | |
| (Fin.cases hQ (Fin.cases hN (fun j => Fin.elim0 j))))).1 rel)⟩ | |
| · rintro ⟨hz, rel⟩ | |
| exact ⟨hz, (BoundedFormula.realize_toFormula M _ _ (Fin.cases (M.transitive hf hz) | |
| (Fin.cases hQ (Fin.cases hN (fun j => Fin.elim0 j))))).2 | |
| ((BoundedFormula.truth_productElementFormula 0 1 2 _).2 rel)⟩ | |
| exact eq ▸ selected | |
| theorem groundEmbeddable_restrict (separation : SeparationSchema M.sets) | |
| {D Q N : ZFSet.{u}} (hQ : Q ∈ M.sets) (hN : N ∈ M.sets) (subset : Q ⊆ D) | |
| (small : M.groundEmbeddable D N) : M.groundEmbeddable Q N := by | |
| obtain ⟨f, hf, code⟩ := small | |
| exact ⟨ZFSet.sep (fun z => z ∈ ZFSet.prod Q N) f, | |
| M.injection_restriction_mem separation hQ hN hf, code.restrict subset⟩ | |
| theorem smallPartialFunctions_restrict (separation : SeparationSchema M.sets) | |
| {X Y N p q : ZFSet.{u}} (hp : p ∈ M.smallPartialFunctions X Y N) | |
| (hq : q ∈ M.sets) (hN : N ∈ M.sets) (subset : q ⊆ p) : q ∈ M.smallPartialFunctions X Y N := by | |
| obtain ⟨_, code, small⟩ := (M.mem_smallPartialFunctions X Y N p).1 hp | |
| exact (M.mem_smallPartialFunctions X Y N q).2 | |
| ⟨hq, code.mono subset, M.groundEmbeddable_restrict separation hq hN subset small⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end | |
| end OAI | |