math / data /lean /OAI /SetTheory /PartitionPrinciple /Transfinite /GroundCanonicalCompressionHistory.lean
Download data/lean/OAI/SetTheory/PartitionPrinciple/Transfinite/GroundCanonicalCompressionHistory.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 5.02 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Transfinite/GroundCanonicalCompressionHistory.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/SetTheory/PartitionPrinciple/Transfinite/GroundCanonicalCompressionHistory.lean
-
curl -L -o GroundCanonicalCompressionHistory.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Transfinite/GroundCanonicalCompressionHistory.lean
5.02 kB
| import OAI.SetTheory.PartitionPrinciple.Definability.GroundCompressionHistoryFormulas | |
| namespace OAI | |
| section | |
| namespace PartitionPilot.Forcing | |
| open SetFormula | |
| universe u | |
| namespace RecursiveStateData | |
| variable (initial : RecursiveStateData.{u}) (M : TransitiveGround.{u}) | |
| variable (I Sources Reps G T : ZFSet.{u}) | |
| noncomputable def canonicalHistory : ZFSet.{u} := | |
| familyCodeGraph natSetCode (fun n => (initial.iterate M I Sources Reps G T n).code) | |
| theorem pair_mem_canonicalHistory (n : Nat) (y : ZFSet.{u}) : | |
| ZFSet.pair (natSetCode n) y β initial.canonicalHistory M I Sources Reps G T β | |
| y = (initial.iterate M I Sources Reps G T n).code := | |
| pair_mem_familyCodeGraph _ _ natSetCode_injective n y | |
| theorem canonicalHistory_function : | |
| FunctionGraphOn ZFSet.omega (initial.canonicalHistory M I Sources Reps G T) := by | |
| have domain : ZFSet.range (natSetCode : Nat β ZFSet.{u}) = ZFSet.omega := by | |
| apply ZFSet.ext | |
| intro x | |
| rw [ZFSet.mem_range, mem_omega_iff_natSetCode] | |
| change (β n, natSetCode n = x) β β n, x = natSetCode n | |
| constructor | |
| Β· rintro β¨n, hxβ© | |
| exact β¨n, hx.symmβ© | |
| Β· rintro β¨n, hxβ© | |
| exact β¨n, hx.symmβ© | |
| exact domain βΈ familyCodeGraph_function natSetCode | |
| (fun n => (initial.iterate M I Sources Reps G T n).code) natSetCode_injective | |
| theorem canonicalHistory_eq_of_entries {history : ZFSet.{u}} | |
| (function : FunctionGraphOn ZFSet.omega history) | |
| (entries : β n y, ZFSet.pair (natSetCode n) y β history β | |
| y = (initial.iterate M I Sources Reps G T n).code) : | |
| initial.canonicalHistory M I Sources Reps G T = history := by | |
| apply (initial.canonicalHistory_function M I Sources Reps G T).eq_of_agree function | |
| intro x y z xy xz | |
| obtain β¨n, rflβ© := (mem_omega_iff_natSetCode x).1 | |
| ((initial.canonicalHistory_function M I Sources Reps G T).pair_source xy) | |
| exact ((initial.pair_mem_canonicalHistory M I Sources Reps G T n y).1 xy).trans | |
| ((entries n z).1 xz).symm | |
| end RecursiveStateData | |
| namespace GroundCompressionState | |
| variable {M : TransitiveGround.{u}} | |
| variable {P0 r0 ΞΌ0 A0 Ο I Sources Reps G m inv one T Filters : ZFSet.{u}} | |
| variable {seed : FixedCompressionSeed P0 r0 ΞΌ0 A0 Ο I Sources Reps G m inv one T Filters} | |
| variable (state : GroundCompressionState M seed) | |
| 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 SetFormula.infinity Fin.elim0) | |
| variable (hI : I β M.sets) (hSources : Sources β M.sets) (hReps : Reps β M.sets) | |
| variable (hG : G β M.sets) (hT : T β M.sets) | |
| include pairing unions powers separation collection infinite hI hSources hReps hG hT | |
| theorem canonicalHistory_spec : | |
| let R := groundRecursionStep M | |
| (naturalStepFormula (M.compressionSuccessorFormula pairing unions powers separation)) | |
| (extend state.data.code (extend I (extend Sources (extend Reps (extend G (extend T Fin.elim0)))))) | |
| state.data.canonicalHistory M I Sources Reps G T β M.sets β§ | |
| OrdinalRecursionTrace R ZFSet.omega (state.data.canonicalHistory M I Sources Reps G T) β§ | |
| β history, OrdinalRecursionTrace R ZFSet.omega history β | |
| history = state.data.canonicalHistory M I Sources Reps G T := by | |
| obtain β¨history, ground, trace, entries, unique, _β© := state.exists_groundHistory | |
| pairing unions powers separation collection infinite hI hSources hReps hG hT | |
| have equal := state.data.canonicalHistory_eq_of_entries M I Sources Reps G T trace.1 entries | |
| rw [β equal] at ground trace unique | |
| exact β¨ground, trace, uniqueβ© | |
| theorem canonicalHistory_mem : | |
| state.data.canonicalHistory M I Sources Reps G T β M.sets := | |
| (state.canonicalHistory_spec pairing unions powers separation collection infinite | |
| hI hSources hReps hG hT).1 | |
| theorem realize_compressionHistory_iff {history : ZFSet.{u}} (hHistory : history β M.sets) : | |
| Realize M.sets (M.compressionHistoryFormula pairing unions powers separation) | |
| (extend ZFSet.omega (extend history (extend state.data.code | |
| (extend I (extend Sources (extend Reps (extend G (extend T Fin.elim0)))))))) β | |
| history = state.data.canonicalHistory M I Sources Reps G T := by | |
| have initial : state.data.code β M.sets := by | |
| simpa only [RecursiveStateData.iterate_zero] using | |
| state.canonical_iterate_code_mem pairing unions powers separation hI hSources hReps hG hT 0 | |
| rw [M.realize_compressionHistoryFormula pairing unions powers separation | |
| (M.omega_mem separation infinite) hHistory initial hI hSources hReps hG hT] | |
| obtain β¨_, trace, uniqueβ© := state.canonicalHistory_spec pairing unions powers separation | |
| collection infinite hI hSources hReps hG hT | |
| exact β¨unique history, fun equal => equal.symm βΈ traceβ© | |
| end GroundCompressionState | |
| end PartitionPilot.Forcing | |
| end | |
| end OAI | |