| import OAI.SetTheory.PartitionPrinciple.Models.GroundCountableQuotients |
|
|
| namespace OAI |
|
|
|
|
| namespace PartitionPilot.Forcing |
|
|
| open Compression.RecursiveMaps |
| universe u |
|
|
| structure StrictLinearOrderCode (D r : ZFSet.{u}) : Prop where |
| shape : r ⊆ ZFSet.prod D D |
| irrefl : ∀ x ∈ D, ZFSet.pair x x ∉ r |
| trans : ∀ x y z, ZFSet.pair x y ∈ r → ZFSet.pair y z ∈ r → ZFSet.pair x z ∈ r |
| compare : ∀ x ∈ D, ∀ y ∈ D, ZFSet.pair x y ∈ r ∨ x = y ∨ ZFSet.pair y x ∈ r |
|
|
| structure DenseOrderCode (D r : ZFSet.{u}) : Prop extends StrictLinearOrderCode D r where |
| between : ∀ x y, ZFSet.pair x y ∈ r → ∃ z ∈ D, ZFSet.pair x z ∈ r ∧ ZFSet.pair z y ∈ r |
|
|
| def StrictLinearOrderCode.toLinearHeightOrder {D r : ZFSet.{u}} (code : StrictLinearOrderCode D r) : |
| LinearHeightOrder {x : ZFSet.{u} // x ∈ D} where |
| lt x y := ZFSet.pair x.val y.val ∈ r |
| irrefl x := code.irrefl x.val x.property |
| trans {x y z} := code.trans x.val y.val z.val |
| compare x y := (code.compare x.val x.property y.val y.property).imp id |
| (fun h => h.imp (fun equal => Subtype.ext equal) id) |
|
|
| def DenseOrderCode.toDenseHeightOrder {D r : ZFSet.{u}} (code : DenseOrderCode D r) : |
| DenseHeightOrder {x : ZFSet.{u} // x ∈ D} where |
| toLinearHeightOrder := code.toStrictLinearOrderCode.toLinearHeightOrder |
| between x y lower := by |
| obtain ⟨z, hz, left, right⟩ := code.between x.val y.val lower |
| exact ⟨⟨z, hz⟩, left, right⟩ |
|
|
| def intervalCandidate (D r lower upper lo hi x : ZFSet.{u}) : Prop := |
| x ∈ D ∧ ZFSet.pair lo x ∈ r ∧ ZFSet.pair x hi ∈ r ∧ |
| (∀ y ∈ lower, ZFSet.pair y x ∈ r) ∧ (∀ y ∈ upper, ZFSet.pair x y ∈ r) |
|
|
| theorem DenseOrderCode.finite_interval_candidate {D r lower upper lo hi : ZFSet.{u}} |
| (code : DenseOrderCode D r) (loD : lo ∈ D) (hiD : hi ∈ D) |
| (lowerD : lower ⊆ D) (upperD : upper ⊆ D) |
| (finiteLower : lower.toSet.Finite) (finiteUpper : upper.toSet.Finite) |
| (gap : ZFSet.pair lo hi ∈ r) |
| (lowerHi : ∀ x ∈ lower, ZFSet.pair x hi ∈ r) |
| (loUpper : ∀ y ∈ upper, ZFSet.pair lo y ∈ r) |
| (separated : ∀ x ∈ lower, ∀ y ∈ upper, ZFSet.pair x y ∈ r) : |
| ∃ x, intervalCandidate D r lower upper lo hi x := by |
| classical |
| have lowerFinite : (Subtype.val ⁻¹' lower.toSet : Set {x : ZFSet.{u} // x ∈ D}).Finite := |
| Set.Finite.preimage (fun _ _ _ _ equal => Subtype.ext equal) finiteLower |
| have upperFinite : (Subtype.val ⁻¹' upper.toSet : Set {x : ZFSet.{u} // x ∈ D}).Finite := |
| Set.Finite.preimage (fun _ _ _ _ equal => Subtype.ext equal) finiteUpper |
| let lowers := lowerFinite.toFinset.toList |
| let uppers := upperFinite.toFinset.toList |
| have lowerSpec (x : {x : ZFSet.{u} // x ∈ D}) : x ∈ lowers ↔ x.val ∈ lower := by |
| simp only [lowers, Finset.mem_toList, Set.Finite.mem_toFinset, Set.mem_preimage] |
| rfl |
| have upperSpec (x : {x : ZFSet.{u} // x ∈ D}) : x ∈ uppers ↔ x.val ∈ upper := by |
| simp only [uppers, Finset.mem_toList, Set.Finite.mem_toFinset, Set.mem_preimage] |
| rfl |
| obtain ⟨x, left, right, aboveLower, belowUpper⟩ := code.toDenseHeightOrder.finite_gap |
| ⟨lo, loD⟩ ⟨hi, hiD⟩ lowers uppers gap |
| (fun x hx => lowerHi x.val ((lowerSpec x).1 hx)) |
| (fun y hy => loUpper y.val ((upperSpec y).1 hy)) |
| (fun x hx y hy => separated x.val ((lowerSpec x).1 hx) y.val ((upperSpec y).1 hy)) |
| exact ⟨x.val, x.property, left, right, |
| fun y hy => aboveLower ⟨y, lowerD hy⟩ ((lowerSpec _).2 hy), |
| fun y hy => belowUpper ⟨y, upperD hy⟩ ((upperSpec _).2 hy)⟩ |
|
|
| end PartitionPilot.Forcing |
|
|
| end OAI |
|
|
