File size: 3,607 Bytes
3277efa | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 | 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
|