| import OAI.SetTheory.PartitionPrinciple.Transfinite.OrdinalExternalHeights |
|
|
| namespace OAI |
|
|
| section |
|
|
| namespace PartitionPilot.Compression.RecursiveMaps |
|
|
| universe u v |
|
|
| structure DirectSystem (I : Type u) [LinearOrder I] where |
| Point : I → Type u |
| map : ∀ {i j}, i ≤ j → Point i → Point j |
| map_self : ∀ i x, map (le_refl i) x = x |
| map_comp : ∀ {i j k} (hij : i ≤ j) (hjk : j ≤ k) x, |
| map (le_trans hij hjk) x = map hjk (map hij x) |
| injective : ∀ {i j} (h : i ≤ j), Function.Injective (map h) |
|
|
| namespace DirectSystem |
| variable {I : Type u} [LinearOrder I] (c : DirectSystem I) |
|
|
| def Label := (i : I) × c.Point i |
| def Related (x y : c.Label) : Prop := |
| ∃ (k : I) (hx : x.1 ≤ k) (hy : y.1 ≤ k), c.map hx x.2 = c.map hy y.2 |
|
|
| theorem related_refl (x : c.Label) : c.Related x x := ⟨x.1, le_rfl, le_rfl, rfl⟩ |
| theorem related_symm {x y : c.Label} (h : c.Related x y) : c.Related y x := by |
| rcases h with ⟨k, hx, hy, eq⟩ |
| exact ⟨k, hy, hx, eq.symm⟩ |
|
|
| theorem related_trans {x y z : c.Label} (hxy : c.Related x y) (hyz : c.Related y z) : |
| c.Related x z := by |
| rcases hxy with ⟨k, hx, hy, eq1⟩ |
| rcases hyz with ⟨l, hy', hz, eq2⟩ |
| refine ⟨max k l, le_trans hx (le_max_left _ _), le_trans hz (le_max_right _ _), ?_⟩ |
| calc |
| c.map _ x.2 = c.map (le_max_left k l) (c.map hx x.2) := c.map_comp _ _ _ |
| _ = c.map (le_max_left k l) (c.map hy y.2) := congrArg _ eq1 |
| _ = c.map (le_max_right k l) (c.map hy' y.2) := |
| (c.map_comp _ _ _).symm.trans (c.map_comp _ _ _) |
| _ = c.map (le_max_right k l) (c.map hz z.2) := congrArg _ eq2 |
| _ = c.map _ z.2 := (c.map_comp _ _ _).symm |
|
|
| def setoid : Setoid c.Label := ⟨c.Related, c.related_refl, c.related_symm, c.related_trans⟩ |
| def Union := Quotient c.setoid |
| def point (i : I) (x : c.Point i) : c.Union := Quotient.mk c.setoid ⟨i, x⟩ |
|
|
| theorem point_map {i j : I} (h : i ≤ j) (x : c.Point i) : |
| c.point j (c.map h x) = c.point i x := by |
| apply Quotient.sound |
| exact ⟨j, le_rfl, h, c.map_self _ _⟩ |
|
|
| theorem point_injective (i : I) : Function.Injective (c.point i) := by |
| intro x y eq |
| rcases Quotient.exact eq with ⟨k, hx, hy, same⟩ |
| exact c.injective hx same |
|
|
| theorem cover (x : c.Union) : ∃ i a, c.point i a = x := by |
| induction x using Quotient.ind with |
| | _ x => exact ⟨x.1, x.2, rfl⟩ |
|
|
| theorem pair_cover (d : DirectSystem I) (x : c.Union) (y : d.Union) : |
| ∃ i a b, c.point i a = x ∧ d.point i b = y := by |
| rcases c.cover x with ⟨i, a, rfl⟩ |
| rcases d.cover y with ⟨j, b, rfl⟩ |
| exact ⟨max i j, c.map (le_max_left _ _) a, d.map (le_max_right _ _) b, |
| c.point_map _ _, d.point_map _ _⟩ |
|
|
| theorem triple_cover (d e : DirectSystem I) (x : c.Union) (y : d.Union) (z : e.Union) : |
| ∃ i a b t, c.point i a = x ∧ d.point i b = y ∧ e.point i t = z := by |
| rcases c.pair_cover d x y with ⟨i, a, b, rfl, rfl⟩ |
| rcases e.cover z with ⟨j, t, rfl⟩ |
| exact ⟨max i j, c.map (le_max_left _ _) a, d.map (le_max_left _ _) b, |
| e.map (le_max_right _ _) t, c.point_map _ _, d.point_map _ _, e.point_map _ _⟩ |
|
|
| def descend {H : Type v} (value : ∀ i, c.Point i → H) |
| (coherent : ∀ {i j} (h : i ≤ j) x, value j (c.map h x) = value i x) : c.Union → H := |
| Quotient.lift (fun x => value x.1 x.2) (by |
| intro x y related |
| rcases related with ⟨k, hx, hy, eq⟩ |
| exact (coherent hx x.2).symm.trans ((congrArg (value k) eq).trans (coherent hy y.2))) |
|
|
| theorem descend_point {H : Type v} (value : ∀ i, c.Point i → H) |
| (coherent : ∀ {i j} (h : i ≤ j) x, value j (c.map h x) = value i x) (i : I) (x : c.Point i) : |
| c.descend value coherent (c.point i x) = value i x := rfl |
|
|
| section Binary |
| variable (d e : DirectSystem I) (op : ∀ i, c.Point i → d.Point i → e.Point i) |
| (coherent : ∀ {i j} (h : i ≤ j) x y, |
| e.map h (op i x y) = op j (c.map h x) (d.map h y)) |
|
|
| def binaryLabel (x : c.Label) (y : d.Label) : e.Union := |
| e.point (max x.1 y.1) |
| (op _ (c.map (le_max_left _ _) x.2) (d.map (le_max_right _ _) y.2)) |
|
|
| include coherent |
|
|
| theorem binaryLabel_at (x : c.Label) (y : d.Label) (k : I) (hx : x.1 ≤ k) (hy : y.1 ≤ k) : |
| c.binaryLabel d e op x y = e.point k (op k (c.map hx x.2) (d.map hy y.2)) := by |
| let h : max x.1 y.1 ≤ k := max_le hx hy |
| change e.point (max x.1 y.1) _ = _ |
| rw [← e.point_map h, coherent, ← c.map_comp, ← d.map_comp] |
|
|
| theorem binaryLabel_respects (x x' : c.Label) (y y' : d.Label) |
| (eqx : c.Related x x') (eqy : d.Related y y') : |
| c.binaryLabel d e op x y = c.binaryLabel d e op x' y' := by |
| rcases eqx with ⟨k, hx, hx', eqx⟩ |
| rcases eqy with ⟨l, hy, hy', eqy⟩ |
| rw [c.binaryLabel_at d e op coherent x y (max k l) |
| (le_trans hx (le_max_left _ _)) (le_trans hy (le_max_right _ _)), |
| c.binaryLabel_at d e op coherent x' y' (max k l) |
| (le_trans hx' (le_max_left _ _)) (le_trans hy' (le_max_right _ _))] |
| rw [c.map_comp hx (le_max_left _ _), c.map_comp hx' (le_max_left _ _), |
| d.map_comp hy (le_max_right _ _), d.map_comp hy' (le_max_right _ _), eqx, eqy] |
|
|
| def binary : c.Union → d.Union → e.Union := |
| Quotient.lift₂ (c.binaryLabel d e op) |
| (fun x y x' y' hx hy => c.binaryLabel_respects d e op coherent x x' y y' hx hy) |
|
|
| theorem binary_point (i : I) (x : c.Point i) (y : d.Point i) : |
| c.binary d e op coherent (c.point i x) (d.point i y) = e.point i (op i x y) := by |
| change c.binaryLabel d e op ⟨i, x⟩ ⟨i, y⟩ = _ |
| erw [c.binaryLabel_at d e op coherent _ _ i le_rfl le_rfl, c.map_self, d.map_self] |
|
|
| end Binary |
|
|
| end DirectSystem |
| end PartitionPilot.Compression.RecursiveMaps |
|
|
| end |
|
|
| end OAI |
|
|
