| import Mathlib |
| import OAI.Probability.LatticeSurface.Convexity.BoundedBase |
|
|
| namespace OAI |
|
|
| noncomputable section |
|
|
| open MeasureTheory Set |
|
|
| open scoped ENNReal |
|
|
| namespace ExtremalEdges |
|
|
| attribute [local instance] Classical.propDecidable |
|
|
| lemma finite_partition_measure {X I : Type*} [MeasurableSpace X] [Fintype I] |
| (μ : Measure X) (tag : X → I) (hm : ∀ i, MeasurableSet {x | tag x = i}) |
| (s : Set X) (hs : MeasurableSet s) : |
| μ s = ∑ i, μ (s ∩ {x | tag x = i}) := by |
| classical |
| have he : s = ⋃ i, s ∩ {x | tag x = i} := by ext x; simp |
| calc |
| μ s = μ (⋃ i, s ∩ {x | tag x = i}) := congrArg μ he |
| _ = ∑' i, μ (s ∩ {x | tag x = i}) := measure_iUnion |
| (fun i j hij => Set.disjoint_left.mpr fun x hx hy => hij (hx.2.symm.trans hy.2)) |
| (fun i => hs.inter (hm i)) |
| _ = _ := tsum_fintype _ |
|
|
| lemma finite_switch_preserving {N I : Type*} [Fintype N] [Fintype I] |
| (tag : (N → ℝ) → I) (hm : ∀ i, MeasurableSet {x | tag x = i}) |
| (T : I → (N → ℝ) → (N → ℝ)) |
| (hT : ∀ i, MeasurePreserving (T i)) |
| (hinv : ∀ i x, tag (T i x) = tag x) : |
| MeasurePreserving (fun x => T (tag x) x) := by |
| classical |
| have hme : Measurable (fun x => T (tag x) x) := by |
| have hh : (fun x => T (tag x) x) = |
| fun x => ∑ i, ({x | tag x = i}).indicator (T i) x := by |
| funext x |
| simp [Set.indicator] |
| rw [hh] |
| exact Finset.measurable_sum _ fun i _ => (hT i).measurable.indicator (hm i) |
| refine ⟨hme, ?_⟩ |
| apply Measure.ext |
| intro s hs |
| rw [Measure.map_apply hme hs, |
| finite_partition_measure volume tag hm _ (hme hs), |
| finite_partition_measure volume tag hm _ hs] |
| apply Finset.sum_congr rfl |
| intro i hi |
| have he : (fun x => T (tag x) x) ⁻¹' s ∩ {x | tag x = i} = |
| T i ⁻¹' (s ∩ {x | tag x = i}) := by |
| ext x |
| simp only [mem_inter_iff, mem_preimage, mem_ofPred_eq, hinv] |
| constructor |
| · rintro ⟨h, htag⟩ |
| exact ⟨by simpa only [htag] using h, htag⟩ |
| · rintro ⟨h, htag⟩ |
| exact ⟨by simpa only [htag] using h, htag⟩ |
| rw [he] |
| exact (hT i).measure_preimage (hs.inter (hm i)).nullMeasurableSet |
|
|
| def lock {V : Type*} (G : SimpleGraph V) (a : ℝ) (h : V → ℝ) : SimpleGraph V where |
| Adj x y := G.Adj x y ∧ 1 < |h x-a| + |h y-a| |
| symm := ⟨by intro x y h; exact ⟨h.1.symm, by linarith [h.2]⟩⟩ |
| loopless := ⟨by intro x h; exact h.1.ne rfl⟩ |
|
|
| def reflect {V : Type*} (pins : Set V) (S : Set V) (a : ℝ) |
| (h : Free pins → ℝ) (x : Free pins) : ℝ := |
| if (x : V) ∈ S then 2*a-h x else h x |
|
|
| lemma preserving_reflect {V : Type*} [Fintype V] (pins S : Set V) (a : ℝ) : |
| MeasurePreserving (reflect pins S a) := by |
| classical |
| change MeasurePreserving (fun (h : Free pins → ℝ) (x : Free pins) => (fun t : ℝ => if (x : V) ∈ S then 2*a-t else t) (h x)) |
| refine volume_preserving_pi (f := fun (x : Free pins) (t : ℝ) => if (x : V) ∈ S then 2*a-t else t) ?_ |
| intro x |
| by_cases hx : (x : V) ∈ S |
| · simpa [reflect, hx, sub_eq_add_neg, Function.comp_def] using |
| (measurePreserving_add_left (volume : Measure ℝ) (2*a)).comp |
| (Measure.measurePreserving_neg volume) |
| · convert (MeasurePreserving.id (volume : Measure ℝ)) using 1 |
| funext t |
| simp [hx] |
|
|
| lemma reflect_involutive {V : Type*} (pins S : Set V) (a : ℝ) : |
| Function.Involutive (reflect pins S a) := by |
| intro h |
| funext x |
| simp only [reflect] |
| split_ifs <;> ring |
|
|
| lemma restore_reflect {V : Type*} (pins S : Set V) (b : V → ℝ) (a : ℝ) |
| (hS : Disjoint pins S) (h : Free pins → ℝ) (x : V) : |
| restore pins b (reflect pins S a h) x = |
| if x ∈ S then 2*a-restore pins b h x else restore pins b h x := by |
| by_cases hx : x ∈ pins |
| · have hxS : x ∉ S := fun hh => Set.disjoint_left.mp hS hx hh |
| simp [restore, hx, hxS] |
| · simp [restore, hx, reflect] |
|
|
| lemma abs_restore_reflect {V : Type*} (pins S : Set V) (b : V → ℝ) (a : ℝ) |
| (hS : Disjoint pins S) (h : Free pins → ℝ) (x : V) : |
| |restore pins b (reflect pins S a h) x-a| = |restore pins b h x-a| := by |
| rw [restore_reflect pins S b a hS] |
| split_ifs |
| · rw [show 2*a-restore pins b h x-a = -(restore pins b h x-a) by ring, abs_neg] |
| · rfl |
|
|
| lemma lock_reflect {V : Type*} (G : SimpleGraph V) (pins S : Set V) (b : V → ℝ) (a : ℝ) |
| (hS : Disjoint pins S) (h : Free pins → ℝ) : |
| lock G a (restore pins b (reflect pins S a h)) = lock G a (restore pins b h) := by |
| ext x y |
| simp only [lock, abs_restore_reflect pins S b a hS] |
|
|
| lemma measurable_lock_fiber {V : Type*} [Fintype V] |
| (G H : SimpleGraph V) (pins : Set V) (b : V → ℝ) (a : ℝ) : |
| MeasurableSet {h : Free pins → ℝ | lock G a (restore pins b h) = H} := by |
| have he : {h : Free pins → ℝ | lock G a (restore pins b h) = H} = |
| {h | ∀ x y, (G.Adj x y ∧ 1 < |restore pins b h x-a|+|restore pins b h y-a|) ↔ H.Adj x y} := by |
| ext h |
| exact ⟨fun hh x y => by rw [← hh]; rfl, |
| fun hh => by ext x y; exact hh x y⟩ |
| rw [he] |
| simp only [ofPred_forall] |
| apply MeasurableSet.iInter; intro x |
| apply MeasurableSet.iInter; intro y |
| have hm : MeasurableSet {h : Free pins → ℝ | |
| 1 < |restore pins b h x-a|+|restore pins b h y-a|} := |
| isOpen_lt continuous_const |
| (((continuous_restore pins b x).sub continuous_const).abs.add |
| ((continuous_restore pins b y).sub continuous_const).abs) |>.measurableSet |
| by_cases hg : G.Adj x y |
| · by_cases hh : H.Adj x y |
| · simpa only [hg, hh, true_and, iff_true] using hm |
| · simpa only [hg, hh, true_and, iff_false, Set.compl_ofPred] using hm.compl |
| · simp only [hg, false_and, false_iff] |
| exact MeasurableSet.const _ |
|
|
| lemma lock_same_sign {V : Type*} {G : SimpleGraph V} {h : V → ℝ} {a : ℝ} |
| (hf : ∀ x y, G.Adj x y → |h x-h y| ≤ 1) {x y : V} |
| (hxy : (lock G a h).Adj x y) : (a < h x ↔ a < h y) := by |
| have hb := abs_le.mp (hf x y hxy.1) |
| have hl := hxy.2 |
| constructor |
| · intro hx |
| by_contra hy |
| have hy := le_of_not_gt hy |
| rw [abs_of_nonneg (by linarith : 0 ≤ h x-a), abs_of_nonpos (by linarith : h y-a ≤ 0)] at hl |
| linarith [hb.2] |
| · intro hy |
| by_contra hx |
| have hx := le_of_not_gt hx |
| rw [abs_of_nonpos (by linarith : h x-a ≤ 0), abs_of_nonneg (by linarith : 0 ≤ h y-a)] at hl |
| linarith [hb.1] |
|
|
| lemma reachable_same_sign {V : Type*} {G : SimpleGraph V} {h : V → ℝ} {a : ℝ} |
| (hf : ∀ x y, G.Adj x y → |h x-h y| ≤ 1) {x y : V} |
| (hxy : (lock G a h).Reachable x y) : (a < h x ↔ a < h y) := by |
| obtain ⟨p⟩ := hxy |
| induction p with |
| | nil => rfl |
| | @cons u v w huv p ih => exact (lock_same_sign hf huv).trans ih |
|
|
| def freeCluster {V : Type*} (pins : Set V) (H : SimpleGraph V) (v : V) : Set V := |
| if Disjoint pins {x | H.Reachable v x} then {x | H.Reachable v x} else ∅ |
|
|
| lemma disjoint_freeCluster {V : Type*} (pins : Set V) (H : SimpleGraph V) (v : V) : |
| Disjoint pins (freeCluster pins H v) := by |
| unfold freeCluster |
| split_ifs with hh |
| · exact hh |
| · exact Set.disjoint_empty _ |
|
|
| lemma freeCluster_closed {V : Type*} (pins : Set V) (H : SimpleGraph V) (v x y : V) |
| (hx : x ∈ freeCluster pins H v) (hxy : H.Adj x y) : |
| y ∈ freeCluster pins H v := by |
| unfold freeCluster at * |
| split_ifs at * with hh |
| · exact hx.trans hxy.reachable |
| · exact False.elim hx |
|
|
| lemma reflect_cluster_feasible {V : Type*} {G : SimpleGraph V} |
| {pins : Set V} {b : V → ℝ} {a : ℝ} {h : Free pins → ℝ} |
| (hf : h ∈ conditionalBody G pins b) (v : V) : |
| reflect pins (freeCluster pins (lock G a (restore pins b h)) v) a h ∈ |
| conditionalBody G pins b := by |
| let S := freeCluster pins (lock G a (restore pins b h)) v |
| have hS := disjoint_freeCluster pins (lock G a (restore pins b h)) v |
| intro x y hxy |
| rw [restore_reflect pins S b a hS, restore_reflect pins S b a hS] |
| by_cases hx : x ∈ S <;> by_cases hy : y ∈ S |
| · simp only [ite_eq_left hx, ite_eq_left hy] |
| convert hf x y hxy using 1 |
| rw [show 2*a-restore pins b h x-(2*a-restore pins b h y) = |
| -(restore pins b h x-restore pins b h y) by ring, abs_neg] |
| · simp only [ite_eq_left hx, ite_eq_right hy] |
| have hn : ¬ (lock G a (restore pins b h)).Adj x y := |
| fun hh => hy (freeCluster_closed pins _ v x y hx hh) |
| have hr : |restore pins b h x-a|+|restore pins b h y-a| ≤ 1 := by |
| by_contra hh |
| exact hn ⟨hxy, lt_of_not_ge hh⟩ |
| calc |
| |2*a-restore pins b h x-restore pins b h y| = |
| |-(restore pins b h x-a)-(restore pins b h y-a)| := by congr 1; ring |
| _ ≤ |restore pins b h x-a|+|restore pins b h y-a| := by |
| simpa only [sub_zero, zero_sub, abs_neg] using abs_sub_le (-(restore pins b h x-a)) 0 (restore pins b h y-a) |
| _ ≤ 1 := hr |
| · simp only [ite_eq_right hx, ite_eq_left hy] |
| have hn : ¬ (lock G a (restore pins b h)).Adj x y := |
| fun hh => hx (freeCluster_closed pins _ v y x hy hh.symm) |
| have hr : |restore pins b h x-a|+|restore pins b h y-a| ≤ 1 := by |
| by_contra hh |
| exact hn ⟨hxy, lt_of_not_ge hh⟩ |
| calc |
| |restore pins b h x-(2*a-restore pins b h y)| = |
| |(restore pins b h x-a)+(restore pins b h y-a)| := by congr 1; ring |
| _ ≤ |restore pins b h x-a|+|restore pins b h y-a| := abs_add_le _ _ |
| _ ≤ 1 := hr |
| · simpa only [ite_eq_right hx, ite_eq_right hy] using hf x y hxy |
|
|
| def clusterFlip {V : Type*} (G : SimpleGraph V) (pins : Set V) (b : V → ℝ) |
| (a : ℝ) (v : V) (h : Free pins → ℝ) : Free pins → ℝ := |
| reflect pins (freeCluster pins (lock G a (restore pins b h)) v) a h |
|
|
| lemma preserving_clusterFlip {V : Type*} [Fintype V] |
| (G : SimpleGraph V) (pins : Set V) (b : V → ℝ) (a : ℝ) (v : V) : |
| MeasurePreserving (clusterFlip G pins b a v) := by |
| classical |
| let : Fintype (SimpleGraph V) := Fintype.ofFinite _ |
| apply finite_switch_preserving |
| (fun h => lock G a (restore pins b h)) |
| (fun H => measurable_lock_fiber G H pins b a) |
| (fun H => reflect pins (freeCluster pins H v) a) |
| (fun H => preserving_reflect pins _ a) |
| intro H h |
| exact lock_reflect G pins _ b a (disjoint_freeCluster pins H v) h |
|
|
| lemma positive_freeCluster {V : Type*} {G : SimpleGraph V} |
| {pins : Set V} {b : V → ℝ} {a : ℝ} {h : Free pins → ℝ} |
| (hf : h ∈ conditionalBody G pins b) (hb : ∀ x ∈ pins, b x ≤ a) |
| (v : V) (hv : a < restore pins b h v) : |
| freeCluster pins (lock G a (restore pins b h)) v = |
| {x | (lock G a (restore pins b h)).Reachable v x} := by |
| apply ite_eq_left |
| apply Set.disjoint_left.mpr |
| intro x hx hreach |
| have hxpos := (reachable_same_sign hf hreach).mp hv |
| have he : restore pins b h x = b x := by simp [restore, hx] |
| rw [he] at hxpos |
| exact (not_lt_of_ge (hb x hx)) hxpos |
|
|
| lemma clusterFlip_positive {V : Type*} {G : SimpleGraph V} |
| {pins : Set V} {b : V → ℝ} {a : ℝ} {h : Free pins → ℝ} |
| (hf : h ∈ conditionalBody G pins b) (hb : ∀ x ∈ pins, b x ≤ a) |
| (v : V) (hv : a < restore pins b h v) : |
| restore pins b (clusterFlip G pins b a v h) v ≤ a ∧ |
| ∀ x, restore pins b h x ≤ a → |
| restore pins b (clusterFlip G pins b a v h) x = restore pins b h x := by |
| have he := positive_freeCluster hf hb v hv |
| have hdis := disjoint_freeCluster pins (lock G a (restore pins b h)) v |
| constructor |
| · unfold clusterFlip |
| rw [restore_reflect pins _ b a hdis, he] |
| simp only [Set.mem_ofPred_eq, SimpleGraph.Reachable.refl, ite_true] |
| linarith |
| · intro x hx |
| unfold clusterFlip |
| rw [restore_reflect pins _ b a hdis, he] |
| apply ite_eq_right |
| intro hr |
| exact (not_lt_of_ge hx) ((reachable_same_sign hf hr).mp hv) |
|
|
| def below {V : Type*} (G : SimpleGraph V) (pins : Set V) (b : V → ℝ) |
| (a : ℝ) (S : Finset V) : Set (Free pins → ℝ) := |
| conditionalBody G pins b ∩ {h | ∀ x ∈ S, restore pins b h x ≤ a} |
|
|
| lemma measurable_below {V : Type*} [Fintype V] (G : SimpleGraph V) (pins : Set V) |
| (b : V → ℝ) (a : ℝ) (S : Finset V) : MeasurableSet (below G pins b a S) := by |
| apply (closed_conditionalBody G pins b).measurableSet.inter |
| simp only [ofPred_forall] |
| exact MeasurableSet.iInter fun x => MeasurableSet.iInter fun _ => |
| (isClosed_le (continuous_restore pins b x) continuous_const).measurableSet |
|
|
| lemma volume_below_insert {V : Type*} [Fintype V] (G : SimpleGraph V) (pins : Set V) |
| (b : V → ℝ) (a : ℝ) (hb : ∀ x ∈ pins, b x ≤ a) (S : Finset V) (v : V) : |
| volume (below G pins b a S) ≤ 2 * volume (below G pins b a (insert v S)) := by |
| classical |
| let B := below G pins b a (insert v S) |
| have hmB : MeasurableSet B := measurable_below G pins b a _ |
| have hsub : below G pins b a S ⊆ B ∪ clusterFlip G pins b a v ⁻¹' B := by |
| rintro h ⟨hf, hS⟩ |
| by_cases hv : restore pins b h v ≤ a |
| · left |
| exact ⟨hf, fun x hx => (Finset.mem_insert.mp hx).elim (fun he => he ▸ hv) (hS x)⟩ |
| · right |
| have hh := clusterFlip_positive hf hb v (lt_of_not_ge hv) |
| refine ⟨reflect_cluster_feasible hf v, ?_⟩ |
| intro x hx |
| rcases Finset.mem_insert.mp hx with rfl | hx |
| · exact hh.1 |
| · rw [hh.2 x (hS x hx)] |
| exact hS x hx |
| calc |
| volume (below G pins b a S) ≤ volume (B ∪ clusterFlip G pins b a v ⁻¹' B) := measure_mono hsub |
| _ ≤ volume B + volume (clusterFlip G pins b a v ⁻¹' B) := measure_union_le _ _ |
| _ = 2 * volume B := by |
| rw [(preserving_clusterFlip G pins b a v).measure_preimage hmB.nullMeasurableSet, two_mul] |
|
|
| theorem volume_one_sided {V : Type*} [Fintype V] (G : SimpleGraph V) (pins : Set V) |
| (b : V → ℝ) (a : ℝ) (hb : ∀ x ∈ pins, b x ≤ a) (S : Finset V) : |
| volume (conditionalBody G pins b) ≤ 2 ^ S.card * volume (below G pins b a S) := by |
| classical |
| induction S using Finset.induction_on with |
| | empty => simp [below] |
| | @insert v S hv ih => |
| calc |
| volume (conditionalBody G pins b) ≤ 2 ^ S.card * volume (below G pins b a S) := ih |
| _ ≤ 2 ^ S.card * (2 * volume (below G pins b a (insert v S))) := |
| mul_le_mul_right (volume_below_insert G pins b a hb S v) _ |
| _ = _ := by rw [Finset.card_insert_of_notMem hv, pow_succ]; ac_rfl |
|
|
| end ExtremalEdges |
|
|
| end |
|
|
| end OAI |
|
|
