openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /GroundAssignmentRepresentativeClosure.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.AssignmentQueryFormulas | |
| import OAI.SetTheory.PartitionPrinciple.Transfinite.GroundStructuralFullIndexSize | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| section | |
| universe u | |
| theorem assignmentOnIndices_indices_on {I T X A : ZFSet.{u}} | |
| (shape : A ⊆ stageOneAssignments I T) : | |
| assignmentOnIndices (assignmentIndices I T (assignmentOnIndices X T A)) T A = | |
| assignmentOnIndices X T A := by | |
| apply ZFSet.ext | |
| intro z | |
| constructor | |
| · intro member | |
| obtain ⟨hA, inside⟩ := (mem_assignmentOnIndices _ T A z).1 member | |
| obtain ⟨t, ht, v, hv, w, hw, rfl⟩ := (mem_stageOneAssignments _ T z).1 inside | |
| rw [assignmentIndices_on] at ht | |
| exact (assignmentOnIndices_entry X T A t v w).2 | |
| ⟨hA, (ZFSet.mem_inter.1 ht).2, hv, hw⟩ | |
| · intro member | |
| have hA := ((mem_assignmentOnIndices X T A z).1 member).1 | |
| obtain ⟨t, ht, v, hv, w, hw, rfl⟩ := (mem_stageOneAssignments I T z).1 (shape hA) | |
| exact (assignmentOnIndices_entry _ T A t v w).2 | |
| ⟨hA, (mem_assignmentIndices I T (assignmentOnIndices X T A) t).2 | |
| ⟨ht, v, hv, w, hw, member⟩, hv, hw⟩ | |
| end | |
| namespace TransitiveGround | |
| open SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| variable (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| variable (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| variable (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| include pairing unions powers separation | |
| theorem assignmentQueryRelation_mem {I T C D : ZFSet.{u}} | |
| (hI : I ∈ M.sets) (hT : T ∈ M.sets) (hC : C ∈ M.sets) (hD : D ∈ M.sets) : | |
| assignmentQueryRelation I T C D ∈ M.sets := by | |
| let f := productFirst I (ZFSet.prod T T) | |
| have hf : f ∈ M.sets := M.productFirst_mem pairing unions powers separation hI | |
| (M.prod_mem pairing unions powers separation hT hT) | |
| let params := extend I (extend f Fin.elim0) | |
| have selected := M.bounded_separation_mem separation | |
| (BoundedFormula.assignmentQueryRelationFormula 0 1 2) params | |
| (Fin.cases hI (Fin.cases hf (fun j => Fin.elim0 j))) | |
| (M.prod_mem pairing unions powers separation hC hD) | |
| have equal : ZFSet.sep (fun z => BoundedFormula.Truth | |
| (BoundedFormula.assignmentQueryRelationFormula 0 1 2) (extend z params)) | |
| (ZFSet.prod C D) = assignmentQueryRelation I T C D := by | |
| apply ZFSet.ext | |
| intro z | |
| rw [ZFSet.mem_sep, assignmentQueryRelation, ZFSet.mem_sep] | |
| exact and_congr Iff.rfl (BoundedFormula.truth_assignmentQueryRelationFormula 0 1 2 | |
| (extend z params) T rfl) | |
| exact equal ▸ selected | |
| theorem realizedAssignmentQueries_mem {I T C D : ZFSet.{u}} | |
| (hI : I ∈ M.sets) (hT : T ∈ M.sets) (hC : C ∈ M.sets) (hD : D ∈ M.sets) : | |
| realizedAssignmentQueries I T C D ∈ M.sets := | |
| M.relationImage_mem separation hD hC (M.relationConverse_mem pairing unions powers separation | |
| hC hD (M.assignmentQueryRelation_mem pairing unions powers separation hI hT hC hD)) | |
| theorem exists_assignmentQuerySelector | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| {I T C D : ZFSet.{u}} (hI : I ∈ M.sets) (hT : T ∈ M.sets) | |
| (hC : C ∈ M.sets) (hD : D ∈ M.sets) : | |
| ∃ F ∈ M.sets, ZFSet.IsFunc (realizedAssignmentQueries I T C D) D F ∧ | |
| F ⊆ assignmentQueryRelation I T C D := by | |
| apply M.uniformize_relation pairing unions powers separation choice | |
| (M.realizedAssignmentQueries_mem pairing unions powers separation hI hT hC hD) hD | |
| (M.assignmentQueryRelation_mem pairing unions powers separation hI hT hC hD) | |
| intro q member | |
| exact ((mem_realizedAssignmentQueries I T C D q).1 member).2 | |
| theorem exists_stageOneAssignmentQuerySelector | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| {rows I T D : ZFSet.{u}} (hRows : rows ∈ M.sets) (hI : I ∈ M.sets) | |
| (hT : T ∈ M.sets) (omega : ZFSet.omega ∈ M.sets) (hD : D ∈ M.sets) : | |
| ∃ F ∈ M.sets, | |
| ZFSet.IsFunc (realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D) D F ∧ | |
| F ⊆ assignmentQueryRelation I T (M.stageOneCandidateBound rows I T) D := | |
| M.exists_assignmentQuerySelector pairing unions powers separation choice hI hT | |
| (M.stageOneCandidateBound_mem pairing unions powers separation hRows hI hT omega) hD | |
| end TransitiveGround | |
| namespace TransitiveGround | |
| open SetFormula | |
| universe u | |
| variable (M : TransitiveGround.{u}) | |
| theorem exists_groundOmegaOneClosure | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| {I K : ZFSet.{u}} (hK : K ∈ M.sets) (conditions : GroundInaccessibleConditions M K) | |
| {n : Nat} {f : (Fin (n + 1) → ZFSet.{u}) → ZFSet.{u}} | |
| (defined : GroundDefinableFunction M f) (params : Fin n → ZFSet.{u}) | |
| (members : ∀ j, params j ∈ M.sets) | |
| (inflationary : ∀ X ∈ M.sets, X ⊆ I → X ⊆ f (extend X params)) | |
| (preserves : ∀ X ∈ M.sets, X ⊆ I → GroundBelow M X K → | |
| f (extend X params) ⊆ I ∧ GroundBelow M (f (extend X params)) K) : | |
| let C := M.groundOmegaOne pairing unions powers separation collection infinite | |
| ∃ history ∈ M.sets, | |
| OrdinalRecursionTrace (fun alpha prior output => | |
| output = f (extend (refinementHistoryIndices alpha prior) params)) C history ∧ | |
| let X := refinementHistoryIndices C history | |
| X ∈ M.sets ∧ X ⊆ I ∧ GroundBelow M X K ∧ | |
| (∀ alpha Y, ZFSet.pair alpha Y ∈ history → | |
| Y ∈ M.sets ∧ Y ⊆ I ∧ GroundBelow M Y K) ∧ | |
| (∀ alpha beta Y Z, ZFSet.pair alpha Y ∈ history → | |
| ZFSet.pair beta Z ∈ history → alpha ∈ beta → Y ⊆ Z) ∧ | |
| ∀ B ∈ M.sets, M.groundEmbeddable B ZFSet.omega → B ⊆ X → | |
| ∃ beta ∈ C, | |
| let U := refinementHistoryIndices beta history | |
| U ∈ M.sets ∧ U ⊆ X ∧ GroundBelow M U K ∧ B ⊆ U ∧ f (extend U params) ⊆ X := by | |
| let C := M.groundOmegaOne pairing unions powers separation collection infinite | |
| have spec := M.groundOmegaOne_spec pairing unions powers separation collection infinite | |
| have hC := spec.1 | |
| obtain ⟨history, hh, trace⟩ := M.exists_historyUnionTrace pairing unions separation collection | |
| defined params members hC spec.2.1 | |
| have bounds := M.historyUnionTrace_below pairing unions powers separation choice hK conditions | |
| (fun X => f (extend X params)) preserves C | |
| (conditions.groundOmegaOne_mem pairing unions powers separation collection infinite hK) history hh trace | |
| let X := refinementHistoryIndices C history | |
| have hX : X ∈ M.sets := M.refinementHistoryIndices_mem unions separation hC hh | |
| have step (beta Y : ZFSet.{u}) (entry : ZFSet.pair beta Y ∈ history) : | |
| Y = f (extend (refinementHistoryIndices beta history) params) := by | |
| have result := trace.2 beta (trace.1.pair_source entry) Y entry | |
| change Y = f (extend (refinementHistoryIndices beta (graphRestriction beta history)) params) at result | |
| rw [refinementHistoryIndices_restrict (fun _ hx => hx)] at result | |
| exact result | |
| have earlierUnion (beta : ZFSet.{u}) (member : beta ∈ C) : | |
| refinementHistoryIndices beta history ∈ M.sets ∧ | |
| refinementHistoryIndices beta history ⊆ X ∧ | |
| GroundBelow M (refinementHistoryIndices beta history) K := by | |
| have ground := M.refinementHistoryIndices_mem unions separation (M.transitive hC member) hh | |
| have subset := refinementHistoryIndices_mono (history := history) (spec.2.1.1 beta member) | |
| exact ⟨ground, subset, bounds.2.2.restrict separation ground hK subset⟩ | |
| refine ⟨history, hh, trace, hX, bounds.2.1, bounds.2.2, ?_, ?_, ?_⟩ | |
| · intro alpha Y entry | |
| exact ⟨M.transitive (M.union_mem unions (M.union_mem unions hh)) | |
| (pair_second_mem_doubleUnion entry), bounds.1 alpha Y entry⟩ | |
| · intro alpha beta Y Z first second before x inside | |
| have earlier := earlierUnion beta (trace.1.pair_source second) | |
| rw [step beta Z second] | |
| exact inflationary _ earlier.1 (fun _ hx => bounds.2.1 (earlier.2.1 hx)) | |
| ((mem_refinementHistoryIndices beta history x).2 ⟨alpha, before, Y, first, inside⟩) | |
| · intro B hB small subset | |
| obtain ⟨beta, member, captured⟩ := M.historyUnion_countable_capture | |
| pairing unions powers separation collection infinite choice hh hB small subset | |
| have earlier := earlierUnion beta member | |
| refine ⟨beta, member, earlier.1, earlier.2.1, earlier.2.2, captured, ?_⟩ | |
| obtain ⟨Y, entry⟩ := trace.1.total member | |
| rw [← step beta Y entry] | |
| intro x inside | |
| exact (mem_refinementHistoryIndices C history x).2 ⟨beta, member, Y, entry, inside⟩ | |
| theorem assignmentQueryClosure_representatives | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| {rows I T D c X : ZFSet.{u}} (hI : I ∈ M.sets) (hT : T ∈ M.sets) | |
| (omega : ZFSet.omega ∈ M.sets) (hX : X ∈ M.sets) | |
| (shape : D ⊆ M.stageOneCandidateBound rows I T) | |
| (selector : ZFSet.IsFunc | |
| (realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D) D c) | |
| (selected : c ⊆ assignmentQueryRelation I T (M.stageOneCandidateBound rows I T) D) | |
| (capture : ∀ B ∈ M.sets, M.groundEmbeddable B ZFSet.omega → B ⊆ X → | |
| ∃ U, B ⊆ U ∧ representativeIndexStep I T | |
| (realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D) c U ⊆ X) : | |
| ∀ row A, ZFSet.pair row A ∈ D → | |
| ∃ C, ZFSet.pair row C ∈ D ∧ assignmentIndices I T C ⊆ X ∧ | |
| assignmentOnIndices (assignmentIndices I T (assignmentOnIndices X T A)) T C = | |
| assignmentOnIndices X T A := by | |
| intro row A member | |
| let L := assignmentOnIndices X T A | |
| let B := assignmentIndices I T L | |
| let Q := realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D | |
| have data := (M.pair_mem_stageOneCandidateBound rows I T row A).1 (shape member) | |
| have hL : L ∈ M.sets := M.assignmentOnIndices_mem pairing unions powers separation hX hT data.2.1 | |
| have smallL := M.assignmentOnIndices_small pairing unions powers separation hX hT data.2.1 | |
| omega data.2.2.2 | |
| have listShape : L ⊆ stageOneAssignments I T := | |
| fun _ h => data.2.2.1 ((mem_assignmentOnIndices X T A _).1 h).1 | |
| have queryCandidate : ZFSet.pair row L ∈ M.stageOneCandidateBound rows I T := | |
| (M.pair_mem_stageOneCandidateBound rows I T row L).2 ⟨data.1, hL, listShape, smallL⟩ | |
| have query : ZFSet.pair row L ∈ Q := | |
| (mem_realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D _).2 | |
| ⟨queryCandidate, ZFSet.pair row A, member, | |
| (assignmentQueryRelation_entry I T (M.stageOneCandidateBound rows I T) D row L row A).2 | |
| ⟨queryCandidate, member, rfl, assignmentOnIndices_indices_on data.2.2.1⟩⟩ | |
| have hB : B ∈ M.sets := M.assignmentIndices_mem pairing unions powers separation hI hT hL | |
| have smallB := M.assignmentIndices_small pairing unions powers separation choice hI hT hL omega smallL | |
| have subsetB : B ⊆ X := by | |
| intro i hi | |
| change i ∈ assignmentIndices I T (assignmentOnIndices X T A) at hi | |
| rw [assignmentIndices_on] at hi | |
| exact (ZFSet.mem_inter.1 hi).2 | |
| obtain ⟨U, captured, closed⟩ := capture B hB smallB subsetB | |
| obtain ⟨p, entry, _⟩ := selector.2 (ZFSet.pair row L) query | |
| have inD := (ZFSet.pair_mem_prod.1 (selector.1 entry)).2 | |
| obtain ⟨other, _, C, _, _, _, rfl⟩ := | |
| (M.mem_stageOneCandidateBound rows I T p).1 (shape inD) | |
| have matched := (assignmentQueryRelation_entry I T (M.stageOneCandidateBound rows I T) D | |
| row L other C).1 (selected entry) | |
| obtain rfl := matched.2.2.1 | |
| refine ⟨C, inD, ?_, matched.2.2.2⟩ | |
| have localQuery : AssignmentQueryWithin U T (ZFSet.pair row L) := | |
| ⟨row, L, rfl, (assignment_subset_iff_indices_subset listShape).2 captured⟩ | |
| exact fun _ h => closed (representativeIndexStep_covers query localQuery entry h) | |
| theorem exists_assignmentRepresentativeClosure | |
| (pairing : Realize M.sets SetFormula.pairing Fin.elim0) | |
| (unions : Realize M.sets SetFormula.union Fin.elim0) | |
| (powers : Realize M.sets powerSet Fin.elim0) (separation : SeparationSchema M.sets) | |
| (collection : CollectionSchema M.sets) (infinite : Realize M.sets infinity Fin.elim0) | |
| (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| {rows I T D K : ZFSet.{u}} (hRows : rows ∈ M.sets) (hI : I ∈ M.sets) | |
| (hT : T ∈ M.sets) (hD : D ∈ M.sets) (hK : K ∈ M.sets) | |
| (conditions : GroundInaccessibleConditions M K) | |
| (smallRows : GroundBelow M rows K) (smallT : GroundBelow M T K) | |
| (shape : D ⊆ M.stageOneCandidateBound rows I T) : | |
| ∃ X ∈ M.sets, X ⊆ I ∧ GroundBelow M X K ∧ | |
| ∀ row A, ZFSet.pair row A ∈ D → | |
| ∃ C, ZFSet.pair row C ∈ D ∧ assignmentIndices I T C ⊆ X ∧ | |
| assignmentOnIndices (assignmentIndices I T (assignmentOnIndices X T A)) T C = | |
| assignmentOnIndices X T A := by | |
| have omega := M.omega_mem separation infinite | |
| let Q := realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D | |
| have hQ : Q ∈ M.sets := M.realizedAssignmentQueries_mem pairing unions powers separation hI hT | |
| (M.stageOneCandidateBound_mem pairing unions powers separation hRows hI hT omega) hD | |
| have queries : Q ⊆ M.stageOneCandidateBound rows I T := | |
| fun _ h => ((mem_realizedAssignmentQueries I T (M.stageOneCandidateBound rows I T) D _).1 h).1 | |
| obtain ⟨c, hc, selector, selected⟩ := M.exists_stageOneAssignmentQuerySelector | |
| pairing unions powers separation choice hRows hI hT omega hD | |
| let params : Fin 4 → ZFSet.{u} := extend I (extend T (extend Q (extend c Fin.elim0))) | |
| have members : ∀ j, params j ∈ M.sets := | |
| Fin.cases hI (Fin.cases hT (Fin.cases hQ (Fin.cases hc (fun j => Fin.elim0 j)))) | |
| have inflationary : ∀ X ∈ M.sets, X ⊆ I → | |
| X ⊆ representativeIndexStep I T Q c X := | |
| fun X _ _ => representativeIndexStep_contains I T Q c X | |
| have preserves : ∀ X ∈ M.sets, X ⊆ I → GroundBelow M X K → | |
| representativeIndexStep I T Q c X ⊆ I ∧ | |
| GroundBelow M (representativeIndexStep I T Q c X) K := by | |
| intro X hX subset smallX | |
| exact ⟨representativeIndexStep_subset subset, | |
| M.representativeIndexStep_below pairing unions powers separation infinite choice | |
| hRows hI hT hQ hc hD hX hK conditions selector queries shape smallRows smallT smallX⟩ | |
| obtain ⟨history, _, _, hX, subsetX, smallX, _, _, capture⟩ := | |
| M.exists_groundOmegaOneClosure pairing unions powers separation collection infinite choice | |
| hK conditions (M.definable_representativeIndexStep pairing unions separation) | |
| params members inflationary preserves | |
| refine ⟨_, hX, subsetX, smallX, | |
| M.assignmentQueryClosure_representatives pairing unions powers separation choice | |
| hI hT omega hX shape selector selected ?_⟩ | |
| intro B hB countable subset | |
| obtain ⟨beta, _, _, _, _, bounded, closed⟩ := capture B hB countable subset | |
| exact ⟨refinementHistoryIndices beta history, bounded, closed⟩ | |
| end TransitiveGround | |
| end PartitionPilot.Forcing | |
| end OAI | |