Download data/lean/OAI/SetTheory/PartitionPrinciple/Geometry/GroundAssignmentRequestBatches.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 14.7 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Geometry/GroundAssignmentRequestBatches.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/SetTheory/PartitionPrinciple/Geometry/GroundAssignmentRequestBatches.lean
-
curl -L -o GroundAssignmentRequestBatches.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Geometry/GroundAssignmentRequestBatches.lean
14.7 kB
| 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 | |