Download data/lean/OAI/SetTheory/PartitionPrinciple/Definability/EquivalenceClassCodes.lean from introvoyz045/math: direct link, hf CLI and curl.
- Browser
- Download file 4.43 kB
-
https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Definability/EquivalenceClassCodes.lean
- Command line
-
hf download hf://datasets/introvoyz045/math/data/lean/OAI/SetTheory/PartitionPrinciple/Definability/EquivalenceClassCodes.lean
-
curl -L -o EquivalenceClassCodes.lean https://huggingface.co/datasets/introvoyz045/math/resolve/main/data/lean/OAI/SetTheory/PartitionPrinciple/Definability/EquivalenceClassCodes.lean
4.43 kB
| import OAI.SetTheory.PartitionPrinciple.Models.GroundCountableQuotients | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| universe u | |
| noncomputable def equivalenceClass (A E y : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun x => ZFSet.pair x y β E) A | |
| theorem mem_equivalenceClass (A E y x : ZFSet.{u}) : | |
| x β equivalenceClass A E y β x β A β§ ZFSet.pair x y β E := | |
| ZFSet.mem_sep | |
| theorem equivalenceClass_subset (A E y : ZFSet.{u}) : equivalenceClass A E y β A := | |
| fun _ h => (mem_equivalenceClass A E y _).1 h |>.1 | |
| noncomputable def equivalenceClasses (A E : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun C => β y β A, C = equivalenceClass A E y) (ZFSet.powerset A) | |
| theorem mem_equivalenceClasses (A E C : ZFSet.{u}) : | |
| C β equivalenceClasses A E β β y β A, C = equivalenceClass A E y := by | |
| rw [equivalenceClasses, ZFSet.mem_sep, ZFSet.mem_powerset] | |
| exact β¨And.right, fun β¨y, hy, equalβ© => | |
| β¨equal βΈ equivalenceClass_subset A E y, y, hy, equalβ©β© | |
| theorem equivalenceClass_mem {A E y : ZFSet.{u}} (hy : y β A) : | |
| equivalenceClass A E y β equivalenceClasses A E := | |
| (mem_equivalenceClasses A E _).2 β¨y, hy, rflβ© | |
| noncomputable def equivalenceClassifier (A E : ZFSet.{u}) : ZFSet.{u} := | |
| ZFSet.sep (fun z => β y β A, z = ZFSet.pair y (equivalenceClass A E y)) | |
| (ZFSet.prod A (equivalenceClasses A E)) | |
| theorem mem_equivalenceClassifier (A E z : ZFSet.{u}) : | |
| z β equivalenceClassifier A E β | |
| β y β A, z = ZFSet.pair y (equivalenceClass A E y) := by | |
| rw [equivalenceClassifier, ZFSet.mem_sep] | |
| refine β¨And.right, ?_β© | |
| rintro β¨y, hy, rflβ© | |
| exact β¨ZFSet.pair_mem_prod.2 β¨hy, equivalenceClass_mem hyβ©, y, hy, rflβ© | |
| theorem pair_mem_equivalenceClassifier (A E y C : ZFSet.{u}) : | |
| ZFSet.pair y C β equivalenceClassifier A E β | |
| y β A β§ C = equivalenceClass A E y := by | |
| rw [mem_equivalenceClassifier] | |
| constructor | |
| Β· rintro β¨x, hx, equalβ© | |
| obtain β¨rfl, equalβ© := ZFSet.pair_inj.1 equal | |
| exact β¨hx, equalβ© | |
| Β· rintro β¨hy, rflβ© | |
| exact β¨y, hy, rflβ© | |
| theorem equivalenceClassifier_function (A E : ZFSet.{u}) : | |
| ZFSet.IsFunc A (equivalenceClasses A E) (equivalenceClassifier A E) := by | |
| refine β¨fun _ h => (ZFSet.mem_sep.1 h).1, ?_β© | |
| intro y hy | |
| exact β¨equivalenceClass A E y, | |
| (pair_mem_equivalenceClassifier A E y _).2 β¨hy, rflβ©, | |
| fun C hC => ((pair_mem_equivalenceClassifier A E y C).1 hC).2β© | |
| theorem equivalenceClassifier_onto {A E C : ZFSet.{u}} | |
| (hC : C β equivalenceClasses A E) : | |
| β y β A, ZFSet.pair y C β equivalenceClassifier A E := by | |
| obtain β¨y, hy, rflβ© := (mem_equivalenceClasses A E C).1 hC | |
| exact β¨y, hy, (pair_mem_equivalenceClassifier A E y _).2 β¨hy, rflβ©β© | |
| namespace EquivalenceRelationCode | |
| theorem class_self {A E : ZFSet.{u}} (equivalence : EquivalenceRelationCode A E) | |
| {x : ZFSet.{u}} (hx : x β A) : x β equivalenceClass A E x := | |
| (mem_equivalenceClass A E x x).2 β¨hx, equivalence.refl x hxβ© | |
| theorem class_eq_iff {A E : ZFSet.{u}} (equivalence : EquivalenceRelationCode A E) | |
| {x y : ZFSet.{u}} (hx : x β A) (_hy : y β A) : | |
| equivalenceClass A E x = equivalenceClass A E y β ZFSet.pair x y β E := by | |
| constructor | |
| Β· intro equal | |
| exact ((mem_equivalenceClass A E y x).1 (equal βΈ equivalence.class_self hx)).2 | |
| Β· intro related | |
| apply ZFSet.ext | |
| intro z | |
| rw [mem_equivalenceClass, mem_equivalenceClass] | |
| exact and_congr_right (fun _ => β¨ | |
| fun h => equivalence.trans z x y h related, | |
| fun h => equivalence.trans z y x h (equivalence.symm x y related)β©) | |
| theorem classifier_kernel {A E : ZFSet.{u}} (equivalence : EquivalenceRelationCode A E) | |
| {x y C D : ZFSet.{u}} | |
| (first : ZFSet.pair x C β equivalenceClassifier A E) | |
| (second : ZFSet.pair y D β equivalenceClassifier A E) : | |
| C = D β ZFSet.pair x y β E := by | |
| obtain β¨hx, rflβ© := (pair_mem_equivalenceClassifier A E x C).1 first | |
| obtain β¨hy, rflβ© := (pair_mem_equivalenceClassifier A E y D).1 second | |
| exact equivalence.class_eq_iff hx hy | |
| theorem class_nonempty {A E C : ZFSet.{u}} (equivalence : EquivalenceRelationCode A E) | |
| (hC : C β equivalenceClasses A E) : β x, x β C := by | |
| obtain β¨x, hx, rflβ© := (mem_equivalenceClasses A E C).1 hC | |
| exact β¨x, equivalence.class_self hxβ© | |
| end EquivalenceRelationCode | |
| end PartitionPilot.Forcing | |
| end OAI | |