openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /GroundAssignmentRequestBatches.lean
| import OAI.SetTheory.PartitionPrinciple.Definability.RefinementDataHistoryEntryFormulas | |
| namespace OAI | |
| namespace PartitionPilot.Forcing.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) | |
| private noncomputable def storedClassFormula (side : Fin 2) : SetFormula 4 := | |
| let w := prefixIndex 4 15 | |
| let old := suffixIndex 4 15 | |
| exBlock 15 (.ex (.conj | |
| (BoundedFormula.nonemptyTupleFormula 14 0 (fun j => (w j).succ)).toFormula | |
| (.conj (BoundedFormula.pairMembershipFormula (old 0).succ 0 (old 2).succ).toFormula | |
| (reindex (extend (old 1).succ (extend (old 3).succ (fun j => (w j).succ))) | |
| (M.definable_storedAssignmentClassGraph pairing unions powers separation side).formula)))) | |
| private theorem realize_storedClassFormula (side : Fin 2) | |
| (env : Fin 4 → ZFSet.{u}) (members : ∀ j, env j ∈ M.sets) : | |
| Realize M.sets (storedClassFormula M pairing unions powers separation side) env ↔ | |
| ∃ d : Fin 15 → ZFSet.{u}, (∀ j, d j ∈ M.sets) ∧ | |
| ZFSet.pair (env 0) (refinementFormulaDataCode d) ∈ env 2 ∧ | |
| env 1 = M.storedAssignmentClassGraph (env 3) d side := by | |
| unfold storedClassFormula | |
| rw [realize_exBlock] | |
| apply exists_congr | |
| intro d | |
| apply and_congr_right | |
| intro ground | |
| have args (code : ZFSet.{u}) : | |
| (fun j => extend code (extendMany 15 d env) | |
| (extend (suffixIndex 4 15 1).succ | |
| (extend (suffixIndex 4 15 3).succ (fun j => (prefixIndex 4 15 j).succ)) j)) = | |
| extend (env 1) (extend (env 3) d) := by | |
| rw [map_extend, map_extend] | |
| simp only [extend, Fin.cases_succ, extendMany_suffix, extendMany_prefix] | |
| simp only [realize_ex] | |
| constructor | |
| · rintro ⟨code, hc, tuple, stored, output⟩ | |
| have all : ∀ j, (extend code (extendMany 15 d env)) j ∈ M.sets := | |
| Fin.cases hc (extendMany_members 15 d env ground members) | |
| have eqCode := (BoundedFormula.truth_nonemptyTupleFormula 14 0 | |
| (fun j => (prefixIndex 4 15 j).succ) _).1 | |
| ((BoundedFormula.realize_toFormula M _ _ all).1 tuple) | |
| change code = refinementFormulaDataCode d at eqCode | |
| have edge := (BoundedFormula.truth_pairMembershipFormula | |
| (suffixIndex 4 15 0).succ 0 (suffixIndex 4 15 2).succ _).1 | |
| ((BoundedFormula.realize_toFormula M _ _ all).1 stored) | |
| change ZFSet.pair (env 0) code ∈ env 2 at edge | |
| rw [realize_reindex, args] at output | |
| have value := ((M.definable_storedAssignmentClassGraph pairing unions powers separation side).correct | |
| (extend (env 3) d) (Fin.cases (members 3) ground) (env 1) (members 1)).1 output | |
| exact ⟨eqCode ▸ edge, value⟩ | |
| · rintro ⟨edge, value⟩ | |
| let code := refinementFormulaDataCode d | |
| have hc := M.refinementFormulaDataCode_mem pairing d ground | |
| have all : ∀ j, (extend code (extendMany 15 d env)) j ∈ M.sets := | |
| Fin.cases hc (extendMany_members 15 d env ground members) | |
| refine ⟨code, hc, ?_, ?_, ?_⟩ | |
| · apply (BoundedFormula.realize_toFormula M _ _ all).2 | |
| exact (BoundedFormula.truth_nonemptyTupleFormula 14 0 | |
| (fun j => (prefixIndex 4 15 j).succ) _).2 rfl | |
| · apply (BoundedFormula.realize_toFormula M _ _ all).2 | |
| exact (BoundedFormula.truth_pairMembershipFormula | |
| (suffixIndex 4 15 0).succ 0 (suffixIndex 4 15 2).succ _).2 edge | |
| · rw [realize_reindex, args] | |
| exact ((M.definable_storedAssignmentClassGraph pairing unions powers separation side).correct | |
| (extend (env 3) d) (Fin.cases (members 3) ground) (env 1) (members 1)).2 value | |
| include pairing unions powers separation in | |
| theorem exists_storedAssignmentClassFamily | |
| (collection : CollectionSchema M.sets) (side : Fin 2) | |
| {levels stages history A T : ZFSet.{u}} | |
| (hLevels : levels ∈ M.sets) (hHistory : history ∈ M.sets) (hA : A ∈ M.sets) | |
| (inside : levels ⊆ stages) (valid : RefinementDataHistory stages history T) : | |
| ∃ graph ∈ M.sets, FunctionGraphOn levels graph ∧ | |
| ∀ alpha (d : Fin 15 → ZFSet.{u}), | |
| ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history → | |
| ∀ y, ZFSet.pair alpha y ∈ graph ↔ | |
| alpha ∈ levels ∧ y = M.storedAssignmentClassGraph A d side := by | |
| let params : Fin 2 → ZFSet.{u} := ![history, A] | |
| have members : ∀ j, params j ∈ M.sets := Fin.cases hHistory (Fin.cases hA (fun j => Fin.elim0 j)) | |
| let formula := storedClassFormula M pairing unions powers separation side | |
| have meaning (alpha y : ZFSet.{u}) (ha : alpha ∈ M.sets) (hy : y ∈ M.sets) := | |
| realize_storedClassFormula M pairing unions powers separation side | |
| (extend alpha (extend y params)) (Fin.cases ha (Fin.cases hy members)) | |
| have unique (alpha y z : ZFSet.{u}) (ha : alpha ∈ M.sets) (hy : y ∈ M.sets) (hz : z ∈ M.sets) | |
| (first : Realize M.sets formula (extend alpha (extend y params))) | |
| (second : Realize M.sets formula (extend alpha (extend z params))) : y = z := by | |
| obtain ⟨d, _, de, dy⟩ := (meaning alpha y ha hy).1 first | |
| obtain ⟨e, _, ee, ez⟩ := (meaning alpha z ha hz).1 second | |
| have same := refinementFormulaDataCode_injective (valid.function.unique de ee) | |
| exact dy.trans (same ▸ ez.symm) | |
| obtain ⟨B, hB, bounded⟩ := M.collection_witness collection formula params members hLevels (by | |
| intro alpha ha | |
| obtain ⟨code, entry⟩ := valid.function.total (inside ha) | |
| obtain ⟨d, rfl⟩ := valid.decoded alpha code entry | |
| have fields := M.refinementFormulaDataCode_fields_mem _ (M.pair_right (M.transitive hHistory entry)) | |
| have output := (M.definable_storedAssignmentClassGraph pairing unions powers separation side).closed | |
| (extend A d) (Fin.cases hA fields) | |
| exact ⟨_, output, (meaning alpha _ (M.transitive hLevels ha) output).2 ⟨d, fields, entry, rfl⟩⟩) | |
| let graph := M.definableRelation formula params levels B | |
| have hGraph := M.definableRelation_mem pairing unions powers separation formula params members hLevels hB | |
| refine ⟨graph, hGraph, ⟨B, fun _ h => (ZFSet.mem_sep.1 h).1, ?_⟩, ?_⟩ | |
| · intro alpha ha | |
| obtain ⟨y, hy, rel⟩ := bounded alpha ha | |
| refine ⟨y, (M.pair_mem_definableRelation formula params levels B alpha y).2 ⟨ha, hy, rel⟩, ?_⟩ | |
| intro z hz | |
| obtain ⟨_, hz, rz⟩ := (M.pair_mem_definableRelation formula params levels B alpha z).1 hz | |
| exact unique alpha z y (M.transitive hLevels ha) (M.transitive hB hz) (M.transitive hB hy) rz rel | |
| · intro alpha d entry y | |
| rw [M.pair_mem_definableRelation] | |
| constructor | |
| · rintro ⟨ha, hy, rel⟩ | |
| obtain ⟨e, _, ee, ey⟩ := (meaning alpha y (M.transitive hLevels ha) (M.transitive hB hy)).1 rel | |
| have same := refinementFormulaDataCode_injective (valid.function.unique ee entry) | |
| exact ⟨ha, same ▸ ey⟩ | |
| · rintro ⟨ha, rfl⟩ | |
| obtain ⟨z, hz, rel⟩ := bounded alpha ha | |
| obtain ⟨e, _, ee, ez⟩ := (meaning alpha z (M.transitive hLevels ha) (M.transitive hB hz)).1 rel | |
| have same := refinementFormulaDataCode_injective (valid.function.unique ee entry) | |
| have eq : z = M.storedAssignmentClassGraph A d side := same ▸ ez | |
| exact eq ▸ ⟨ha, hz, rel⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| namespace PartitionPilot.Forcing.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) | |
| variable (collection : CollectionSchema M.sets) | |
| variable (infinite : Realize M.sets infinity Fin.elim0) | |
| variable (choice : Realize M.sets SetFormula.choice Fin.elim0) | |
| include pairing unions powers separation collection infinite choice | |
| open scoped ZFSet | |
| theorem exists_assignmentRequestBatch {stages history T A : ZFSet.{u}} | |
| (hStages : stages ∈ M.sets) (hHistory : history ∈ M.sets) (hT : T ∈ M.sets) | |
| (hA : A ∈ M.sets) (smallA : M.groundEmbeddable A ZFSet.omega) | |
| (valid : RefinementDataHistory stages history T) | |
| (shape : A ⊆ stageOneAssignments (refinementDataHistoryIndices stages history) T) | |
| (localFunctions : ∀ alpha (d : Fin 15 → ZFSet.{u}), | |
| ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history → | |
| ∀ side, FunctionGraphOn (assignmentOnIndices (d 0) T A) | |
| (M.storedAssignmentClassGraph A d side)) : | |
| let levels := relationImage A stages (refinementDataHistoryLevels stages history T) | |
| levels ∈ M.sets ∧ M.groundEmbeddable levels ZFSet.omega ∧ levels ⊆ stages ∧ | |
| ∃ families : Fin 2 → ZFSet.{u}, | |
| (∀ side, families side ∈ M.sets ∧ FunctionGraphOn levels (families side)) ∧ | |
| (∀ side alpha (d : Fin 15 → ZFSet.{u}), | |
| ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history → | |
| ∀ graph, ZFSet.pair alpha graph ∈ families side ↔ | |
| alpha ∈ levels ∧ graph = M.storedAssignmentClassGraph A d side) ∧ | |
| let flat := fun side => ⋃₀ functionGraphRange levels (families side) | |
| let requests := fun side => functionGraphRange A (flat side) | |
| (∀ side, flat side ∈ M.sets ∧ FunctionGraphOn A (flat side)) ∧ | |
| (requests 0 ∪ requests 1) ∈ M.sets ∧ | |
| M.groundEmbeddable (requests 0 ∪ requests 1) ZFSet.omega := by | |
| let levels := relationImage A stages (refinementDataHistoryLevels stages history T) | |
| have hOmega := M.omega_mem separation infinite | |
| have hLevelGraph := M.refinementDataHistoryLevels_mem pairing unions powers separation hStages hHistory hT | |
| have hLevels := M.relationImage_mem separation hA hStages hLevelGraph | |
| have smallLevels := M.groundEmbeddable_function_image pairing unions powers separation choice | |
| hA hStages hOmega hLevelGraph valid.levels_function smallA | |
| have inside : levels ⊆ stages := fun _ h => (mem_relationImage _ _ _ _).1 h |>.1 | |
| have family (side : Fin 2) := M.exists_storedAssignmentClassFamily pairing unions powers separation | |
| collection side hLevels hHistory hA inside valid | |
| choose families ground functions entries using family | |
| let flat := fun side => ⋃₀ functionGraphRange levels (families side) | |
| have flatEntry (side : Fin 2) (z : ZFSet.{u}) : z ∈ flat side ↔ | |
| ∃ alpha ∈ levels, ∃ d : Fin 15 → ZFSet.{u}, | |
| ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history ∧ | |
| z ∈ M.storedAssignmentClassGraph A d side := by | |
| rw [ZFSet.mem_sUnion] | |
| constructor | |
| · rintro ⟨g, hg, hz⟩ | |
| obtain ⟨alpha, ha, stored⟩ := (mem_functionGraphRange levels (families side) g).1 hg | |
| obtain ⟨code, entry⟩ := valid.function.total (inside ha) | |
| obtain ⟨d, rfl⟩ := valid.decoded alpha code entry | |
| exact ⟨alpha, ha, d, entry, ((entries side alpha d entry g).1 stored).2 ▸ hz⟩ | |
| · rintro ⟨alpha, ha, d, entry, hz⟩ | |
| exact ⟨_, (mem_functionGraphRange levels (families side) _).2 | |
| ⟨alpha, ha, (entries side alpha d entry _).2 ⟨ha, rfl⟩⟩, hz⟩ | |
| have levelOf {alpha : ZFSet.{u}} {d : Fin 15 → ZFSet.{u}} | |
| (entry : ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history) | |
| {x : ZFSet.{u}} (hx : x ∈ assignmentOnIndices (d 0) T A) : | |
| ZFSet.pair x alpha ∈ refinementDataHistoryLevels stages history T := by | |
| obtain ⟨i, hi, u, hu, w, hw, rfl⟩ := (mem_stageOneAssignments _ _ _).1 | |
| ((mem_assignmentOnIndices _ _ _ _).1 hx).2 | |
| have terms := valid.terms alpha d entry | |
| exact valid.coverage alpha (valid.function.pair_source entry) d entry i hi u | |
| (terms.symm ▸ hu) w (terms.symm ▸ hw) | |
| have cover (x : ZFSet.{u}) (hx : x ∈ A) : | |
| ∃ alpha ∈ levels, ∃ d : Fin 15 → ZFSet.{u}, | |
| ZFSet.pair alpha (refinementFormulaDataCode d) ∈ history ∧ | |
| x ∈ assignmentOnIndices (d 0) T A := by | |
| obtain ⟨i, hi, u, hu, w, hw, rfl⟩ := (mem_stageOneAssignments _ _ _).1 (shape hx) | |
| obtain ⟨alpha, ha, d, entry, idx⟩ := (mem_refinementDataHistoryIndices _ _ _).1 hi | |
| have selected := (mem_assignmentOnIndices (d 0) T A _).2 | |
| ⟨hx, (stageOneAssignment_mem_assignments _ _ _ _ _).2 ⟨idx, hu, hw⟩⟩ | |
| exact ⟨alpha, (mem_relationImage _ _ _ _).2 ⟨ha, _, hx, levelOf entry selected⟩, | |
| d, entry, selected⟩ | |
| have flatGround (side : Fin 2) : flat side ∈ M.sets := | |
| M.union_mem unions (M.functionGraphRange_mem unions separation hLevels (ground side)) | |
| have flatFunction (side : Fin 2) : FunctionGraphOn A (flat side) := by | |
| refine ⟨⋃₀ ⋃₀ flat side, ?_, ?_⟩ | |
| · intro z hz | |
| obtain ⟨alpha, _, d, entry, member⟩ := (flatEntry side z).1 hz | |
| obtain ⟨x, hx, y, rfl⟩ := (localFunctions alpha d entry side).shape z member | |
| exact ZFSet.pair_mem_prod.2 | |
| ⟨((mem_assignmentOnIndices _ _ _ _).1 hx).1, pair_second_mem_doubleUnion hz⟩ | |
| · intro x hx | |
| obtain ⟨alpha, ha, d, entry, selected⟩ := cover x hx | |
| obtain ⟨y, hy⟩ := (localFunctions alpha d entry side).total selected | |
| refine ⟨y, (flatEntry side _).2 ⟨alpha, ha, d, entry, hy⟩, ?_⟩ | |
| intro z hz | |
| obtain ⟨beta, _, e, ee, ez⟩ := (flatEntry side _).1 hz | |
| have betaSelected := (localFunctions beta e ee side).pair_source ez | |
| have sameLevel := (functionCode_partial valid.levels_function).unique x beta alpha | |
| (levelOf ee betaSelected) (levelOf entry selected) | |
| subst beta | |
| have same := refinementFormulaDataCode_injective (valid.function.unique ee entry) | |
| subst e | |
| exact (localFunctions alpha d entry side).unique ez hy | |
| let requests := fun side => functionGraphRange A (flat side) | |
| have requestGround (side : Fin 2) : requests side ∈ M.sets := | |
| M.functionGraphRange_mem unions separation hA (flatGround side) | |
| have requestSmall (side : Fin 2) : M.groundEmbeddable (requests side) ZFSet.omega := | |
| M.groundEmbeddable_function_image pairing unions powers separation choice hA | |
| (M.union_mem unions (M.union_mem unions (flatGround side))) hOmega (flatGround side) | |
| (flatFunction side).to_isFunc smallA | |
| exact ⟨hLevels, smallLevels, inside, families, fun side => ⟨ground side, functions side⟩, | |
| entries, fun side => ⟨flatGround side, flatFunction side⟩, | |
| M.binary_union_mem pairing unions (requestGround 0) (requestGround 1), | |
| M.groundCountable_binary_union pairing unions powers separation infinite choice | |
| (requestGround 0) (requestGround 1) (requestSmall 0) (requestSmall 1)⟩ | |
| end PartitionPilot.Forcing.TransitiveGround | |
| end OAI | |