openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Forcing /GenericPartialFunctions.lean
| import Mathlib.SetTheory.Cardinal.Arithmetic | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| section | |
| universe u | |
| variable {P : Type u} [Preorder P] | |
| def Dense (D : Set P) : Prop := ∀ p, ∃ q, q ≤ p ∧ q ∈ D | |
| def DownwardClosed (D : Set P) : Prop := ∀ ⦃p q⦄, q ≤ p → p ∈ D → q ∈ D | |
| def CountablyClosed (P : Type u) [Preorder P] : Prop := | |
| ∀ chain : Nat → P, Antitone chain → ∃ lower, ∀ n, lower ≤ chain n | |
| structure ConditionFilter (P : Type u) [Preorder P] where | |
| mem : P → Prop | |
| nonempty : ∃ p, mem p | |
| upward : ∀ ⦃p q⦄, mem p → p ≤ q → mem q | |
| directed : ∀ ⦃p q⦄, mem p → mem q → ∃ r, mem r ∧ r ≤ p ∧ r ≤ q | |
| namespace ConditionFilter | |
| def Meets (F : ConditionFilter P) (D : Set P) : Prop := ∃ p, F.mem p ∧ p ∈ D | |
| def GenericFor (F : ConditionFilter P) (family : Set (Set P)) : Prop := | |
| ∀ D ∈ family, Dense D → F.Meets D | |
| theorem top_mem [OrderTop P] (F : ConditionFilter P) : F.mem ⊤ := by | |
| rcases F.nonempty with ⟨p, hp⟩ | |
| exact F.upward hp le_top | |
| theorem compatible (F : ConditionFilter P) {p q : P} (hp : F.mem p) (hq : F.mem q) : | |
| ∃ r, r ≤ p ∧ r ≤ q := by | |
| rcases F.directed hp hq with ⟨r, _, rp, rq⟩ | |
| exact ⟨r, rp, rq⟩ | |
| end ConditionFilter | |
| end | |
| section | |
| universe u v | |
| structure CountableCondition (I : Type u) (A : Type v) where | |
| value : I → Option A | |
| countable_domain : Set.Countable {i | value i ≠ none} | |
| namespace CountableCondition | |
| variable {I : Type u} {A : Type v} | |
| theorem ext {p q : CountableCondition I A} (values : p.value = q.value) : p = q := by | |
| cases p | |
| cases q | |
| cases values | |
| rfl | |
| instance : PartialOrder (CountableCondition I A) where | |
| le p q := ∀ i a, q.value i = some a → p.value i = some a | |
| le_refl _ _ _ h := h | |
| le_trans _ _ _ h1 h2 i a h := h1 i a (h2 i a h) | |
| le_antisymm p q hpq hqp := by | |
| apply ext | |
| funext i | |
| cases hp : p.value i with | |
| | none => | |
| cases hq : q.value i with | |
| | none => rfl | |
| | some a => | |
| have impossible := hpq i a hq | |
| rw [hp] at impossible | |
| contradiction | |
| | some a => exact (hqp i a hp).symm | |
| def domain (p : CountableCondition I A) : Set I := {i | p.value i ≠ none} | |
| def empty : CountableCondition I A where | |
| value _ := none | |
| countable_domain := by simp | |
| instance : OrderTop (CountableCondition I A) where | |
| top := empty | |
| le_top p i a h := by cases h | |
| theorem value_eq_of_le {p q : CountableCondition I A} (le : p ≤ q) (i : I) | |
| (defined : i ∈ q.domain) : p.value i = q.value i := by | |
| cases h : q.value i with | |
| | none => exact False.elim (defined h) | |
| | some a => exact le i a h | |
| theorem domain_mono {p q : CountableCondition I A} (le : p ≤ q) : q.domain ⊆ p.domain := by | |
| intro i hi | |
| change p.value i ≠ none | |
| rw [value_eq_of_le le i hi] | |
| exact hi | |
| noncomputable def assign (p : CountableCondition I A) (i : I) (a : A) : CountableCondition I A := by | |
| classical | |
| refine ⟨fun j => if j = i then some a else p.value j, ?_⟩ | |
| apply (p.countable_domain.insert i).mono | |
| intro j hj | |
| by_cases eq : j = i | |
| · exact Or.inl eq | |
| · exact Or.inr (by simpa only [Set.mem_ofPred_eq, ite_eq_right eq] using hj) | |
| theorem assign_same (p : CountableCondition I A) (i : I) (a : A) : | |
| (p.assign i a).value i = some a := by | |
| classical | |
| simp [assign] | |
| theorem assign_other (p : CountableCondition I A) (i j : I) (a : A) (ne : j ≠ i) : | |
| (p.assign i a).value j = p.value j := by | |
| classical | |
| simp only [assign, ite_eq_right ne] | |
| theorem assign_le (p : CountableCondition I A) (i : I) (a : A) (fresh : p.value i = none) : | |
| p.assign i a ≤ p := by | |
| intro j b hb | |
| by_cases eq : j = i | |
| · subst j | |
| rw [fresh] at hb | |
| contradiction | |
| · rw [assign_other p i j a eq] | |
| exact hb | |
| def definedAt (i : I) : Set (CountableCondition I A) := {p | p.value i ≠ none} | |
| theorem definedAt_downwardClosed (i : I) : DownwardClosed (definedAt (A := A) i) := by | |
| intro p q le hp | |
| exact domain_mono le hp | |
| theorem definedAt_dense [Nonempty A] (i : I) : Dense (definedAt (A := A) i) := by | |
| classical | |
| intro p | |
| by_cases defined : p.value i ≠ none | |
| · exact ⟨p, le_rfl, defined⟩ | |
| · have fresh : p.value i = none := not_ne_iff.1 defined | |
| let a : A := Classical.choice inferInstance | |
| refine ⟨p.assign i a, assign_le p i a fresh, ?_⟩ | |
| change (p.assign i a).value i ≠ none | |
| rw [assign_same] | |
| exact Option.some_ne_none _ | |
| theorem compatible_values {p q : CountableCondition I A} (compatible : ∃ r, r ≤ p ∧ r ≤ q) | |
| {i : I} {a b : A} (ha : p.value i = some a) (hb : q.value i = some b) : a = b := by | |
| rcases compatible with ⟨r, rp, rq⟩ | |
| exact Option.some.inj ((rp i a ha).symm.trans (rq i b hb)) | |
| end CountableCondition | |
| end | |
| section | |
| universe u | |
| variable {P : Type u} [Preorder P] | |
| theorem exists_filter_meeting_sequence (p : P) (D : Nat → Set P) | |
| (dense : ∀ n, Dense (D n)) : | |
| ∃ H : ConditionFilter P, H.mem p ∧ ∀ n, H.Meets (D n) := by | |
| classical | |
| let next (n : Nat) (q : P) : P := Classical.choose (dense n q) | |
| have next_le (n : Nat) (q : P) : next n q ≤ q := (Classical.choose_spec (dense n q)).1 | |
| have next_mem (n : Nat) (q : P) : next n q ∈ D n := (Classical.choose_spec (dense n q)).2 | |
| let chain : Nat → P := Nat.rec p next | |
| have step (n : Nat) : chain (n + 1) ≤ chain n := next_le n (chain n) | |
| have down : Antitone chain := antitone_nat_of_succ_le step | |
| let H : ConditionFilter P := { | |
| mem := fun q => ∃ n, chain n ≤ q | |
| nonempty := ⟨p, 0, le_rfl⟩ | |
| upward := by | |
| rintro q r ⟨n, nq⟩ qr | |
| exact ⟨n, nq.trans qr⟩ | |
| directed := by | |
| rintro q r ⟨n, nq⟩ ⟨m, mr⟩ | |
| exact ⟨chain (max n m), ⟨max n m, le_rfl⟩, | |
| (down (le_max_left n m)).trans nq, (down (le_max_right n m)).trans mr⟩ } | |
| exact ⟨H, ⟨0, le_rfl⟩, fun n => ⟨chain (n + 1), ⟨n + 1, le_rfl⟩, next_mem n (chain n)⟩⟩ | |
| theorem exists_generic_for_countable_family (p : P) (family : Set (Set P)) | |
| (small : family.Countable) : | |
| ∃ H : ConditionFilter P, H.mem p ∧ H.GenericFor family := by | |
| classical | |
| let listed := Set.enumerateCountable small (Set.univ : Set P) | |
| let D (n : Nat) : Set P := if Dense (listed n) then listed n else Set.univ | |
| have dense (n : Nat) : Dense (D n) := by | |
| dsimp [D] | |
| split_ifs with h | |
| · exact h | |
| · exact fun q => ⟨q, le_rfl, Set.mem_univ q⟩ | |
| obtain ⟨H, hp, meets⟩ := exists_filter_meeting_sequence p D dense | |
| refine ⟨H, hp, ?_⟩ | |
| intro E hE hDense | |
| obtain ⟨n, hn⟩ := Set.subset_range_enumerate small (Set.univ : Set P) hE | |
| have eq : D n = E := by | |
| dsimp [D, listed] | |
| simp only [hn, ite_eq_left hDense] | |
| exact eq ▸ meets n | |
| def Compatible (p q : P) : Prop := ∃ r, r ≤ p ∧ r ≤ q | |
| def DenseBelow (p : P) (D : Set P) : Prop := ∀ q, q ≤ p → ∃ r, r ≤ q ∧ r ∈ D | |
| def Localized (p : P) (D : Set P) : Set P := {q | q ∈ D ∨ ¬ Compatible q p} | |
| theorem localized_dense {p : P} {D : Set P} (dense : DenseBelow p D) : Dense (Localized p D) := by | |
| classical | |
| intro q | |
| by_cases compat : Compatible q p | |
| · obtain ⟨r, rq, rp⟩ := compat | |
| obtain ⟨t, tr, ht⟩ := dense r rp | |
| exact ⟨t, tr.trans rq, Or.inl ht⟩ | |
| · exact ⟨q, le_rfl, Or.inr compat⟩ | |
| theorem ConditionFilter.meets_below (H : ConditionFilter P) {family : Set (Set P)} | |
| (generic : H.GenericFor family) {p : P} (hp : H.mem p) {D : Set P} | |
| (registered : Localized p D ∈ family) (dense : DenseBelow p D) : H.Meets D := by | |
| obtain ⟨q, hq, good | bad⟩ := generic _ registered (localized_dense dense) | |
| · exact ⟨q, hq, good⟩ | |
| · exact False.elim (bad (H.compatible hq hp)) | |
| theorem denseBelow_mono {p : P} {D E : Set P} (dense : DenseBelow p D) (included : D ⊆ E) : | |
| DenseBelow p E := by | |
| intro q qp | |
| obtain ⟨r, rq, hr⟩ := dense q qp | |
| exact ⟨r, rq, included hr⟩ | |
| theorem dense_countable_intersection (closed : CountablyClosed P) | |
| (D : Nat → Set P) (dense : ∀ n, Dense (D n)) | |
| (open_ : ∀ n, DownwardClosed (D n)) : Dense {p | ∀ n, p ∈ D n} := by | |
| classical | |
| intro p | |
| let next (n : Nat) (q : P) : P := Classical.choose (dense n q) | |
| have next_le (n : Nat) (q : P) : next n q ≤ q := (Classical.choose_spec (dense n q)).1 | |
| have next_mem (n : Nat) (q : P) : next n q ∈ D n := (Classical.choose_spec (dense n q)).2 | |
| let chain : Nat → P := Nat.rec p next | |
| have step (n : Nat) : chain (n + 1) ≤ chain n := next_le n (chain n) | |
| rcases closed chain (antitone_nat_of_succ_le step) with ⟨q, lower⟩ | |
| refine ⟨q, lower 0, ?_⟩ | |
| intro n | |
| exact open_ n (lower (n + 1)) (next_mem n (chain n)) | |
| theorem dense_simultaneous_witnesses (closed : CountablyClosed P) | |
| {A : Nat → Type*} (R : P → (n : Nat) → A n → Prop) | |
| (monotone : ∀ ⦃p q⦄, q ≤ p → ∀ n a, R p n a → R q n a) | |
| (dense : ∀ n, Dense {p | ∃ a, R p n a}) : | |
| Dense {p | ∃ f : ∀ n, A n, ∀ n, R p n (f n)} := by | |
| intro p | |
| rcases dense_countable_intersection closed (fun n => {p | ∃ a, R p n a}) dense | |
| (fun n _ _ le ⟨a, ha⟩ => ⟨a, monotone le n a ha⟩) p with ⟨q, qp, all⟩ | |
| exact ⟨q, qp, Classical.axiomOfChoice all⟩ | |
| end | |
| namespace CountableCondition | |
| universe u v | |
| variable {I : Type u} {A : Type v} | |
| def Agrees (p q : CountableCondition I A) : Prop := | |
| ∀ i a b, p.value i = some a → q.value i = some b → a = b | |
| theorem agrees_symm {p q : CountableCondition I A} (h : Agrees p q) : Agrees q p := | |
| fun i a b ha hb => (h i b a hb ha).symm | |
| noncomputable def merge (p q : CountableCondition I A) : CountableCondition I A where | |
| value i := match p.value i with | |
| | some a => some a | |
| | none => q.value i | |
| countable_domain := by | |
| apply (p.countable_domain.union q.countable_domain).mono | |
| intro i hi | |
| cases hp : p.value i with | |
| | none => exact Or.inr (by simpa only [Set.mem_ofPred_eq, hp] using hi) | |
| | some a => exact Or.inl (by | |
| change p.value i ≠ none | |
| rw [hp] | |
| exact Option.some_ne_none _) | |
| theorem merge_le_left (p q : CountableCondition I A) : merge p q ≤ p := by | |
| intro i a ha | |
| change (match p.value i with | some a => some a | none => q.value i) = some a | |
| rw [ha] | |
| theorem merge_le_right {p q : CountableCondition I A} (agree : Agrees p q) : merge p q ≤ q := by | |
| intro i b hb | |
| change (match p.value i with | some a => some a | none => q.value i) = some b | |
| cases hp : p.value i with | |
| | none => exact hb | |
| | some a => exact congrArg some (agree i a b hp hb) | |
| theorem merge_value {p q : CountableCondition I A} (agree : Agrees p q) (i : I) (a : A) : | |
| (merge p q).value i = some a ↔ p.value i = some a ∨ q.value i = some a := by | |
| constructor | |
| · intro h | |
| cases hp : p.value i with | |
| | none => exact Or.inr (by simpa only [merge, hp] using h) | |
| | some b => exact Or.inl (by simpa only [merge, hp] using h) | |
| · rintro (hp | hq) | |
| · exact merge_le_left p q i a hp | |
| · exact merge_le_right agree i a hq | |
| theorem merge_agrees {p q r : CountableCondition I A} (pq : Agrees p q) | |
| (pr : Agrees p r) (qr : Agrees q r) : Agrees (merge p q) r := by | |
| intro i a b hab hr | |
| obtain hp | hq := (merge_value pq i a).1 hab | |
| · exact pr i a b hp hr | |
| · exact qr i a b hq hr | |
| theorem three_agree_common {p q r : CountableCondition I A} | |
| (pq : Agrees p q) (pr : Agrees p r) (qr : Agrees q r) : | |
| ∃ t, t ≤ p ∧ t ≤ q ∧ t ≤ r := by | |
| refine ⟨merge (merge p q) r, ?_, ?_, merge_le_right (merge_agrees pq pr qr)⟩ | |
| · exact (merge_le_left _ _).trans (merge_le_left _ _) | |
| · exact (merge_le_left _ _).trans (merge_le_right pq) | |
| noncomputable def unionValue (chain : Nat → CountableCondition I A) (i : I) : Option A := by | |
| classical | |
| exact if h : ∃ a, ∃ n, (chain n).value i = some a then some (Classical.choose h) else none | |
| theorem unionValue_domain (chain : Nat → CountableCondition I A) : | |
| {i | unionValue chain i ≠ none} ⊆ ⋃ n, (chain n).domain := by | |
| classical | |
| intro i hi | |
| by_cases h : ∃ a, ∃ n, (chain n).value i = some a | |
| · rcases h with ⟨a, n, ha⟩ | |
| apply Set.mem_iUnion.2 ⟨n, ?_⟩ | |
| change (chain n).value i ≠ none | |
| rw [ha] | |
| exact Option.some_ne_none _ | |
| · have value : unionValue chain i = none := by simp only [unionValue, dite_eq_right h] | |
| exact False.elim (hi value) | |
| theorem unionValue_extends (chain : Nat → CountableCondition I A) (decreasing : Antitone chain) | |
| (n : Nat) (i : I) (a : A) (value : (chain n).value i = some a) : | |
| unionValue chain i = some a := by | |
| classical | |
| have h : ∃ a, ∃ n, (chain n).value i = some a := ⟨a, n, value⟩ | |
| rw [unionValue, dite_eq_left h] | |
| rcases Classical.choose_spec h with ⟨m, hm⟩ | |
| have compatible : ∃ r, r ≤ chain m ∧ r ≤ chain n := | |
| ⟨chain (max m n), decreasing (le_max_left _ _), decreasing (le_max_right _ _)⟩ | |
| exact congrArg some (compatible_values compatible hm value) | |
| noncomputable def chainUnion (chain : Nat → CountableCondition I A) : CountableCondition I A where | |
| value := unionValue chain | |
| countable_domain := (Set.countable_iUnion (fun n => (chain n).countable_domain)).mono | |
| (unionValue_domain chain) | |
| theorem chainUnion_le (chain : Nat → CountableCondition I A) (decreasing : Antitone chain) | |
| (n : Nat) : chainUnion chain ≤ chain n := | |
| unionValue_extends chain decreasing n | |
| theorem countablyClosed : CountablyClosed (CountableCondition I A) := | |
| fun chain decreasing => ⟨chainUnion chain, chainUnion_le chain decreasing⟩ | |
| end CountableCondition | |
| section | |
| universe u v | |
| structure DecisionSystem (P : Type u) [Preorder P] (A : Nat → Type v) where | |
| decides : P → (n : Nat) → A n → Prop | |
| persistent : ∀ ⦃p q⦄, q ≤ p → ∀ n a, decides p n a → decides q n a | |
| unique : ∀ p n a b, decides p n a → decides p n b → a = b | |
| dense : ∀ n, Dense {p | ∃ a, decides p n a} | |
| namespace DecisionSystem | |
| variable {P : Type u} [Preorder P] {A : Nat → Type v} (d : DecisionSystem P A) | |
| def commonDecisions : Set P := {p | ∃ f : ∀ n, A n, ∀ n, d.decides p n (f n)} | |
| theorem commonDecisions_dense (closed : CountablyClosed P) : Dense d.commonDecisions := | |
| dense_simultaneous_witnesses closed d.decides d.persistent d.dense | |
| theorem commonDecisions_downwardClosed : DownwardClosed d.commonDecisions := by | |
| rintro p q le ⟨f, hf⟩ | |
| exact ⟨f, fun n => d.persistent le n (f n) (hf n)⟩ | |
| def Realizes (F : ConditionFilter P) (f : ∀ n, A n) : Prop := | |
| ∀ n, ∃ p, F.mem p ∧ d.decides p n (f n) | |
| theorem compatible_decisions (F : ConditionFilter P) {p q : P} (hp : F.mem p) (hq : F.mem q) | |
| (n : Nat) (a b : A n) (ha : d.decides p n a) (hb : d.decides q n b) : a = b := by | |
| rcases F.directed hp hq with ⟨r, _, rp, rq⟩ | |
| exact d.unique r n a b (d.persistent rp n a ha) (d.persistent rq n b hb) | |
| theorem realizes_unique (F : ConditionFilter P) {f g : ∀ n, A n} | |
| (hf : d.Realizes F f) (hg : d.Realizes F g) : f = g := by | |
| funext n | |
| rcases hf n with ⟨p, hp, ha⟩ | |
| rcases hg n with ⟨q, hq, hb⟩ | |
| exact d.compatible_decisions F hp hq n (f n) (g n) ha hb | |
| theorem common_condition_decides (F : ConditionFilter P) (meets : F.Meets d.commonDecisions) | |
| (f : ∀ n, A n) (realizes : d.Realizes F f) : | |
| ∃ p, F.mem p ∧ ∀ n, d.decides p n (f n) := by | |
| rcases meets with ⟨p, hp, g, hg⟩ | |
| have eq : g = f := d.realizes_unique F (fun n => ⟨p, hp, hg n⟩) realizes | |
| exact ⟨p, hp, eq ▸ hg⟩ | |
| theorem generic_condition_decides (closed : CountablyClosed P) (F : ConditionFilter P) | |
| (family : Set (Set P)) (generic : F.GenericFor family) (present : d.commonDecisions ∈ family) | |
| (f : ∀ n, A n) (realizes : d.Realizes F f) : | |
| ∃ p, F.mem p ∧ ∀ n, d.decides p n (f n) := | |
| d.common_condition_decides F (generic _ present (d.commonDecisions_dense closed)) f realizes | |
| end DecisionSystem | |
| end | |
| namespace CountableCondition | |
| universe u v | |
| variable {I : Type u} {A : Type v} (F : ConditionFilter (CountableCondition I A)) | |
| theorem exists_value (meets : ∀ i, F.Meets (definedAt i)) (i : I) : | |
| ∃ a, ∃ p, F.mem p ∧ p.value i = some a := by | |
| rcases meets i with ⟨p, hp, defined⟩ | |
| cases value : p.value i with | |
| | none => exact False.elim (defined value) | |
| | some a => exact ⟨a, p, hp, value⟩ | |
| noncomputable def readValue (meets : ∀ i, F.Meets (definedAt i)) (i : I) : A := | |
| Classical.choose (exists_value F meets i) | |
| theorem readValue_realized (meets : ∀ i, F.Meets (definedAt i)) (i : I) : | |
| ∃ p, F.mem p ∧ p.value i = some (readValue F meets i) := | |
| Classical.choose_spec (exists_value F meets i) | |
| theorem readValue_of_condition (meets : ∀ i, F.Meets (definedAt i)) | |
| {p : CountableCondition I A} (hp : F.mem p) {i : I} {a : A} (value : p.value i = some a) : | |
| readValue F meets i = a := by | |
| rcases readValue_realized F meets i with ⟨q, hq, read⟩ | |
| exact compatible_values (F.compatible hq hp) read value | |
| theorem readValue_iff (meets : ∀ i, F.Meets (definedAt i)) (i : I) (a : A) : | |
| readValue F meets i = a ↔ ∃ p, F.mem p ∧ p.value i = some a := by | |
| constructor | |
| · intro eq | |
| exact eq ▸ readValue_realized F meets i | |
| · rintro ⟨p, hp, value⟩ | |
| exact readValue_of_condition F meets hp value | |
| omit F in | |
| def coordinateDecisions [Nonempty A] (index : Nat → I) : | |
| DecisionSystem (CountableCondition I A) (fun _ => A) where | |
| decides p n a := p.value (index n) = some a | |
| persistent := by | |
| intro p q le n a value | |
| exact le (index n) a value | |
| unique _ _ _ _ h1 h2 := Option.some.inj (h1.symm.trans h2) | |
| dense n := by | |
| intro p | |
| rcases definedAt_dense (A := A) (index n) p with ⟨q, qp, defined⟩ | |
| cases value : q.value (index n) with | |
| | none => exact False.elim (defined value) | |
| | some a => exact ⟨q, qp, a, value⟩ | |
| omit F in | |
| theorem coordinate_commonDecisions_dense [Nonempty A] (index : Nat → I) : | |
| Dense (coordinateDecisions (A := A) index).commonDecisions := | |
| (coordinateDecisions index).commonDecisions_dense countablyClosed | |
| theorem readValue_sequence_decided [Nonempty A] (meets : ∀ i, F.Meets (definedAt i)) | |
| (index : Nat → I) (family : Set (Set (CountableCondition I A))) (generic : F.GenericFor family) | |
| (present : (coordinateDecisions (A := A) index).commonDecisions ∈ family) : | |
| ∃ p, F.mem p ∧ ∀ n, p.value (index n) = some (readValue F meets (index n)) := | |
| (coordinateDecisions index).generic_condition_decides countablyClosed F family generic present | |
| (fun n => readValue F meets (index n)) (fun n => readValue_realized F meets (index n)) | |
| end CountableCondition | |
| end PartitionPilot.Forcing | |
| end OAI | |