| import OAI.Probability.InvariantIsing.Core.TailOrder |
|
|
| namespace OAI |
|
|
| /-! Contact inequalities at trial-partition endpoints imply the full upper |
| tail order. Monotone quantile tails lie above their interval chords. -/ |
|
|
| noncomputable section |
| open MeasureTheory Set |
| open scoped BigOperators |
|
|
| namespace InvariantIsing |
|
|
| lemma pathTail_chord (p : OverlapPath) {a s b : ℝ} (has : a ≤ s) (hsb : s ≤ b) : |
| (b - s) * pathTail p a + (s - a) * pathTail p b ≤ (b - a) * pathTail p s := by |
| have hleft : (∫ u in a..s, p u) ≤ ∫ _u in a..s, p s := |
| intervalIntegral.integral_mono_on has p.monotone.intervalIntegrable |
| intervalIntegrable_const (fun u hu => p.monotone hu.2) |
| have hright : (∫ _u in s..b, p s) ≤ ∫ u in s..b, p u := |
| intervalIntegral.integral_mono_on hsb intervalIntegrable_const |
| p.monotone.intervalIntegrable (fun u hu => p.monotone hu.1) |
| rw [intervalIntegral.integral_const, smul_eq_mul] at hleft hright |
| have h1 := intervalIntegral.integral_add_adjacent_intervals |
| (p.monotone.intervalIntegrable (μ := volume) (a := a) (b := s)) |
| (p.monotone.intervalIntegrable (μ := volume) (a := s) (b := 1)) |
| have h2 := intervalIntegral.integral_add_adjacent_intervals |
| (p.monotone.intervalIntegrable (μ := volume) (a := s) (b := b)) |
| (p.monotone.intervalIntegrable (μ := volume) (a := b) (b := 1)) |
| have hL := mul_le_mul_of_nonneg_left hleft (sub_nonneg.mpr hsb) |
| have hR := mul_le_mul_of_nonneg_left hright (sub_nonneg.mpr has) |
| unfold pathTail |
| nlinarith |
|
|
| lemma pathTail_chord_eq_of_const (q : OverlapPath) {a s b c : ℝ} |
| (has : a ≤ s) (hsb : s ≤ b) (hc : ∀ u ∈ Ioo a b, q u = c) : |
| (b - s) * pathTail q a + (s - a) * pathTail q b = (b - a) * pathTail q s := by |
| have hleft : (∫ u in a..s, q u) = (s - a) * c := by |
| calc |
| _ = ∫ _u in a..s, c := intervalIntegral.integral_congr_Ioo_of_le has |
| (fun u hu => hc u ⟨hu.1, hu.2.trans_le hsb⟩) |
| _ = _ := by simp only [intervalIntegral.integral_const, smul_eq_mul] |
| have hright : (∫ u in s..b, q u) = (b - s) * c := by |
| calc |
| _ = ∫ _u in s..b, c := intervalIntegral.integral_congr_Ioo_of_le hsb |
| (fun u hu => hc u ⟨has.trans_lt hu.1, hu.2⟩) |
| _ = _ := by simp only [intervalIntegral.integral_const, smul_eq_mul] |
| have h1 := intervalIntegral.integral_add_adjacent_intervals |
| (q.monotone.intervalIntegrable (μ := volume) (a := a) (b := s)) |
| (q.monotone.intervalIntegrable (μ := volume) (a := s) (b := 1)) |
| have h2 := intervalIntegral.integral_add_adjacent_intervals |
| (q.monotone.intervalIntegrable (μ := volume) (a := s) (b := b)) |
| (q.monotone.intervalIntegrable (μ := volume) (a := b) (b := 1)) |
| rw [hleft] at h1 |
| rw [hright] at h2 |
| unfold pathTail |
| nlinarith |
|
|
| lemma pathTail_le_of_interval_endpoints (p q : OverlapPath) {a s b c : ℝ} |
| (hab : a < b) (has : a ≤ s) (hsb : s ≤ b) (hc : ∀ u ∈ Ioo a b, q u = c) |
| (ha : pathTail q a ≤ pathTail p a) (hb : pathTail q b ≤ pathTail p b) : |
| pathTail q s ≤ pathTail p s := by |
| have hp := pathTail_chord p has hsb |
| have hq := pathTail_chord_eq_of_const q has hsb hc |
| have h1 := mul_le_mul_of_nonneg_left ha (sub_nonneg.mpr hsb) |
| have h2 := mul_le_mul_of_nonneg_left hb (sub_nonneg.mpr has) |
| nlinarith |
|
|
| lemma finite_cut_bracket {n : ℕ} (cut : Fin (n + 2) → ℝ) |
| (hfirst : cut 0 = 0) (hlast : cut (Fin.last (n + 1)) = 1) |
| {s : ℝ} (hs : s ∈ Icc (0 : ℝ) 1) : |
| ∃ i : Fin (n + 1), cut i.castSucc ≤ s ∧ s ≤ cut i.succ := by |
| classical |
| let S := Finset.univ.filter (fun i : Fin (n + 1) => cut i.castSucc ≤ s) |
| have hS : S.Nonempty := ⟨0, by simp only [S, Finset.mem_filter, Finset.mem_univ, |
| true_and, Fin.castSucc_zero, hfirst]; exact hs.1⟩ |
| let i := S.max' hS |
| have hiS : i ∈ S := Finset.max'_mem _ _ |
| have hi : cut i.castSucc ≤ s := (Finset.mem_filter.mp hiS).2 |
| refine ⟨i, hi, ?_⟩ |
| by_cases hin : i.val = n |
| · have he : i.succ = Fin.last (n + 1) := by ext; simp only [Fin.val_succ, Fin.val_last]; omega |
| rw [he, hlast] |
| exact hs.2 |
| · by_contra hsb |
| let j : Fin (n + 1) := ⟨i.val + 1, by omega⟩ |
| have he : j.castSucc = i.succ := by ext; rfl |
| have hjS : j ∈ S := Finset.mem_filter.mpr ⟨Finset.mem_univ _, by |
| rw [he]; exact (lt_of_not_ge hsb).le⟩ |
| have hji : j ≤ i := Finset.le_max' S j hjS |
| change j.val ≤ i.val at hji |
| dsimp only [j] at hji |
| omega |
|
|
| theorem pathTail_order_of_finite_partition (p q : OverlapPath) {n : ℕ} |
| (cut : Fin (n + 2) → ℝ) (hcut : StrictMono cut) |
| (hfirst : cut 0 = 0) (hlast : cut (Fin.last (n + 1)) = 1) |
| (v : Fin (n + 1) → ℝ) |
| (hq : ∀ i u, u ∈ Ioo (cut i.castSucc) (cut i.succ) → q u = v i) |
| (hend : ∀ i, pathTail q (cut i) ≤ pathTail p (cut i)) : |
| ∀ s ∈ Icc (0 : ℝ) 1, pathTail q s ≤ pathTail p s := by |
| intro s hs |
| obtain ⟨i, has, hsb⟩ := finite_cut_bracket cut hfirst hlast hs |
| exact pathTail_le_of_interval_endpoints p q |
| (hcut (by exact_mod_cast (show i.val < i.val + 1 by omega))) has hsb (hq i) |
| (hend i.castSucc) (hend i.succ) |
|
|
| end InvariantIsing |
|
|
| end |
|
|
| end OAI |
|
|
