openAI-math-dataset / lean /OAI /SetTheory /PartitionPrinciple /Geometry /CompleteProjectionPredensity.lean
| import OAI.SetTheory.PartitionPrinciple.Forcing.ConditionQuantifiers | |
| namespace OAI | |
| namespace PartitionPilot.Forcing | |
| section | |
| universe u v | |
| variable {Upper : Type u} {Lower : Type v} [PartialOrder Upper] [PartialOrder Lower] | |
| structure CompleteProjection (restriction : Upper →o Lower) | |
| (inclusion : Lower ↪o Upper) : Prop where | |
| retract : ∀ q, restriction (inclusion q) = q | |
| le_include_iff : ∀ p q, p ≤ inclusion q ↔ restriction p ≤ q | |
| lift : ∀ p q, q ≤ restriction p → ∃ r, r ≤ p ∧ restriction r = q | |
| namespace CompleteProjection | |
| variable {restriction : Upper →o Lower} {inclusion : Lower ↪o Upper} | |
| variable (projection : CompleteProjection restriction inclusion) | |
| include projection | |
| theorem le_include_restriction (p : Upper) : p ≤ inclusion (restriction p) := | |
| (projection.le_include_iff p (restriction p)).2 le_rfl | |
| theorem compatible_include_iff (p : Upper) (q : Lower) : | |
| Compatible p (inclusion q) ↔ Compatible (restriction p) q := by | |
| constructor | |
| · rintro ⟨r, rp, rq⟩ | |
| exact ⟨restriction r, restriction.monotone rp, (projection.le_include_iff r q).1 rq⟩ | |
| · rintro ⟨q', below, included⟩ | |
| obtain ⟨r, rp, equal⟩ := projection.lift p q' below | |
| refine ⟨r, rp, (projection.le_include_iff r q).2 ?_⟩ | |
| exact equal.symm ▸ included | |
| theorem included_compatible_iff (p q : Lower) : | |
| Compatible (inclusion p) (inclusion q) ↔ Compatible p q := by | |
| rw [projection.compatible_include_iff, projection.retract] | |
| theorem dense_preimage {E : Set Lower} (dense : Dense E) : | |
| Dense {p : Upper | restriction p ∈ E} := by | |
| intro p | |
| obtain ⟨q, below, member⟩ := dense (restriction p) | |
| obtain ⟨r, rp, equal⟩ := projection.lift p q below | |
| refine ⟨r, rp, ?_⟩ | |
| change restriction r ∈ E | |
| rw [equal] | |
| exact member | |
| theorem predense_inclusion {E : Set Lower} | |
| (predense : ∀ q : Lower, ∃ r ∈ E, Compatible q r) : | |
| ∀ p : Upper, ∃ r ∈ E, Compatible p (inclusion r) := by | |
| intro p | |
| obtain ⟨r, member, compatible⟩ := predense (restriction p) | |
| exact ⟨r, member, (projection.compatible_include_iff p r).2 compatible⟩ | |
| def projectedFilter (H : ConditionFilter Upper) : ConditionFilter Lower where | |
| mem q := H.mem (inclusion q) | |
| nonempty := by | |
| obtain ⟨p, member⟩ := H.nonempty | |
| exact ⟨restriction p, H.upward member (projection.le_include_restriction p)⟩ | |
| upward := by | |
| intro p q member below | |
| exact H.upward member (inclusion.monotone below) | |
| directed := by | |
| intro p q hp hq | |
| obtain ⟨r, member, rp, rq⟩ := H.directed hp hq | |
| exact ⟨restriction r, H.upward member (projection.le_include_restriction r), | |
| (projection.le_include_iff r p).1 rp, (projection.le_include_iff r q).1 rq⟩ | |
| theorem projectedFilter_mem_iff (H : ConditionFilter Upper) (q : Lower) : | |
| (projection.projectedFilter H).mem q ↔ | |
| ∃ p : Upper, H.mem p ∧ restriction p = q := by | |
| constructor | |
| · intro member | |
| exact ⟨inclusion q, member, projection.retract q⟩ | |
| · rintro ⟨p, member, rfl⟩ | |
| exact H.upward member (projection.le_include_restriction p) | |
| theorem projectedFilter_meets_iff (H : ConditionFilter Upper) (E : Set Lower) : | |
| (projection.projectedFilter H).Meets E ↔ H.Meets {p : Upper | restriction p ∈ E} := by | |
| constructor | |
| · rintro ⟨q, member, hq⟩ | |
| obtain ⟨p, hp, rfl⟩ := (projection.projectedFilter_mem_iff H q).1 member | |
| exact ⟨p, hp, hq⟩ | |
| · rintro ⟨p, member, hp⟩ | |
| exact ⟨restriction p, (projection.projectedFilter_mem_iff H (restriction p)).2 | |
| ⟨p, member, rfl⟩, hp⟩ | |
| theorem projectedFilter_generic (H : ConditionFilter Upper) (family : Set (Set Lower)) | |
| (generic : H.GenericFor ((fun E : Set Lower => {p : Upper | restriction p ∈ E}) '' family)) : | |
| (projection.projectedFilter H).GenericFor family := by | |
| intro E member dense | |
| exact (projection.projectedFilter_meets_iff H E).2 | |
| (generic _ ⟨E, member, rfl⟩ (projection.dense_preimage dense)) | |
| end CompleteProjection | |
| end | |
| namespace CompleteProjection | |
| universe u v | |
| variable {Upper : Type u} {Lower : Type v} [PartialOrder Upper] [PartialOrder Lower] | |
| variable {restriction : Upper →o Lower} {inclusion : Lower ↪o Upper} | |
| variable (projection : CompleteProjection restriction inclusion) | |
| include projection | |
| theorem denseBelow_preimage_iff (q : Upper) (E : Set Lower) : | |
| DenseBelow q {r | restriction r ∈ E} ↔ DenseBelow (restriction q) E := by | |
| constructor | |
| · intro dense p pq | |
| obtain ⟨r, rq, rp⟩ := projection.lift q p pq | |
| obtain ⟨v, vr, member⟩ := dense r rq | |
| exact ⟨restriction v, (restriction.monotone vr).trans_eq rp, member⟩ | |
| · intro dense r rq | |
| obtain ⟨p, pr, member⟩ := dense (restriction r) (restriction.monotone rq) | |
| obtain ⟨v, vr, vp⟩ := projection.lift r p pr | |
| exact ⟨v, vr, show restriction v ∈ E from vp.symm ▸ member⟩ | |
| end CompleteProjection | |
| namespace Name | |
| open SetRealization | |
| universe u | |
| variable {P Q : Type u} [PartialOrder P] [PartialOrder Q] | |
| variable (s : Presentation P) (t : Presentation Q) | |
| variable (pi : Q →o P) (inc : P ↪o Q) (projection : CompleteProjection pi inc) | |
| include projection | |
| theorem forcesEq_rename_completeProjection (q : Q) (σ τ : Name s) : | |
| ForcesEq q (rename t inc σ) (rename t inc τ) ↔ ForcesEq (pi q) σ τ := by | |
| induction σ using inductionOn generalizing τ q with | |
| | step σ ih => | |
| rw [ForcesEq, ForcesEq] | |
| constructor | |
| · rintro ⟨left, right⟩ | |
| constructor | |
| · intro ρ r hr p pq pr | |
| obtain ⟨v, vq, vp⟩ := projection.lift q p pq | |
| have vr : v ≤ inc r := (projection.le_include_iff v r).2 (vp.symm ▸ pr) | |
| have entry := (entry_rename t inc σ (rename t inc ρ) (inc r)).2 ⟨ρ, r, hr, rfl, rfl⟩ | |
| obtain ⟨w, wv, ν, k, hk, wk, eq⟩ := left _ _ entry v vq vr | |
| obtain ⟨ν₀, k₀, old, rfl, rfl⟩ := (entry_rename t inc τ ν k).1 hk | |
| exact ⟨pi w, (pi.monotone wv).trans_eq vp, ν₀, k₀, old, | |
| (projection.le_include_iff w k₀).1 wk, (ih ρ r hr (q := w) (τ := ν₀)).1 eq⟩ | |
| · intro ν k hk p pq pk | |
| obtain ⟨v, vq, vp⟩ := projection.lift q p pq | |
| have vk : v ≤ inc k := (projection.le_include_iff v k).2 (vp.symm ▸ pk) | |
| have entry := (entry_rename t inc τ (rename t inc ν) (inc k)).2 ⟨ν, k, hk, rfl, rfl⟩ | |
| obtain ⟨w, wv, ρ, r, hr, wr, eq⟩ := right _ _ entry v vq vk | |
| obtain ⟨ρ₀, r₀, old, rfl, rfl⟩ := (entry_rename t inc σ ρ r).1 hr | |
| exact ⟨pi w, (pi.monotone wv).trans_eq vp, ρ₀, r₀, old, | |
| (projection.le_include_iff w r₀).1 wr, (ih ρ₀ r₀ old (q := w) (τ := ν)).1 eq⟩ | |
| · rintro ⟨left, right⟩ | |
| constructor | |
| · intro ρ r hr v vq vr | |
| obtain ⟨ρ₀, r₀, old, rfl, rfl⟩ := (entry_rename t inc σ ρ r).1 hr | |
| obtain ⟨p, pv, ν, k, hk, pk, eq⟩ := | |
| left ρ₀ r₀ old (pi v) (pi.monotone vq) ((projection.le_include_iff v r₀).1 vr) | |
| obtain ⟨w, wv, wp⟩ := projection.lift v p pv | |
| refine ⟨w, wv, rename t inc ν, inc k, | |
| (entry_rename t inc τ (rename t inc ν) (inc k)).2 ⟨ν, k, hk, rfl, rfl⟩, | |
| (projection.le_include_iff w k).2 (wp.symm ▸ pk), ?_⟩ | |
| exact (ih ρ₀ r₀ old (q := w) (τ := ν)).2 (wp.symm ▸ eq) | |
| · intro ν k hk v vq vk | |
| obtain ⟨ν₀, k₀, old, rfl, rfl⟩ := (entry_rename t inc τ ν k).1 hk | |
| obtain ⟨p, pv, ρ, r, hr, pr, eq⟩ := | |
| right ν₀ k₀ old (pi v) (pi.monotone vq) ((projection.le_include_iff v k₀).1 vk) | |
| obtain ⟨w, wv, wp⟩ := projection.lift v p pv | |
| refine ⟨w, wv, rename t inc ρ, inc r, | |
| (entry_rename t inc σ (rename t inc ρ) (inc r)).2 ⟨ρ, r, hr, rfl, rfl⟩, | |
| (projection.le_include_iff w r).2 (wp.symm ▸ pr), ?_⟩ | |
| exact (ih ρ r hr (q := w) (τ := ν₀)).2 (wp.symm ▸ eq) | |
| end Name | |
| namespace Name | |
| open SetRealization | |
| universe u | |
| variable {P Q : Type u} [PartialOrder P] [PartialOrder Q] | |
| variable (s : Presentation P) (t : Presentation Q) | |
| variable (pi : Q →o P) (inc : P ↪o Q) (projection : CompleteProjection pi inc) | |
| include projection | |
| theorem memWitness_rename_completeProjection (q : Q) (σ τ : Name s) : | |
| q ∈ MemWitness (rename t inc σ) (rename t inc τ) ↔ pi q ∈ MemWitness σ τ := by | |
| constructor | |
| · rintro ⟨ν, r, entry, qr, eq⟩ | |
| obtain ⟨ν₀, r₀, old, rfl, rfl⟩ := (entry_rename t inc τ ν r).1 entry | |
| exact ⟨ν₀, r₀, old, (projection.le_include_iff q r₀).1 qr, | |
| (forcesEq_rename_completeProjection s t pi inc projection q σ ν₀).1 eq⟩ | |
| · rintro ⟨ν, r, entry, qr, eq⟩ | |
| exact ⟨rename t inc ν, inc r, | |
| (entry_rename t inc τ (rename t inc ν) (inc r)).2 ⟨ν, r, entry, rfl, rfl⟩, | |
| (projection.le_include_iff q r).2 qr, | |
| (forcesEq_rename_completeProjection s t pi inc projection q σ ν).2 eq⟩ | |
| theorem forcesMem_rename_completeProjection (q : Q) (σ τ : Name s) : | |
| ForcesMem q (rename t inc σ) (rename t inc τ) ↔ ForcesMem (pi q) σ τ := by | |
| have witnesses : MemWitness (rename t inc σ) (rename t inc τ) = | |
| {r : Q | pi r ∈ MemWitness σ τ} := by | |
| apply Set.ext | |
| intro r | |
| exact memWitness_rename_completeProjection s t pi inc projection r σ τ | |
| change DenseBelow q _ ↔ DenseBelow (pi q) _ | |
| rw [witnesses] | |
| exact projection.denseBelow_preimage_iff q (MemWitness σ τ) | |
| end Name | |
| namespace CompleteProjection | |
| open SetRealization | |
| universe u | |
| variable {Upper Lower : Type u} [PartialOrder Upper] [PartialOrder Lower] | |
| variable {restriction : Upper →o Lower} {inclusion : Lower ↪o Upper} | |
| variable (projection : CompleteProjection restriction inclusion) | |
| include projection | |
| theorem predense_inclusion_iff {E : Set Lower} : | |
| (∀ p : Upper, ∃ r ∈ E, Compatible p (inclusion r)) ↔ | |
| (∀ q : Lower, ∃ r ∈ E, Compatible q r) := by | |
| constructor | |
| · intro predense q | |
| obtain ⟨r, member, common⟩ := predense (inclusion q) | |
| exact ⟨r, member, (projection.included_compatible_iff q r).1 common⟩ | |
| · exact projection.predense_inclusion | |
| theorem raw_predense_restriction (s : Presentation Upper) (t : Presentation Lower) | |
| (unchanged : ∀ q, s.encode (inclusion q) = t.encode q) | |
| {A : ZFSet.{u}} (within : A ⊆ t.carrier) | |
| (predense : ∀ q ∈ s.carrier, ∃ p ∈ A, ∃ r ∈ s.carrier, | |
| ZFSet.pair r q ∈ s.conditionOrder ∧ ZFSet.pair r p ∈ s.conditionOrder) : | |
| ∀ q ∈ t.carrier, ∃ p ∈ A, ∃ r ∈ t.carrier, | |
| ZFSet.pair r q ∈ t.conditionOrder ∧ ZFSet.pair r p ∈ t.conditionOrder := by | |
| have upper : ∀ p : Upper, ∃ q, t.encode q ∈ A ∧ Compatible p (inclusion q) := by | |
| intro p | |
| obtain ⟨x, hx, z, hz, zp, zx⟩ := predense (s.encode p) (s.encode_mem p) | |
| obtain ⟨q, qCode⟩ := (t.mem_carrier x).1 (within hx) | |
| obtain ⟨r, rCode⟩ := (s.mem_carrier z).1 hz | |
| refine ⟨q, qCode.symm ▸ hx, r, ?_, ?_⟩ | |
| · apply (s.pair_mem_conditionOrder r p).1 | |
| rwa [rCode] | |
| · apply (s.pair_mem_conditionOrder r (inclusion q)).1 | |
| rwa [rCode, unchanged q, qCode] | |
| have lower := (projection.predense_inclusion_iff (E := {q | t.encode q ∈ A})).1 upper | |
| intro x hx | |
| obtain ⟨q, qCode⟩ := (t.mem_carrier x).1 hx | |
| obtain ⟨p, hp, r, rq, rp⟩ := lower q | |
| refine ⟨t.encode p, hp, t.encode r, t.encode_mem r, ?_, | |
| (t.pair_mem_conditionOrder r p).2 rp⟩ | |
| rw [← qCode] | |
| exact (t.pair_mem_conditionOrder r q).2 rq | |
| end CompleteProjection | |
| end PartitionPilot.Forcing | |
| end OAI | |