| import Init |
|
|
| namespace OAI |
|
|
|
|
| namespace PartitionPilot |
|
|
| section |
|
|
| universe u v |
|
|
| structure MeetOrder (α : Type u) where |
| le : α → α → Prop |
| meet : α → α → α |
| refl : ∀ a, le a a |
| trans : ∀ {a b c}, le a b → le b c → le a c |
| antisymm : ∀ {a b}, le a b → le b a → a = b |
| meet_le_left : ∀ a b, le (meet a b) a |
| meet_le_right : ∀ a b, le (meet a b) b |
| le_meet : ∀ {a b c}, le a b → le a c → le a (meet b c) |
|
|
| theorem meet_comm {α : Type u} (P : MeetOrder α) (a b : α) : |
| P.meet a b = P.meet b a := by |
| apply P.antisymm |
| · exact P.le_meet (P.meet_le_right a b) (P.meet_le_left a b) |
| · exact P.le_meet (P.meet_le_right b a) (P.meet_le_left b a) |
|
|
| structure MeetEmbedding {α : Type u} {β : Type v} |
| (P : MeetOrder α) (Q : MeetOrder β) where |
| toFun : α → β |
| le_iff : ∀ a b, Q.le (toFun a) (toFun b) ↔ P.le a b |
| map_meet : ∀ a b, toFun (P.meet a b) = Q.meet (toFun a) (toFun b) |
|
|
| def Positive {α : Type u} (P : MeetOrder α) (F : α → Prop) (x : α) : Prop := |
| ∃ f, F f ∧ P.le f x |
|
|
| def Profile {α : Type u} (P : MeetOrder α) (c e K : α) (F : α → Prop) : Prop := |
| ∀ x, P.le e x → |
| (Positive P F x → P.le K x) ∧ |
| (¬ Positive P F x → P.meet K x = c) |
|
|
| def PositiveOver {α : Type u} {β : Type v} |
| {P : MeetOrder α} {Q : MeetOrder β} |
| (i : MeetEmbedding P Q) (F : α → Prop) (x : β) : Prop := |
| ∃ f, F f ∧ Q.le (i.toFun f) x |
|
|
| def ProfileOver {α : Type u} {β : Type v} |
| {P : MeetOrder α} {Q : MeetOrder β} |
| (i : MeetEmbedding P Q) (c e K : α) (F : α → Prop) : Prop := |
| ∀ x, Q.le (i.toFun e) x → |
| (PositiveOver i F x → Q.le (i.toFun K) x) ∧ |
| (¬ PositiveOver i F x → Q.meet (i.toFun K) x = i.toFun c) |
|
|
| def HasOldShadow {α : Type u} {β : Type v} |
| {P : MeetOrder α} {Q : MeetOrder β} |
| (i : MeetEmbedding P Q) (x : β) : Prop := |
| ∃ l, |
| (∀ a, Q.le (i.toFun a) x ↔ P.le a l) ∧ |
| (∀ a, ¬ Q.le x (i.toFun a) → |
| Q.meet x (i.toFun a) = i.toFun (P.meet l a)) |
|
|
| def IsGreatest {β : Type v} (Q : MeetOrder β) (x : β) : Prop := |
| ∀ y, Q.le y x |
|
|
| def PermittedExtension {α : Type u} {β : Type v} |
| {P : MeetOrder α} {Q : MeetOrder β} |
| (i : MeetEmbedding P Q) : Prop := |
| ∀ x, (∃ a, i.toFun a = x) ∨ HasOldShadow i x ∨ IsGreatest Q x |
|
|
| theorem profile_at_shadow {α : Type u} {β : Type v} |
| {P : MeetOrder α} {Q : MeetOrder β} |
| (i : MeetEmbedding P Q) (c e K : α) (F : α → Prop) |
| (old_profile : Profile P c e K F) |
| (e_not_le_K : ¬ P.le e K) |
| (x : β) (above_e : Q.le (i.toFun e) x) |
| (shadow : HasOldShadow i x) : |
| (PositiveOver i F x → Q.le (i.toFun K) x) ∧ |
| (¬ PositiveOver i F x → Q.meet (i.toFun K) x = i.toFun c) := by |
| cases shadow with |
| | intro l hl => |
| have part := hl.left |
| have shadow_meet := hl.right |
| have e_le_l : P.le e l := (part e).mp above_e |
| have x_not_le_K : ¬ Q.le x (i.toFun K) := by |
| intro hx |
| exact e_not_le_K ((i.le_iff e K).mp (Q.trans above_e hx)) |
| have positives : PositiveOver i F x ↔ Positive P F l := by |
| constructor |
| · intro hp |
| cases hp with |
| | intro f hf => exact ⟨f, hf.left, (part f).mp hf.right⟩ |
| · intro hp |
| cases hp with |
| | intro f hf => exact ⟨f, hf.left, (part f).mpr hf.right⟩ |
| have inherited := old_profile l e_le_l |
| constructor |
| · intro hp |
| exact (part K).mpr (inherited.left (positives.mp hp)) |
| · intro hn |
| have hn_old : ¬ Positive P F l := fun hp => hn (positives.mpr hp) |
| calc |
| Q.meet (i.toFun K) x = Q.meet x (i.toFun K) := meet_comm Q _ _ |
| _ = i.toFun (P.meet l K) := shadow_meet K x_not_le_K |
| _ = i.toFun (P.meet K l) := congrArg i.toFun (meet_comm P l K) |
| _ = i.toFun c := congrArg i.toFun (inherited.right hn_old) |
|
|
| theorem profile_persists_one_step {α : Type u} {β : Type v} |
| {P : MeetOrder α} {Q : MeetOrder β} |
| (i : MeetEmbedding P Q) (c e K : α) (F : α → Prop) |
| (nonempty_F : ∃ f, F f) |
| (old_profile : Profile P c e K F) |
| (e_not_le_K : ¬ P.le e K) |
| (extension : PermittedExtension i) : |
| ProfileOver i c e K F := by |
| intro x above_e |
| cases extension x with |
| | inl old => |
| cases old with |
| | intro a ha => |
| cases ha |
| have e_le_a : P.le e a := (i.le_iff e a).mp above_e |
| have positives : PositiveOver i F (i.toFun a) ↔ Positive P F a := by |
| constructor |
| · intro hp |
| cases hp with |
| | intro f hf => exact ⟨f, hf.left, (i.le_iff f a).mp hf.right⟩ |
| · intro hp |
| cases hp with |
| | intro f hf => exact ⟨f, hf.left, (i.le_iff f a).mpr hf.right⟩ |
| have inherited := old_profile a e_le_a |
| constructor |
| · intro hp |
| exact (i.le_iff K a).mpr (inherited.left (positives.mp hp)) |
| · intro hn |
| have hn_old : ¬ Positive P F a := fun hp => hn (positives.mpr hp) |
| calc |
| Q.meet (i.toFun K) (i.toFun a) = i.toFun (P.meet K a) := |
| (i.map_meet K a).symm |
| _ = i.toFun c := congrArg i.toFun (inherited.right hn_old) |
| | inr fresh => |
| cases fresh with |
| | inl shadow => |
| exact profile_at_shadow i c e K F old_profile e_not_le_K x above_e shadow |
| | inr top => |
| constructor |
| · intro _ |
| exact top (i.toFun K) |
| · intro hn |
| cases nonempty_F with |
| | intro f hf => exact False.elim (hn ⟨f, hf, top (i.toFun f)⟩) |
|
|
| def NodeProfile {α : Type u} (P : MeetOrder α) (c K : α) |
| (F : α → Prop) (x : α) : Prop := |
| (Positive P F x → P.le K x) ∧ |
| (¬ Positive P F x → P.meet K x = c) |
|
|
| def ProfileOn {α : Type u} (P : MeetOrder α) (c e K : α) |
| (F S : α → Prop) : Prop := |
| ∀ x, S x → P.le e x → NodeProfile P c K F x |
|
|
| def ShadowIn {α : Type u} (P : MeetOrder α) (Old : α → Prop) |
| (x l : α) : Prop := |
| Old l ∧ |
| (∀ a, Old a → (P.le a x ↔ P.le a l)) ∧ |
| (∀ a, Old a → ¬ P.le x a → P.meet x a = P.meet l a) |
|
|
| def GreatestIn {α : Type u} (P : MeetOrder α) (S : α → Prop) (x : α) : Prop := |
| ∀ y, S y → P.le y x |
|
|
| def ContainsAnchors {α : Type u} (S : α → Prop) (e K : α) (F : α → Prop) : Prop := |
| S e ∧ S K ∧ ∀ f, F f → S f |
|
|
| theorem profile_on_shadow {α : Type u} (P : MeetOrder α) |
| (c e K : α) (F Old : α → Prop) |
| (anchors : ContainsAnchors Old e K F) |
| (old_profile : ProfileOn P c e K F Old) |
| (e_not_le_K : ¬ P.le e K) |
| (x l : α) (above_e : P.le e x) |
| (shadow : ShadowIn P Old x l) : NodeProfile P c K F x := by |
| have part := shadow.right.left |
| have shadow_meet := shadow.right.right |
| have e_le_l : P.le e l := (part e anchors.left).mp above_e |
| have x_not_le_K : ¬ P.le x K := fun hx => e_not_le_K (P.trans above_e hx) |
| have positives : Positive P F x ↔ Positive P F l := by |
| constructor |
| · intro hp |
| cases hp with |
| | intro f hf => |
| exact ⟨f, hf.left, (part f (anchors.right.right f hf.left)).mp hf.right⟩ |
| · intro hp |
| cases hp with |
| | intro f hf => |
| exact ⟨f, hf.left, (part f (anchors.right.right f hf.left)).mpr hf.right⟩ |
| have inherited := old_profile l shadow.left e_le_l |
| constructor |
| · intro hp |
| exact (part K anchors.right.left).mpr (inherited.left (positives.mp hp)) |
| · intro hn |
| have hn_old : ¬ Positive P F l := fun hp => hn (positives.mpr hp) |
| calc |
| P.meet K x = P.meet x K := meet_comm P _ _ |
| _ = P.meet l K := shadow_meet K anchors.right.left x_not_le_K |
| _ = P.meet K l := meet_comm P _ _ |
| _ = c := inherited.right hn_old |
|
|
| def SuccessorNodes {α : Type u} (P : MeetOrder α) (Old Current : α → Prop) : Prop := |
| ∀ x, Current x → |
| Old x ∨ (∃ l, ShadowIn P Old x l) ∨ GreatestIn P Current x |
|
|
| def StageCases {α : Type u} {I : Type v} (P : MeetOrder α) |
| (earlier : I → I → Prop) (Initial : α → Prop) (stage : I → α → Prop) |
| (i : I) : Prop := |
| (∀ x, stage i x → Initial x) ∨ |
| (∃ j, earlier j i ∧ SuccessorNodes P (stage j) (stage i)) ∨ |
| (∀ x, stage i x → ∃ j, earlier j i ∧ stage j x) |
|
|
| theorem profile_at_every_stage {α : Type u} {I : Type v} |
| (P : MeetOrder α) (c e K : α) (F Initial : α → Prop) |
| (earlier : I → I → Prop) (wf : WellFounded earlier) |
| (stage : I → α → Prop) |
| (nonempty_F : ∃ f, F f) |
| (e_not_le_K : ¬ P.le e K) |
| (initial_profile : ProfileOn P c e K F Initial) |
| (anchors : ∀ i, ContainsAnchors (stage i) e K F) |
| (cases_at : ∀ i, StageCases P earlier Initial stage i) : |
| ∀ i, ProfileOn P c e K F (stage i) := by |
| intro i |
| apply wf.induction i |
| intro current ih |
| intro x hx above_e |
| cases cases_at current with |
| | inl initial => |
| exact initial_profile x (initial x hx) above_e |
| | inr growth => |
| cases growth with |
| | inl successor => |
| cases successor with |
| | intro old h => |
| have old_profile := ih old h.left |
| cases h.right x hx with |
| | inl old_node => exact old_profile x old_node above_e |
| | inr new_node => |
| cases new_node with |
| | inl has_shadow => |
| cases has_shadow with |
| | intro l shadow => |
| exact profile_on_shadow P c e K F (stage old) (anchors old) |
| old_profile e_not_le_K x l above_e shadow |
| | inr top => |
| constructor |
| · intro _ |
| exact top K (anchors current).right.left |
| · intro hn |
| cases nonempty_F with |
| | intro f hf => |
| exact False.elim (hn ⟨f, hf, top f ((anchors current).right.right f hf)⟩) |
| | inr limit => |
| cases limit x hx with |
| | intro old h => exact ih old h.left x h.right above_e |
|
|
| theorem profile_persists_through_growth {α : Type u} {I : Type v} |
| (P : MeetOrder α) (c e K : α) (F Initial : α → Prop) |
| (earlier : I → I → Prop) (wf : WellFounded earlier) |
| (stage : I → α → Prop) |
| (nonempty_F : ∃ f, F f) |
| (e_not_le_K : ¬ P.le e K) |
| (initial_profile : ProfileOn P c e K F Initial) |
| (anchors : ∀ i, ContainsAnchors (stage i) e K F) |
| (cases_at : ∀ i, StageCases P earlier Initial stage i) |
| (covers : ∀ x, ∃ i, stage i x) : |
| Profile P c e K F := by |
| have at_stage := profile_at_every_stage P c e K F Initial earlier wf stage |
| nonempty_F e_not_le_K initial_profile anchors cases_at |
| intro x above_e |
| cases covers x with |
| | intro i hi => exact at_stage i x hi above_e |
|
|
| end |
|
|
|
|
|
|
| namespace Attachment |
|
|
| universe u v w |
|
|
| structure Data {O : Type u} (P : MeetOrder O) (N : Type v) (I : Type w) where |
| component : N → I |
| base : I → O |
| upper : I → O → Prop |
| upper_up : ∀ i {a b}, upper i a → P.le a b → upper i b |
| upper_meet : ∀ i {a b}, upper i a → upper i b → upper i (P.meet a b) |
| base_le_upper : ∀ i a, upper i a → P.le (base i) a |
| base_not_upper : ∀ i, ¬ upper i (base i) |
| shadow : N → O |
| shadow_le_base : ∀ x, P.le (shadow x) (base (component x)) |
| inside : N → N → Prop |
| inside_refl : ∀ x, inside x x |
| inside_trans : ∀ {x y z}, inside x y → inside y z → inside x z |
| inside_antisymm : ∀ {x y}, inside x y → inside y x → x = y |
| inside_component : ∀ {x y}, inside x y → component x = component y |
| inside_shadow : ∀ {x y}, inside x y → P.le (shadow x) (shadow y) |
|
|
| variable {O : Type u} {N : Type v} {I : Type w} {P : MeetOrder O} |
|
|
| def FreshLe (d : Data P N I) (x y : N) : Prop := |
| d.inside x y ∨ d.upper (d.component x) (d.shadow y) |
|
|
| def Le (d : Data P N I) : O ⊕ N → O ⊕ N → Prop |
| | .inl a, .inl b => P.le a b |
| | .inl a, .inr y => P.le a (d.shadow y) |
| | .inr x, .inl b => d.upper (d.component x) b |
| | .inr x, .inr y => FreshLe d x y |
|
|
| theorem not_upper_shadow (d : Data P N I) (x : N) : |
| ¬ d.upper (d.component x) (d.shadow x) := by |
| intro h |
| exact d.base_not_upper _ (d.upper_up _ h (d.shadow_le_base x)) |
|
|
| theorem fresh_shadow_mono (d : Data P N I) {x y : N} |
| (h : FreshLe d x y) : P.le (d.shadow x) (d.shadow y) := by |
| cases h with |
| | inl h => exact d.inside_shadow h |
| | inr h => exact P.trans (d.shadow_le_base x) (d.base_le_upper _ _ h) |
|
|
| theorem fresh_trans (d : Data P N I) {x y z : N} |
| (hxy : FreshLe d x y) (hyz : FreshLe d y z) : FreshLe d x z := by |
| cases hxy with |
| | inl hxy => |
| cases hyz with |
| | inl hyz => exact Or.inl (d.inside_trans hxy hyz) |
| | inr hyz => |
| exact Or.inr ((d.inside_component hxy).symm ▸ hyz) |
| | inr hxy => exact Or.inr (d.upper_up _ hxy (fresh_shadow_mono d hyz)) |
|
|
| theorem fresh_antisymm (d : Data P N I) {x y : N} |
| (hxy : FreshLe d x y) (hyx : FreshLe d y x) : x = y := by |
| cases hxy with |
| | inl hxy => |
| cases hyx with |
| | inl hyx => exact d.inside_antisymm hxy hyx |
| | inr hyx => |
| exact False.elim (not_upper_shadow d x ((d.inside_component hxy).symm ▸ hyx)) |
| | inr hxy => |
| exact False.elim (not_upper_shadow d x (d.upper_up _ hxy (fresh_shadow_mono d hyx))) |
|
|
| theorem le_refl (d : Data P N I) (x : O ⊕ N) : Le d x x := by |
| cases x with |
| | inl a => exact P.refl a |
| | inr x => exact Or.inl (d.inside_refl x) |
|
|
| theorem le_trans (d : Data P N I) {x y z : O ⊕ N} |
| (hxy : Le d x y) (hyz : Le d y z) : Le d x z := by |
| cases x with |
| | inl a => |
| cases y with |
| | inl b => |
| cases z with |
| | inl c => exact P.trans hxy hyz |
| | inr z => exact P.trans hxy hyz |
| | inr y => |
| cases z with |
| | inl c => exact P.trans hxy (P.trans (d.shadow_le_base y) (d.base_le_upper _ _ hyz)) |
| | inr z => exact P.trans hxy (fresh_shadow_mono d hyz) |
| | inr x => |
| cases y with |
| | inl b => |
| cases z with |
| | inl c => exact d.upper_up _ hxy hyz |
| | inr z => exact Or.inr (d.upper_up _ hxy hyz) |
| | inr y => |
| cases z with |
| | inl c => |
| cases hxy with |
| | inl hxy => |
| change d.upper (d.component x) c |
| exact (d.inside_component hxy).symm ▸ hyz |
| | inr hxy => |
| exact d.upper_up _ hxy (P.trans (d.shadow_le_base y) (d.base_le_upper _ _ hyz)) |
| | inr z => exact fresh_trans d hxy hyz |
|
|
| theorem le_antisymm (d : Data P N I) {x y : O ⊕ N} |
| (hxy : Le d x y) (hyx : Le d y x) : x = y := by |
| cases x with |
| | inl a => |
| cases y with |
| | inl b => exact congrArg Sum.inl (P.antisymm hxy hyx) |
| | inr y => exact False.elim (not_upper_shadow d y (d.upper_up _ hyx hxy)) |
| | inr x => |
| cases y with |
| | inl b => exact False.elim (not_upper_shadow d x (d.upper_up _ hxy hyx)) |
| | inr y => exact congrArg Sum.inr (fresh_antisymm d hxy hyx) |
|
|
| theorem fresh_same_component (d : Data P N I) {x y : N} |
| (same : d.component x = d.component y) : |
| FreshLe d x y ↔ d.inside x y := by |
| constructor |
| · intro h |
| cases h with |
| | inl h => exact h |
| | inr h => exact False.elim (not_upper_shadow d y (same ▸ h)) |
| · exact Or.inl |
|
|
| theorem fresh_different_components (d : Data P N I) {x y : N} |
| (different : d.component x ≠ d.component y) : |
| FreshLe d x y ↔ d.upper (d.component x) (d.shadow y) := by |
| constructor |
| · intro h |
| cases h with |
| | inl h => exact False.elim (different (d.inside_component h)) |
| | inr h => exact h |
| · exact Or.inr |
|
|
| def IsMeet (d : Data P N I) (a b m : O ⊕ N) : Prop := |
| Le d m a ∧ Le d m b ∧ ∀ t, Le d t a → Le d t b → Le d t m |
|
|
| theorem old_meet (d : Data P N I) (a b : O) : |
| IsMeet d (.inl a) (.inl b) (.inl (P.meet a b)) := by |
| refine ⟨P.meet_le_left a b, P.meet_le_right a b, ?_⟩ |
| intro t hta htb |
| cases t with |
| | inl c => exact P.le_meet hta htb |
| | inr x => exact d.upper_meet _ hta htb |
|
|
| theorem shadow_meet (d : Data P N I) (x : N) (a : O) |
| (not_above : ¬ d.upper (d.component x) a) : |
| IsMeet d (.inr x) (.inl a) (.inl (P.meet (d.shadow x) a)) := by |
| refine ⟨P.meet_le_left _ _, P.meet_le_right _ _, ?_⟩ |
| intro t htx hta |
| cases t with |
| | inl b => exact P.le_meet htx hta |
| | inr y => |
| cases htx with |
| | inl inside => exact False.elim (not_above (d.inside_component inside ▸ hta)) |
| | inr mediated => exact d.upper_meet _ mediated hta |
|
|
| theorem cross_meet (d : Data P N I) (x z : N) |
| (different : d.component x ≠ d.component z) |
| (not_xz : ¬ FreshLe d x z) (not_zx : ¬ FreshLe d z x) : |
| IsMeet d (.inr x) (.inr z) (.inl (P.meet (d.shadow x) (d.shadow z))) := by |
| refine ⟨P.meet_le_left _ _, P.meet_le_right _ _, ?_⟩ |
| intro t htx htz |
| cases t with |
| | inl b => exact P.le_meet htx htz |
| | inr y => |
| cases htx with |
| | inl hyx => |
| cases htz with |
| | inl hyz => |
| exact False.elim (different ((d.inside_component hyx).symm.trans (d.inside_component hyz))) |
| | inr hyz => exact False.elim (not_xz (Or.inr (d.inside_component hyx ▸ hyz))) |
| | inr hyx => |
| cases htz with |
| | inl hyz => exact False.elim (not_zx (Or.inr (d.inside_component hyz ▸ hyx))) |
| | inr hyz => exact d.upper_meet _ hyx hyz |
|
|
| def ComponentMeets (d : Data P N I) : Prop := |
| ∀ x z, d.component x = d.component z → |
| (∃ m, d.inside m x ∧ d.inside m z ∧ |
| (∀ y, d.inside y x → d.inside y z → d.inside y m) ∧ |
| d.shadow m = P.meet (d.shadow x) (d.shadow z)) ∨ |
| (∀ y, d.inside y x → d.inside y z → False) |
|
|
| theorem inside_mediated_impossible (d : Data P N I) {y x z : N} |
| (inside : d.inside y x) (same : d.component x = d.component z) |
| (mediated : d.upper (d.component y) (d.shadow z)) : False := by |
| exact not_upper_shadow d z ((d.inside_component inside).trans same ▸ mediated) |
|
|
| theorem component_fresh_meet (d : Data P N I) (x z m : N) |
| (same : d.component x = d.component z) |
| (hmx : d.inside m x) (hmz : d.inside m z) |
| (greatest : ∀ y, d.inside y x → d.inside y z → d.inside y m) |
| (shadows : d.shadow m = P.meet (d.shadow x) (d.shadow z)) : |
| IsMeet d (.inr x) (.inr z) (.inr m) := by |
| refine ⟨Or.inl hmx, Or.inl hmz, ?_⟩ |
| intro t htx htz |
| cases t with |
| | inl a => |
| change P.le a (d.shadow m) |
| rw [shadows] |
| exact P.le_meet htx htz |
| | inr y => |
| cases htx with |
| | inl hyx => |
| cases htz with |
| | inl hyz => exact Or.inl (greatest y hyx hyz) |
| | inr hyz => exact False.elim (inside_mediated_impossible d hyx same hyz) |
| | inr hyx => |
| cases htz with |
| | inl hyz => exact False.elim (inside_mediated_impossible d hyz same.symm hyx) |
| | inr hyz => |
| apply Or.inr |
| rw [shadows] |
| exact d.upper_meet _ hyx hyz |
|
|
| theorem component_old_meet (d : Data P N I) (x z : N) |
| (same : d.component x = d.component z) |
| (no_new_lower : ∀ y, d.inside y x → d.inside y z → False) : |
| IsMeet d (.inr x) (.inr z) (.inl (P.meet (d.shadow x) (d.shadow z))) := by |
| refine ⟨P.meet_le_left _ _, P.meet_le_right _ _, ?_⟩ |
| intro t htx htz |
| cases t with |
| | inl a => exact P.le_meet htx htz |
| | inr y => |
| cases htx with |
| | inl hyx => |
| cases htz with |
| | inl hyz => exact False.elim (no_new_lower y hyx hyz) |
| | inr hyz => exact False.elim (inside_mediated_impossible d hyx same hyz) |
| | inr hyx => |
| cases htz with |
| | inl hyz => exact False.elim (inside_mediated_impossible d hyz same.symm hyx) |
| | inr hyz => exact d.upper_meet _ hyx hyz |
|
|
| theorem meet_of_le (d : Data P N I) {a b : O ⊕ N} (h : Le d a b) : |
| IsMeet d a b a := ⟨le_refl d a, h, fun _ hta _ => hta⟩ |
|
|
| theorem meet_symm (d : Data P N I) {a b m : O ⊕ N} |
| (h : IsMeet d a b m) : IsMeet d b a m := |
| ⟨h.right.left, h.left, fun t htb hta => h.right.right t hta htb⟩ |
|
|
| theorem all_meets (d : Data P N I) (local_meets : ComponentMeets d) |
| (a b : O ⊕ N) : ∃ m, IsMeet d a b m := by |
| classical |
| cases a with |
| | inl a => |
| cases b with |
| | inl b => exact ⟨_, old_meet d a b⟩ |
| | inr y => |
| by_cases h : d.upper (d.component y) a |
| · exact ⟨_, meet_symm d (meet_of_le d h)⟩ |
| · exact ⟨_, meet_symm d (shadow_meet d y a h)⟩ |
| | inr x => |
| cases b with |
| | inl b => |
| by_cases h : d.upper (d.component x) b |
| · exact ⟨_, meet_of_le d h⟩ |
| · exact ⟨_, shadow_meet d x b h⟩ |
| | inr z => |
| by_cases same : d.component x = d.component z |
| · cases local_meets x z same with |
| | inl fresh => |
| rcases fresh with ⟨m, hmx, hmz, greatest, shadows⟩ |
| exact ⟨_, component_fresh_meet d x z m same hmx hmz greatest shadows⟩ |
| | inr old => exact ⟨_, component_old_meet d x z same old⟩ |
| · by_cases h : FreshLe d x z |
| · exact ⟨_, meet_of_le d h⟩ |
| · by_cases h' : FreshLe d z x |
| · exact ⟨_, meet_symm d (meet_of_le d h')⟩ |
| · exact ⟨_, cross_meet d x z same h h'⟩ |
|
|
| noncomputable def meetOrder (d : Data P N I) (local_meets : ComponentMeets d) : |
| MeetOrder (O ⊕ N) where |
| le := Le d |
| meet a b := Classical.choose (all_meets d local_meets a b) |
| refl := le_refl d |
| trans := le_trans d |
| antisymm := le_antisymm d |
| meet_le_left a b := (Classical.choose_spec (all_meets d local_meets a b)).left |
| meet_le_right a b := (Classical.choose_spec (all_meets d local_meets a b)).right.left |
| le_meet hab hac := (Classical.choose_spec (all_meets d local_meets _ _)).right.right _ hab hac |
|
|
| theorem meet_eq (d : Data P N I) (local_meets : ComponentMeets d) |
| {a b m : O ⊕ N} (h : IsMeet d a b m) : |
| (meetOrder d local_meets).meet a b = m := by |
| let Q := meetOrder d local_meets |
| apply le_antisymm d |
| · exact h.right.right _ (Q.meet_le_left a b) (Q.meet_le_right a b) |
| · exact Q.le_meet h.left h.right.left |
|
|
| noncomputable def oldEmbedding (d : Data P N I) (local_meets : ComponentMeets d) : |
| MeetEmbedding P (meetOrder d local_meets) where |
| toFun := Sum.inl |
| le_iff _ _ := Iff.rfl |
| map_meet a b := (meet_eq d local_meets (old_meet d a b)).symm |
|
|
| theorem has_old_shadow (d : Data P N I) (local_meets : ComponentMeets d) (x : N) : |
| HasOldShadow (oldEmbedding d local_meets) (.inr x) := by |
| refine ⟨d.shadow x, fun _ => Iff.rfl, ?_⟩ |
| intro a h |
| exact meet_eq d local_meets (shadow_meet d x a h) |
|
|
| theorem permitted_extension (d : Data P N I) (local_meets : ComponentMeets d) : |
| PermittedExtension (oldEmbedding d local_meets) := by |
| intro x |
| cases x with |
| | inl a => exact Or.inl ⟨a, rfl⟩ |
| | inr x => exact Or.inr (Or.inl (has_old_shadow d local_meets x)) |
|
|
| theorem attachment_preserves_profile (d : Data P N I) (local_meets : ComponentMeets d) |
| (c e K : O) (F : O → Prop) (nonempty_F : ∃ f, F f) |
| (old_profile : Profile P c e K F) (e_not_le_K : ¬ P.le e K) : |
| ProfileOver (oldEmbedding d local_meets) c e K F := |
| profile_persists_one_step (oldEmbedding d local_meets) c e K F |
| nonempty_F old_profile e_not_le_K (permitted_extension d local_meets) |
|
|
| end Attachment |
|
|
|
|
|
|
| namespace Attachment |
|
|
| universe u v w |
|
|
| def idealOrder {A : Type v} (Q : MeetOrder A) (a : A) : |
| MeetOrder {x : A // Q.le x a} where |
| le x y := Q.le x.val y.val |
| meet x y := ⟨Q.meet x.val y.val, Q.trans (Q.meet_le_left _ _) x.property⟩ |
| refl x := Q.refl x.val |
| trans hxy hyz := Q.trans hxy hyz |
| antisymm hxy hyx := Subtype.ext (Q.antisymm hxy hyx) |
| meet_le_left x y := Q.meet_le_left x.val y.val |
| meet_le_right x y := Q.meet_le_right x.val y.val |
| le_meet hxy hxz := Q.le_meet hxy hxz |
|
|
| def cut {A : Type v} (Q : MeetOrder A) (a x : A) : {y : A // Q.le y a} := |
| ⟨Q.meet x a, Q.meet_le_right x a⟩ |
|
|
| theorem cut_mono {A : Type v} (Q : MeetOrder A) (a : A) {x y : A} |
| (h : Q.le x y) : (idealOrder Q a).le (cut Q a x) (cut Q a y) := |
| Q.le_meet (Q.trans (Q.meet_le_left x a) h) (Q.meet_le_right x a) |
|
|
| theorem cut_meet {A : Type v} (Q : MeetOrder A) (a x y : A) : |
| cut Q a (Q.meet x y) = (idealOrder Q a).meet (cut Q a x) (cut Q a y) := by |
| apply Subtype.ext |
| change Q.meet (Q.meet x y) a = Q.meet (Q.meet x a) (Q.meet y a) |
| apply Q.antisymm |
| · apply Q.le_meet |
| · exact Q.le_meet (Q.trans (Q.meet_le_left _ _) (Q.meet_le_left x y)) (Q.meet_le_right _ _) |
| · exact Q.le_meet (Q.trans (Q.meet_le_left _ _) (Q.meet_le_right x y)) (Q.meet_le_right _ _) |
| · apply Q.le_meet |
| · exact Q.le_meet (Q.trans (Q.meet_le_left _ _) (Q.meet_le_left x a)) |
| (Q.trans (Q.meet_le_right _ _) (Q.meet_le_left y a)) |
| · exact Q.trans (Q.meet_le_left _ _) (Q.meet_le_right x a) |
|
|
| theorem cut_of_le {A : Type v} (Q : MeetOrder A) (a x : A) (h : Q.le x a) : |
| cut Q a x = ⟨x, h⟩ := by |
| apply Subtype.ext |
| exact Q.antisymm (Q.meet_le_left x a) (Q.le_meet (Q.refl x) h) |
|
|
| structure Templates {O : Type u} (P : MeetOrder O) (I : Type w) where |
| Space : I → Type v |
| order : ∀ i, MeetOrder (Space i) |
| anchor : ∀ i, Space i |
| embed : ∀ i, MeetEmbedding (idealOrder (order i) (anchor i)) P |
| upper : I → O → Prop |
| upper_nonempty : ∀ i, ∃ a, upper i a |
| upper_up : ∀ i {a b}, upper i a → P.le a b → upper i b |
| upper_meet : ∀ i {a b}, upper i a → upper i b → upper i (P.meet a b) |
| separator : I → O |
| base_le_separator : ∀ i, |
| P.le ((embed i).toFun ⟨anchor i, (order i).refl _⟩) (separator i) |
| separator_not_le_base : ∀ i, |
| ¬ P.le (separator i) ((embed i).toFun ⟨anchor i, (order i).refl _⟩) |
| separator_le_upper : ∀ i a, upper i a → P.le (separator i) a |
|
|
| namespace Templates |
|
|
| variable {O : Type u} {I : Type w} {P : MeetOrder O} (b : Templates.{u,v,w} P I) |
|
|
| def Fresh := (i : I) × {y : b.Space i // ¬ (b.order i).le y (b.anchor i)} |
|
|
| def base (i : I) : O := (b.embed i).toFun ⟨b.anchor i, (b.order i).refl _⟩ |
|
|
| def shadow (x : b.Fresh) : O := (b.embed x.1).toFun (cut (b.order x.1) (b.anchor x.1) x.2.val) |
|
|
| def Inside (x y : b.Fresh) : Prop := |
| ∃ h : x.1 = y.1, (b.order x.1).le x.2.val (h.symm ▸ y.2.val) |
|
|
| theorem inside_refl (x : b.Fresh) : b.Inside x x := ⟨rfl, (b.order x.1).refl x.2.val⟩ |
|
|
| theorem inside_trans {x y z : b.Fresh} (hxy : b.Inside x y) (hyz : b.Inside y z) : |
| b.Inside x z := by |
| rcases x with ⟨i, x⟩ |
| rcases y with ⟨j, y⟩ |
| rcases z with ⟨k, z⟩ |
| rcases hxy with ⟨hij, hxy⟩ |
| cases hij |
| rcases hyz with ⟨hjk, hyz⟩ |
| cases hjk |
| exact ⟨rfl, (b.order i).trans hxy hyz⟩ |
|
|
| theorem inside_antisymm {x y : b.Fresh} (hxy : b.Inside x y) (hyx : b.Inside y x) : |
| x = y := by |
| rcases x with ⟨i, x⟩ |
| rcases y with ⟨j, y⟩ |
| rcases hxy with ⟨hij, hxy⟩ |
| cases hij |
| rcases hyx with ⟨hii, hyx⟩ |
| cases hii |
| exact congrArg (Sigma.mk i) (Subtype.ext ((b.order i).antisymm hxy hyx)) |
|
|
| theorem inside_shadow {x y : b.Fresh} (hxy : b.Inside x y) : |
| P.le (b.shadow x) (b.shadow y) := by |
| rcases x with ⟨i, x⟩ |
| rcases y with ⟨j, y⟩ |
| rcases hxy with ⟨hij, hxy⟩ |
| cases hij |
| exact ((b.embed i).le_iff _ _).mpr (cut_mono (b.order i) (b.anchor i) hxy) |
|
|
| def data : Data P b.Fresh I where |
| component := Sigma.fst |
| base := b.base |
| upper := b.upper |
| upper_up := b.upper_up |
| upper_meet := b.upper_meet |
| base_le_upper i a h := P.trans (b.base_le_separator i) (b.separator_le_upper i a h) |
| base_not_upper i h := b.separator_not_le_base i (b.separator_le_upper i (b.base i) h) |
| shadow := b.shadow |
| shadow_le_base x := ((b.embed x.1).le_iff _ _).mpr ((b.order x.1).meet_le_right _ _) |
| inside := b.Inside |
| inside_refl := b.inside_refl |
| inside_trans := b.inside_trans |
| inside_antisymm := b.inside_antisymm |
| inside_component h := h.choose |
| inside_shadow := b.inside_shadow |
|
|
| theorem mapped_cut_meet (i : I) (x y : b.Space i) : |
| (b.embed i).toFun (cut (b.order i) (b.anchor i) ((b.order i).meet x y)) = |
| P.meet ((b.embed i).toFun (cut (b.order i) (b.anchor i) x)) |
| ((b.embed i).toFun (cut (b.order i) (b.anchor i) y)) := by |
| rw [cut_meet] |
| exact (b.embed i).map_meet _ _ |
|
|
| theorem component_meets : ComponentMeets b.data := by |
| classical |
| intro x z same |
| rcases x with ⟨i, x⟩ |
| rcases z with ⟨j, z⟩ |
| change i = j at same |
| cases same |
| by_cases old : (b.order i).le ((b.order i).meet x.val z.val) (b.anchor i) |
| · apply Or.inr |
| intro y hyx hyz |
| rcases y with ⟨k, y⟩ |
| rcases hyx with ⟨hki, hyx⟩ |
| cases hki |
| rcases hyz with ⟨hkk, hyz⟩ |
| cases hkk |
| exact y.property ((b.order i).trans ((b.order i).le_meet hyx hyz) old) |
| · apply Or.inl |
| let m : b.Fresh := ⟨i, ⟨(b.order i).meet x.val z.val, old⟩⟩ |
| refine ⟨m, ⟨rfl, (b.order i).meet_le_left _ _⟩, ⟨rfl, (b.order i).meet_le_right _ _⟩, ?_, ?_⟩ |
| · intro y hyx hyz |
| rcases y with ⟨k, y⟩ |
| rcases hyx with ⟨hki, hyx⟩ |
| cases hki |
| rcases hyz with ⟨hkk, hyz⟩ |
| cases hkk |
| exact ⟨rfl, (b.order i).le_meet hyx hyz⟩ |
| · exact b.mapped_cut_meet i x.val z.val |
|
|
| noncomputable def extension : MeetOrder (O ⊕ b.Fresh) := meetOrder b.data b.component_meets |
|
|
| noncomputable def oldEmbedding : MeetEmbedding P b.extension := |
| Attachment.oldEmbedding b.data b.component_meets |
|
|
| theorem shadow_verified (x : b.Fresh) : HasOldShadow b.oldEmbedding (.inr x) := |
| has_old_shadow b.data b.component_meets x |
|
|
| theorem persistence (c e K : O) (F : O → Prop) (nonempty_F : ∃ f, F f) |
| (old_profile : Profile P c e K F) (e_not_le_K : ¬ P.le e K) : |
| ProfileOver b.oldEmbedding c e K F := |
| attachment_preserves_profile b.data b.component_meets c e K F nonempty_F old_profile e_not_le_K |
|
|
| noncomputable def represent (i : I) (y : b.Space i) : O ⊕ b.Fresh := by |
| classical |
| exact if h : (b.order i).le y (b.anchor i) then |
| .inl ((b.embed i).toFun ⟨y, h⟩) |
| else .inr ⟨i, ⟨y, h⟩⟩ |
|
|
| theorem represent_old (i : I) (y : b.Space i) (h : (b.order i).le y (b.anchor i)) : |
| b.represent i y = .inl ((b.embed i).toFun ⟨y, h⟩) := by |
| simp only [represent, dite_eq_left h] |
|
|
| theorem represent_new (i : I) (y : b.Space i) (h : ¬ (b.order i).le y (b.anchor i)) : |
| b.represent i y = .inr ⟨i, ⟨y, h⟩⟩ := by |
| simp only [represent, dite_eq_right h] |
|
|
| theorem represent_le_iff (i : I) (x y : b.Space i) : |
| Le b.data (b.represent i x) (b.represent i y) ↔ (b.order i).le x y := by |
| classical |
| by_cases hx : (b.order i).le x (b.anchor i) |
| · rw [b.represent_old i x hx] |
| by_cases hy : (b.order i).le y (b.anchor i) |
| · rw [b.represent_old i y hy] |
| exact (b.embed i).le_iff _ _ |
| · rw [b.represent_new i y hy] |
| change P.le ((b.embed i).toFun ⟨x, hx⟩) |
| ((b.embed i).toFun (cut (b.order i) (b.anchor i) y)) ↔ _ |
| rw [(b.embed i).le_iff] |
| constructor |
| · intro h |
| exact (b.order i).trans h ((b.order i).meet_le_left y (b.anchor i)) |
| · intro h |
| exact (b.order i).le_meet h hx |
| · rw [b.represent_new i x hx] |
| by_cases hy : (b.order i).le y (b.anchor i) |
| · rw [b.represent_old i y hy] |
| constructor |
| · intro h |
| have hbase : P.le ((b.embed i).toFun ⟨y, hy⟩) (b.base i) := |
| ((b.embed i).le_iff _ _).mpr hy |
| exact False.elim (b.data.base_not_upper i (b.upper_up i h hbase)) |
| · intro h |
| exact False.elim (hx ((b.order i).trans h hy)) |
| · rw [b.represent_new i y hy] |
| change FreshLe b.data ⟨i, ⟨x, hx⟩⟩ ⟨i, ⟨y, hy⟩⟩ ↔ _ |
| rw [fresh_same_component b.data (x := ⟨i, ⟨x, hx⟩⟩) (y := ⟨i, ⟨y, hy⟩⟩) rfl] |
| constructor |
| · rintro ⟨h, hxy⟩ |
| cases h |
| exact hxy |
| · intro hxy |
| exact ⟨rfl, hxy⟩ |
|
|
| theorem old_below_represent (i : I) (y : b.Space i) (a : O) : |
| Le b.data (.inl a) (b.represent i y) ↔ |
| P.le a ((b.embed i).toFun (cut (b.order i) (b.anchor i) y)) := by |
| classical |
| by_cases hy : (b.order i).le y (b.anchor i) |
| · rw [b.represent_old i y hy, cut_of_le _ _ _ hy] |
| exact Iff.rfl |
| · rw [b.represent_new i y hy] |
| exact Iff.rfl |
|
|
| theorem upper_shadow_below_represent (i : I) (y : b.Space i) (x : b.Fresh) |
| (h : b.upper x.1 ((b.embed i).toFun (cut (b.order i) (b.anchor i) y))) : |
| Le b.data (.inr x) (b.represent i y) := by |
| classical |
| by_cases hy : (b.order i).le y (b.anchor i) |
| · rw [b.represent_old i y hy] |
| rw [cut_of_le _ _ _ hy] at h |
| exact h |
| · rw [b.represent_new i y hy] |
| exact Or.inr h |
|
|
| theorem foreign_below_represent (i : I) (y : b.Space i) (x : b.Fresh) |
| (different : x.1 ≠ i) |
| (h : Le b.data (.inr x) (b.represent i y)) : |
| b.upper x.1 ((b.embed i).toFun (cut (b.order i) (b.anchor i) y)) := by |
| classical |
| by_cases hy : (b.order i).le y (b.anchor i) |
| · rw [b.represent_old i y hy] at h |
| rw [cut_of_le _ _ _ hy] |
| exact h |
| · rw [b.represent_new i y hy] at h |
| exact (fresh_different_components b.data (x := x) (y := ⟨i, ⟨y, hy⟩⟩) different).mp h |
|
|
| theorem represented_meet (i : I) (x z : b.Space i) : |
| IsMeet b.data (b.represent i x) (b.represent i z) |
| (b.represent i ((b.order i).meet x z)) := by |
| classical |
| refine ⟨(b.represent_le_iff i _ _).mpr ((b.order i).meet_le_left x z), |
| (b.represent_le_iff i _ _).mpr ((b.order i).meet_le_right x z), ?_⟩ |
| intro t htx htz |
| cases t with |
| | inl a => |
| apply (b.old_below_represent i _ a).mpr |
| rw [b.mapped_cut_meet] |
| exact P.le_meet ((b.old_below_represent i x a).mp htx) |
| ((b.old_below_represent i z a).mp htz) |
| | inr y => |
| rcases y with ⟨j, y⟩ |
| by_cases same : j = i |
| · cases same |
| have repr_y := b.represent_new i y.val y.property |
| rw [← repr_y] at htx htz ⊢ |
| apply (b.represent_le_iff i _ _).mpr |
| exact (b.order i).le_meet ((b.represent_le_iff i _ _).mp htx) |
| ((b.represent_le_iff i _ _).mp htz) |
| · apply b.upper_shadow_below_represent |
| rw [b.mapped_cut_meet] |
| exact b.upper_meet j (b.foreign_below_represent i x ⟨j, y⟩ same htx) |
| (b.foreign_below_represent i z ⟨j, y⟩ same htz) |
|
|
| noncomputable def templateEmbedding (i : I) : MeetEmbedding (b.order i) b.extension where |
| toFun := b.represent i |
| le_iff := b.represent_le_iff i |
| map_meet x z := (meet_eq b.data b.component_meets (b.represented_meet i x z)).symm |
|
|
| theorem template_agrees_on_base (i : I) (y : b.Space i) |
| (hy : (b.order i).le y (b.anchor i)) : |
| (b.templateEmbedding i).toFun y = .inl ((b.embed i).toFun ⟨y, hy⟩) := |
| b.represent_old i y hy |
|
|
| theorem greatest_preserved (T : O) (top : ∀ a, P.le a T) : |
| ∀ x, b.extension.le x (.inl T) := by |
| intro x |
| cases x with |
| | inl a => exact top a |
| | inr x => |
| rcases b.upper_nonempty x.1 with ⟨a, ha⟩ |
| exact b.upper_up x.1 ha (top a) |
|
|
| theorem least_preserved (zero : O) (bottom : ∀ a, P.le zero a) : |
| ∀ x, b.extension.le (.inl zero) x := by |
| intro x |
| cases x with |
| | inl a => exact bottom a |
| | inr x => exact bottom (b.shadow x) |
|
|
| theorem cross_meet_eq (x z : b.Fresh) (different : x.1 ≠ z.1) |
| (not_xz : ¬ b.extension.le (.inr x) (.inr z)) |
| (not_zx : ¬ b.extension.le (.inr z) (.inr x)) : |
| b.extension.meet (.inr x) (.inr z) = .inl (P.meet (b.shadow x) (b.shadow z)) := |
| meet_eq b.data b.component_meets (cross_meet b.data x z different not_xz not_zx) |
|
|
| theorem old_lower_iff (a : O) (x : b.Fresh) : |
| b.extension.le (.inl a) (.inr x) ↔ P.le a (b.shadow x) := Iff.rfl |
|
|
| theorem old_upper_iff (a : O) (x : b.Fresh) : |
| b.extension.le (.inr x) (.inl a) ↔ b.upper x.1 a := Iff.rfl |
|
|
| theorem cross_le_iff (x z : b.Fresh) (different : x.1 ≠ z.1) : |
| b.extension.le (.inr x) (.inr z) ↔ b.upper x.1 (b.shadow z) := |
| fresh_different_components b.data (x := x) (y := z) different |
|
|
| theorem shadow_meet_eq (x : b.Fresh) (a : O) |
| (not_above : ¬ b.extension.le (.inr x) (.inl a)) : |
| b.extension.meet (.inr x) (.inl a) = .inl (P.meet (b.shadow x) a) := |
| meet_eq b.data b.component_meets (shadow_meet b.data x a not_above) |
|
|
| theorem template_preserves_zero (i : I) (qzero : b.Space i) (zero : O) |
| (qbottom : ∀ y, (b.order i).le qzero y) |
| (base_zero : (b.embed i).toFun ⟨qzero, qbottom (b.anchor i)⟩ = zero) : |
| (b.templateEmbedding i).toFun qzero = .inl zero := by |
| rw [b.template_agrees_on_base i qzero (qbottom (b.anchor i)), base_zero] |
|
|
| end Templates |
| end Attachment |
|
|
|
|
|
|
|
|
| universe u v w |
|
|
| theorem meet_eq_left_of_le {A : Type u} (P : MeetOrder A) {x y : A} |
| (h : P.le x y) : P.meet x y = x := |
| P.antisymm (P.meet_le_left x y) (P.le_meet (P.refl x) h) |
|
|
| namespace Attachment.Templates |
|
|
| variable {O : Type u} {I : Type w} {P : MeetOrder O} (b : Templates.{u,v,w} P I) |
|
|
| def originalFamily (i : I) : O ⊕ b.Fresh → Prop |
| | .inl a => b.upper i a |
| | .inr _ => False |
|
|
| theorem positive_old_iff (i : I) (a : O) : |
| Positive b.extension (b.originalFamily i) (.inl a) ↔ b.upper i a := by |
| constructor |
| · rintro ⟨f, hf, hfa⟩ |
| cases f with |
| | inl f => exact b.upper_up i hf hfa |
| | inr f => exact False.elim hf |
| · intro ha |
| exact ⟨.inl a, ha, P.refl a⟩ |
|
|
| theorem positive_new_iff (i : I) (x : b.Fresh) : |
| Positive b.extension (b.originalFamily i) (.inr x) ↔ b.upper i (b.shadow x) := by |
| constructor |
| · rintro ⟨f, hf, hfx⟩ |
| cases f with |
| | inl f => exact b.upper_up i hf hfx |
| | inr f => exact False.elim hf |
| · intro hx |
| exact ⟨.inl (b.shadow x), hx, P.refl _⟩ |
|
|
| def cap (i : I) (t : b.Space i) (outside : ¬ (b.order i).le t (b.anchor i)) : b.Fresh := |
| ⟨i, ⟨t, outside⟩⟩ |
|
|
| theorem cap_shadow (i : I) (t : b.Space i) |
| (top : ∀ y, (b.order i).le y t) |
| (outside : ¬ (b.order i).le t (b.anchor i)) : |
| b.shadow (b.cap i t outside) = b.base i := by |
| change (b.embed i).toFun (cut (b.order i) (b.anchor i) t) = _ |
| have hcut : cut (b.order i) (b.anchor i) t = |
| ⟨b.anchor i, (b.order i).refl _⟩ := by |
| apply Subtype.ext |
| exact (b.order i).antisymm ((b.order i).meet_le_right _ _) |
| ((b.order i).le_meet (top _) ((b.order i).refl _)) |
| exact congrArg (b.embed i).toFun hcut |
|
|
| theorem cap_strict_above_base (i : I) (t : b.Space i) |
| (top : ∀ y, (b.order i).le y t) |
| (outside : ¬ (b.order i).le t (b.anchor i)) : |
| b.extension.le (.inl (b.base i)) (.inr (b.cap i t outside)) ∧ |
| ¬ b.extension.le (.inr (b.cap i t outside)) (.inl (b.base i)) := by |
| constructor |
| · change P.le (b.base i) (b.shadow (b.cap i t outside)) |
| rw [b.cap_shadow i t top outside] |
| exact P.refl _ |
| · exact b.data.base_not_upper i |
|
|
| theorem separator_not_below_cap (i : I) (t : b.Space i) |
| (top : ∀ y, (b.order i).le y t) |
| (outside : ¬ (b.order i).le t (b.anchor i)) : |
| ¬ b.extension.le (.inl (b.separator i)) (.inr (b.cap i t outside)) := by |
| intro h |
| change P.le (b.separator i) (b.shadow (b.cap i t outside)) at h |
| rw [b.cap_shadow i t top outside] at h |
| exact b.separator_not_le_base i h |
|
|
| theorem initial_profile (i : I) (t : b.Space i) |
| (top : ∀ y, (b.order i).le y t) |
| (outside : ¬ (b.order i).le t (b.anchor i)) : |
| Profile b.extension (.inl (b.base i)) (.inl (b.separator i)) |
| (.inr (b.cap i t outside)) (b.originalFamily i) := by |
| intro x above_e |
| cases x with |
| | inl a => |
| constructor |
| · intro hp |
| exact (b.positive_old_iff i a).mp hp |
| · intro hn |
| have not_upper : ¬ b.upper i a := fun ha => hn ((b.positive_old_iff i a).mpr ha) |
| calc |
| b.extension.meet (.inr (b.cap i t outside)) (.inl a) = |
| .inl (P.meet (b.shadow (b.cap i t outside)) a) := |
| b.shadow_meet_eq _ a not_upper |
| _ = .inl (P.meet (b.base i) a) := by rw [b.cap_shadow i t top outside] |
| _ = .inl (b.base i) := congrArg Sum.inl |
| (meet_eq_left_of_le P (P.trans (b.base_le_separator i) above_e)) |
| | inr x => |
| have different : i ≠ x.1 := by |
| intro same |
| have hs := b.data.shadow_le_base x |
| change P.le (b.shadow x) (b.base x.1) at hs |
| rw [← same] at hs |
| exact b.separator_not_le_base i (P.trans above_e hs) |
| have not_xk : ¬ b.extension.le (.inr x) (.inr (b.cap i t outside)) := by |
| intro h |
| exact b.separator_not_below_cap i t top outside (b.extension.trans above_e h) |
| constructor |
| · intro hp |
| exact (b.cross_le_iff _ x different).mpr ((b.positive_new_iff i x).mp hp) |
| · intro hn |
| have not_kx : ¬ b.extension.le (.inr (b.cap i t outside)) (.inr x) := by |
| intro h |
| exact hn ((b.positive_new_iff i x).mpr ((b.cross_le_iff _ x different).mp h)) |
| calc |
| b.extension.meet (.inr (b.cap i t outside)) (.inr x) = |
| .inl (P.meet (b.shadow (b.cap i t outside)) (b.shadow x)) := |
| b.cross_meet_eq _ x different not_kx not_xk |
| _ = .inl (P.meet (b.base i) (b.shadow x)) := by rw [b.cap_shadow i t top outside] |
| _ = .inl (b.base i) := congrArg Sum.inl |
| (meet_eq_left_of_le P (P.trans (b.base_le_separator i) above_e)) |
|
|
| theorem cap_alternatives (i j : I) (different : i ≠ j) |
| (ti : b.Space i) (tj : b.Space j) |
| (top_i : ∀ y, (b.order i).le y ti) (top_j : ∀ y, (b.order j).le y tj) |
| (outside_i : ¬ (b.order i).le ti (b.anchor i)) |
| (outside_j : ¬ (b.order j).le tj (b.anchor j)) : |
| b.extension.le (.inr (b.cap i ti outside_i)) (.inl (b.base j)) ∨ |
| b.extension.le (.inr (b.cap j tj outside_j)) (.inl (b.base i)) ∨ |
| b.extension.meet (.inr (b.cap i ti outside_i)) (.inr (b.cap j tj outside_j)) = |
| b.extension.meet (.inl (b.base i)) (.inl (b.base j)) := by |
| classical |
| by_cases hij : b.extension.le (.inr (b.cap i ti outside_i)) (.inr (b.cap j tj outside_j)) |
| · apply Or.inl |
| have h := (b.cross_le_iff _ _ different).mp hij |
| rw [b.cap_shadow j tj top_j outside_j] at h |
| exact h |
| · apply Or.inr |
| by_cases hji : b.extension.le (.inr (b.cap j tj outside_j)) (.inr (b.cap i ti outside_i)) |
| · apply Or.inl |
| have h := (b.cross_le_iff _ _ (Ne.symm different)).mp hji |
| rw [b.cap_shadow i ti top_i outside_i] at h |
| exact h |
| · apply Or.inr |
| rw [b.cross_meet_eq _ _ different hij hji, |
| b.cap_shadow i ti top_i outside_i, b.cap_shadow j tj top_j outside_j] |
| exact b.oldEmbedding.map_meet _ _ |
|
|
| theorem equal_base_caps_meet (i j : I) (different : i ≠ j) |
| (same_base : b.base i = b.base j) |
| (ti : b.Space i) (tj : b.Space j) |
| (top_i : ∀ y, (b.order i).le y ti) (top_j : ∀ y, (b.order j).le y tj) |
| (outside_i : ¬ (b.order i).le ti (b.anchor i)) |
| (outside_j : ¬ (b.order j).le tj (b.anchor j)) : |
| b.extension.meet (.inr (b.cap i ti outside_i)) (.inr (b.cap j tj outside_j)) = |
| .inl (b.base i) := by |
| have h := b.cap_alternatives i j different ti tj top_i top_j outside_i outside_j |
| cases h with |
| | inl h => |
| have h' : b.upper i (b.base j) := h |
| rw [← same_base] at h' |
| exact False.elim (b.data.base_not_upper i h') |
| | inr h => |
| cases h with |
| | inl h => |
| have h' : b.upper j (b.base i) := h |
| rw [same_base] at h' |
| exact False.elim (b.data.base_not_upper j h') |
| | inr h => |
| rw [← same_base] at h |
| exact h.trans (meet_eq_left_of_le b.extension (b.extension.refl _)) |
|
|
| theorem initial_profile_persists {A : Type v} {Q : MeetOrder A} |
| (next : MeetEmbedding b.extension Q) (allowed : PermittedExtension next) |
| (i : I) (t : b.Space i) (top : ∀ y, (b.order i).le y t) |
| (outside : ¬ (b.order i).le t (b.anchor i)) : |
| ProfileOver next (.inl (b.base i)) (.inl (b.separator i)) |
| (.inr (b.cap i t outside)) (b.originalFamily i) := by |
| have family_nonempty : ∃ f, b.originalFamily i f := by |
| rcases b.upper_nonempty i with ⟨f, hf⟩ |
| exact ⟨.inl f, hf⟩ |
| exact profile_persists_one_step next _ _ _ _ family_nonempty |
| (b.initial_profile i t top outside) (b.separator_not_below_cap i t top outside) allowed |
|
|
| end Attachment.Templates |
|
|
| namespace Compression |
|
|
| structure MeetFilter {A : Type u} (P : MeetOrder A) where |
| mem : A → Prop |
| nonempty : ∃ x, mem x |
| upward : ∀ {x y}, mem x → P.le x y → mem y |
| closed_meet : ∀ {x y}, mem x → mem y → mem (P.meet x y) |
|
|
| def pushFilter {A : Type u} {B : Type v} {P : MeetOrder A} {Q : MeetOrder B} |
| (s : MeetEmbedding P Q) (F : MeetFilter P) : MeetFilter Q where |
| mem y := ∃ x, F.mem x ∧ Q.le (s.toFun x) y |
| nonempty := by |
| rcases F.nonempty with ⟨x, hx⟩ |
| exact ⟨s.toFun x, x, hx, Q.refl _⟩ |
| upward := by |
| rintro a b ⟨x, hx, hxa⟩ hab |
| exact ⟨x, hx, Q.trans hxa hab⟩ |
| closed_meet := by |
| rintro a b ⟨x, hx, hxa⟩ ⟨y, hy, hyb⟩ |
| refine ⟨P.meet x y, F.closed_meet hx hy, ?_⟩ |
| rw [s.map_meet] |
| exact Q.le_meet (Q.trans (Q.meet_le_left _ _) hxa) |
| (Q.trans (Q.meet_le_right _ _) hyb) |
|
|
| theorem pushFilter_trace {A : Type u} {B : Type v} {P : MeetOrder A} {Q : MeetOrder B} |
| (s : MeetEmbedding P Q) (F : MeetFilter P) (x : A) : |
| (pushFilter s F).mem (s.toFun x) ↔ F.mem x := by |
| constructor |
| · rintro ⟨y, hy, hyx⟩ |
| exact F.upward hy ((s.le_iff y x).mp hyx) |
| · intro hx |
| exact ⟨x, hx, Q.refl _⟩ |
|
|
| theorem pushFilter_lower_bound {A : Type u} {B : Type v} {P : MeetOrder A} {Q : MeetOrder B} |
| (s : MeetEmbedding P Q) (F : MeetFilter P) (e : A) |
| (lower : ∀ f, F.mem f → P.le e f) : |
| ∀ y, (pushFilter s F).mem y → Q.le (s.toFun e) y := by |
| rintro y ⟨f, hf, hfy⟩ |
| exact Q.trans ((s.le_iff e f).mpr (lower f hf)) hfy |
|
|
| structure MeetIso {A : Type u} {B : Type v} (P : MeetOrder A) (Q : MeetOrder B) |
| extends MeetEmbedding P Q where |
| inverse : B → A |
| left_inverse : ∀ x, inverse (toFun x) = x |
| right_inverse : ∀ y, toFun (inverse y) = y |
|
|
| theorem filter_image_from_slice {A : Type u} (P : MeetOrder A) (F : MeetFilter P) |
| (g : MeetIso P P) (v : A) (hv : F.mem v) (y : A) : |
| (∃ f, F.mem f ∧ g.toFun f = y) ↔ |
| (∃ x, F.mem x ∧ P.le x v ∧ P.le (g.toFun x) y) := by |
| constructor |
| · rintro ⟨f, hf, rfl⟩ |
| exact ⟨P.meet f v, F.closed_meet hf hv, P.meet_le_right f v, |
| (g.le_iff _ _).mpr (P.meet_le_left f v)⟩ |
| · rintro ⟨x, hx, _, hxy⟩ |
| have hxinv : P.le x (g.inverse y) := by |
| apply (g.le_iff _ _).mp |
| rw [g.right_inverse] |
| exact hxy |
| exact ⟨g.inverse y, F.upward hx hxinv, g.right_inverse y⟩ |
|
|
| theorem filter_images_agree {A : Type u} (P : MeetOrder A) (F : MeetFilter P) |
| (g h : MeetIso P P) (v : A) (hv : F.mem v) |
| (agree : ∀ x, P.le x v → g.toFun x = h.toFun x) : |
| ∀ y, (∃ f, F.mem f ∧ g.toFun f = y) ↔ (∃ f, F.mem f ∧ h.toFun f = y) := by |
| intro y |
| rw [filter_image_from_slice P F g v hv, filter_image_from_slice P F h v hv] |
| constructor |
| · rintro ⟨x, hx, hxv, hxy⟩ |
| exact ⟨x, hx, hxv, agree x hxv ▸ hxy⟩ |
| · rintro ⟨x, hx, hxv, hxy⟩ |
| exact ⟨x, hx, hxv, (agree x hxv).symm ▸ hxy⟩ |
|
|
| theorem meet_insert_upper {A : Type u} (P : MeetOrder A) (x y a : A) |
| (hya : P.le y a) : P.meet x y = P.meet (P.meet x a) y := by |
| apply P.antisymm |
| · exact P.le_meet (P.le_meet (P.meet_le_left x y) (P.trans (P.meet_le_right x y) hya)) |
| (P.meet_le_right x y) |
| · exact P.le_meet (P.trans (P.meet_le_left _ _) (P.meet_le_left x a)) |
| (P.meet_le_right _ _) |
|
|
| theorem base_meet_patch {A : Type u} {B : Type v} (P : MeetOrder A) (Q : MeetOrder B) |
| (s : A → B) (g : MeetEmbedding P Q) (a : A) (c : B) |
| (ga : g.toFun a = c) |
| (agree : ∀ y, P.le y a → s y = g.toFun y) |
| (cut_law : ∀ x, Q.meet (s x) c = s (P.meet x a)) |
| (x y : A) (hya : P.le y a) : Q.meet (s x) (s y) = s (P.meet x y) := by |
| have syc : Q.le (s y) c := by |
| rw [agree y hya, ← ga] |
| exact (g.le_iff y a).mpr hya |
| calc |
| Q.meet (s x) (s y) = Q.meet (Q.meet (s x) c) (s y) := meet_insert_upper Q _ _ _ syc |
| _ = Q.meet (s (P.meet x a)) (s y) := by rw [cut_law] |
| _ = Q.meet (g.toFun (P.meet x a)) (g.toFun y) := by |
| rw [agree _ (P.meet_le_right x a), agree y hya] |
| _ = g.toFun (P.meet (P.meet x a) y) := (g.map_meet _ _).symm |
| _ = g.toFun (P.meet x y) := congrArg g.toFun (meet_insert_upper P x y a hya).symm |
| _ = s (P.meet x y) := (agree _ (P.trans (P.meet_le_right x y) hya)).symm |
|
|
| theorem base_ideal_filled {A : Type u} (P : MeetOrder A) (s : A → A) |
| (g : MeetIso P P) (a : A) |
| (agree : ∀ y, P.le y a → s y = g.toFun y) : |
| ∀ x, P.le x (g.toFun a) → ∃ y, s y = x := by |
| intro x hx |
| have hy : P.le (g.inverse x) a := by |
| apply (g.le_iff _ _).mp |
| rw [g.right_inverse] |
| exact hx |
| exact ⟨g.inverse x, (agree _ hy).trans (g.right_inverse x)⟩ |
|
|
| theorem range_completion_from_accounting {A : Type u} {J : Type v} |
| (P : MeetOrder A) (Original : A → Prop) (base cap : J → A) (s : J → A → A) |
| (base_filled : ∀ i x, P.le x (base i) → ∃ y, s i y = x) |
| (old_shadow : ∀ i x, Original x → P.le x (cap i) → P.le x (base i)) |
| (separation : ∀ i j, i ≠ j → |
| P.le (cap i) (base j) ∨ P.le (cap j) (base i) ∨ |
| P.meet (cap i) (cap j) = P.meet (base i) (base j)) |
| (accounting : ∀ x, Original x ∨ |
| ∃ j y, s j y = x ∧ P.le x (cap j) ∧ ¬ P.le x (base j)) : |
| ∀ i x, P.le x (cap i) → ∃ y, s i y = x := by |
| classical |
| intro i x hxi |
| cases accounting x with |
| | inl old => exact base_filled i x (old_shadow i x old hxi) |
| | inr new => |
| rcases new with ⟨j, y, hy, hxj, not_base⟩ |
| by_cases same : j = i |
| · cases same |
| exact ⟨y, hy⟩ |
| · cases separation j i same with |
| | inl hjci => exact base_filled i x (P.trans hxj hjci) |
| | inr h => |
| cases h with |
| | inl hicj => exact False.elim (not_base (P.trans hxi hicj)) |
| | inr hmeet => |
| have hxmeet : P.le x (P.meet (base j) (base i)) := hmeet ▸ P.le_meet hxj hxi |
| exact base_filled i x (P.trans hxmeet (P.meet_le_right _ _)) |
|
|
| theorem embedding_injective {A : Type u} {B : Type v} {P : MeetOrder A} {Q : MeetOrder B} |
| (s : MeetEmbedding P Q) {x y : A} (h : s.toFun x = s.toFun y) : x = y := by |
| apply P.antisymm |
| · apply (s.le_iff x y).mp |
| rw [h] |
| exact Q.refl _ |
| · apply (s.le_iff y x).mp |
| rw [h] |
| exact Q.refl _ |
|
|
| noncomputable def isoOntoIdeal {A : Type u} (P : MeetOrder A) |
| (s : MeetEmbedding P P) (k : A) |
| (below : ∀ x, P.le (s.toFun x) k) |
| (onto : ∀ z, P.le z k → ∃ x, s.toFun x = z) : |
| MeetIso P (Attachment.idealOrder P k) where |
| toFun x := ⟨s.toFun x, below x⟩ |
| le_iff x y := s.le_iff x y |
| map_meet x y := Subtype.ext (s.map_meet x y) |
| inverse z := Classical.choose (onto z.val z.property) |
| left_inverse x := embedding_injective s (Classical.choose_spec (onto (s.toFun x) (below x))) |
| right_inverse z := Subtype.ext (Classical.choose_spec (onto z.val z.property)) |
|
|
| structure InitialTasks {A : Type u} (P : MeetOrder A) (J : Type v) where |
| source : J → A |
| representative : J → MeetIso P P |
| filter : J → MeetFilter P |
| separator : J → A |
| base_le_separator : ∀ i, P.le ((representative i).toFun (source i)) (separator i) |
| separator_not_le_base : ∀ i, ¬ P.le (separator i) ((representative i).toFun (source i)) |
| separator_le_filter : ∀ i f, (filter i).mem f → P.le (separator i) f |
|
|
| namespace InitialTasks |
|
|
| variable {A : Type u} {J : Type v} {P : MeetOrder A} (d : InitialTasks P J) |
|
|
| def batch : Attachment.Templates P J where |
| Space _ := A |
| order _ := P |
| anchor := d.source |
| embed i := { |
| toFun y := (d.representative i).toFun y.val |
| le_iff x y := (d.representative i).le_iff x.val y.val |
| map_meet x y := (d.representative i).map_meet x.val y.val } |
| upper i := (d.filter i).mem |
| upper_nonempty i := (d.filter i).nonempty |
| upper_up i := (d.filter i).upward |
| upper_meet i := (d.filter i).closed_meet |
| separator := d.separator |
| base_le_separator := d.base_le_separator |
| separator_not_le_base := d.separator_not_le_base |
| separator_le_upper := d.separator_le_filter |
|
|
| noncomputable def copy (i : J) : MeetEmbedding P d.batch.extension := |
| d.batch.templateEmbedding i |
|
|
| theorem copy_agrees_on_base (i : J) (y : A) (hy : P.le y (d.source i)) : |
| (d.copy i).toFun y = .inl ((d.representative i).toFun y) := |
| d.batch.template_agrees_on_base i y hy |
|
|
| theorem copy_initial_profile (T : A) (top : ∀ y, P.le y T) |
| (outside : ∀ i, ¬ P.le T (d.source i)) (i : J) : |
| Profile d.batch.extension (.inl ((d.representative i).toFun (d.source i))) |
| (.inl (d.separator i)) ((d.copy i).toFun T) (d.batch.originalFamily i) := by |
| change Profile d.batch.extension (.inl (d.batch.base i)) (.inl (d.batch.separator i)) |
| (d.batch.represent i T) (d.batch.originalFamily i) |
| rw [d.batch.represent_new i T (outside i)] |
| exact d.batch.initial_profile i T top (outside i) |
|
|
| theorem copy_cap_separation (T : A) (top : ∀ y, P.le y T) |
| (outside : ∀ i, ¬ P.le T (d.source i)) (i j : J) (different : i ≠ j) : |
| d.batch.extension.le ((d.copy i).toFun T) (.inl (d.batch.base j)) ∨ |
| d.batch.extension.le ((d.copy j).toFun T) (.inl (d.batch.base i)) ∨ |
| d.batch.extension.meet ((d.copy i).toFun T) ((d.copy j).toFun T) = |
| d.batch.extension.meet (.inl (d.batch.base i)) (.inl (d.batch.base j)) := by |
| change d.batch.extension.le (d.batch.represent i T) (.inl (d.batch.base j)) ∨ |
| d.batch.extension.le (d.batch.represent j T) (.inl (d.batch.base i)) ∨ |
| d.batch.extension.meet (d.batch.represent i T) (d.batch.represent j T) = _ |
| rw [d.batch.represent_new i T (outside i), d.batch.represent_new j T (outside j)] |
| exact d.batch.cap_alternatives i j different T T top top (outside i) (outside j) |
|
|
| end InitialTasks |
|
|
| end Compression |
|
|
| end PartitionPilot |
|
|
| end OAI |
|
|
