| import Mathlib |
| import OAI.Probability.Contingency.DenseRegularity |
|
|
| namespace OAI |
|
|
| /-! Piece Quantiles. -/ |
|
|
| noncomputable section |
|
|
| open Set MeasureTheory Filter |
| open scoped BigOperators Topology |
| open Set MeasureTheory Filter |
| open scoped BigOperators Topology |
| namespace Contingency.Interpolation |
| noncomputable section |
|
|
| |
|
|
| structure SourcePieces (n : ℕ) where |
| lo : Fin n → ℝ |
| hi : Fin n → ℝ |
| lt : ∀ i,lo i < hi i |
| ordered : ∀ i j,i < j → hi i ≤ lo j |
| f : Fin n → ℝ → ℝ |
| continuous : ∀ i,ContinuousOn (f i) (Icc (lo i) (hi i)) |
| positive : ∀ i x,x∈Icc (lo i) (hi i) → 0 < f i x |
|
|
| namespace SourcePieces |
| variable {n : ℕ} |
|
|
| def mass (P : SourcePieces n) (i : Fin n) : ℝ := ∫ x in P.lo i..P.hi i,P.f i x |
|
|
| def total (P : SourcePieces n) : ℝ := totalMass P.mass |
|
|
| theorem mass_pos (P : SourcePieces n) (i : Fin n) : 0 < P.mass i := |
| intervalIntegral.integral_pos (P.lt i) (P.continuous i) |
| (fun x hx => (P.positive i x (Ioc_subset_Icc_self hx)).le) |
| ⟨P.lo i,left_mem_Icc.mpr (P.lt i).le,P.positive i _ (left_mem_Icc.mpr (P.lt i).le)⟩ |
|
|
| theorem total_pos (P : SourcePieces n) (hn : 0 < n) : 0 < P.total := by |
| dsimp [total,totalMass] |
| apply Finset.sum_pos (fun i _ => P.mass_pos i) |
| exact ⟨⟨0,hn⟩,Finset.mem_univ _⟩ |
|
|
| def good (P : SourcePieces n) : Set ℝ := ⋃ i,probabilityPiece P.mass i |
|
|
| theorem good_measurable (P : SourcePieces n) : MeasurableSet P.good := |
| MeasurableSet.iUnion fun _ => measurableSet_Ioo |
|
|
| theorem good_subset (P : SourcePieces n) (hn : 0 < n) : P.good ⊆ Ioo 0 1 := by |
| intro t ht |
| obtain ⟨i,hi⟩ := mem_iUnion.mp ht |
| exact probabilityPiece_subset P.mass (fun i => (P.mass_pos i).le) (P.total_pos hn) i hi |
|
|
| theorem good_volume (P : SourcePieces n) (hn : 0 < n) : volume P.good=1 := |
| probabilityPieces_volume P.mass (fun i => (P.mass_pos i).le) (P.total_pos hn) |
|
|
| theorem good_ae (P : SourcePieces n) (hn : 0 < n) : P.good =ᵐ[volume] Ioo (0:ℝ) 1 := by |
| apply ae_eq_of_subset_of_measure_ge (P.good_subset hn) |
| · rw [P.good_volume hn]; simp |
| · exact P.good_measurable.nullMeasurableSet |
| · simp |
| |
| |
| theorem local_quantiles (P : SourcePieces n) (hn : 0 < n) : |
| ∃ Q : Fin n → ℝ → ℝ, |
| (∀ i,StrictMonoOn (Q i) (probabilityPiece P.mass i)) ∧ |
| ∀ i t,t∈probabilityPiece P.mass i → Q i t∈Ioo (P.lo i) (P.hi i) ∧ |
| HasDerivAt (Q i) (P.total/P.f i (Q i t)) t := by |
| have hM := P.total_pos hn |
| have hq (i) := positive_quantile (P.f i) (P.lo i) (P.hi i) (P.lt i) (P.continuous i) (P.positive i) |
| choose hmi Q hmQ himQ hdQ using hq |
| let A := fun (i : Fin n) (t : ℝ) => (P.total*t-prefixMass P.mass i)/P.mass i |
| have hA (i t) (ht : t∈probabilityPiece P.mass i) : A i t∈Ioo 0 1 := by |
| have h1 := (div_lt_iff₀ hM).mp ht.1 |
| have h2 := (lt_div_iff₀ hM).mp ht.2 |
| dsimp [A] |
| constructor |
| · apply div_pos _ (P.mass_pos i); nlinarith only [h1] |
| · apply (div_lt_one (P.mass_pos i)).mpr; nlinarith only [h2] |
| refine ⟨fun i t => Q i (A i t),fun i => ?_,fun i t ht => ?_⟩ |
| · intro t ht s hs hts |
| apply hmQ i (hA i t ht) (hA i s hs) |
| apply (div_lt_div_iff_of_pos_right (P.mass_pos i)).mpr |
| have := mul_lt_mul_of_pos_left hts hM |
| linarith |
| · have hh := hdQ i (A i t) (hA i t ht) |
| refine ⟨hh.1,?_⟩ |
| have hAd : HasDerivAt (A i) (P.total/P.mass i) t := by |
| simpa only [A,mul_one,id_eq] using (((hasDerivAt_id t).const_mul P.total).sub_const (prefixMass P.mass i)).div_const (P.mass i) |
| have hder := hh.2.comp t hAd |
| apply hder.congr_deriv |
| change P.mass i / P.f i (Q i (A i t)) * (P.total / P.mass i) = P.total / P.f i (Q i (A i t)) |
| field_simp [(P.mass_pos i).ne'] |
|
|
| |
|
|
| theorem quantile (P : SourcePieces n) (hn : 0 < n) : |
| ∃ Q V : ℝ → ℝ, |
| StrictMonoOn Q P.good ∧ |
| ∀ t∈P.good, 0 < V t ∧ HasDerivAt Q (P.total/V t) t ∧ |
| ∃ i,Q t∈Ioo (P.lo i) (P.hi i) ∧ V t=P.f i (Q t) := by |
| classical |
| obtain ⟨qi,hmi,hdi⟩ := P.local_quantiles hn |
| let idx := fun t => if h : ∃ i,t∈probabilityPiece P.mass i then h.choose else ⟨0,hn⟩ |
| let Q := fun t => qi (idx t) t |
| let V := fun t => P.f (idx t) (Q t) |
| have hind (t i) (ht : t∈probabilityPiece P.mass i) : idx t=i := by |
| dsimp [idx] |
| have he : ∃ i,t∈probabilityPiece P.mass i := ⟨i,ht⟩ |
| rw [dite_eq_left he] |
| by_contra hne |
| have hdis := probabilityPiece_disjoint P.mass (fun i => (P.mass_pos i).le) (P.total_pos hn) hne |
| exact disjoint_left.mp hdis he.choose_spec ht |
| have hin (t) (ht : t∈P.good) : t∈probabilityPiece P.mass (idx t) := by |
| obtain ⟨i,hi⟩ := mem_iUnion.mp ht |
| rw [hind t i hi] |
| exact hi |
| have hQ (i t) (ht : t∈probabilityPiece P.mass i) : Q t=qi i t := by |
| dsimp [Q]; rw [hind t i ht] |
| refine ⟨Q,V,?_,fun t ht => ?_⟩ |
| · intro t ht s hs hts |
| have hit := hin t ht |
| have his := hin s hs |
| have hti := (hdi _ _ hit).1 |
| have hsi := (hdi _ _ his).1 |
| change qi (idx t) t < qi (idx s) s |
| rcases lt_trichotomy (idx t) (idx s) with hlt|heq|hgt |
| · exact hti.2.trans_le ((P.ordered _ _ hlt).trans hsi.1.le) |
| · rw [heq] at hit ⊢ |
| exact hmi _ hit his hts |
| · have hh := div_le_div_of_nonneg_right |
| (prefix_next_le P.mass (fun i => (P.mass_pos i).le) (idx s) (idx t) hgt) (P.total_pos hn).le |
| exact False.elim (not_lt_of_ge (his.2.le.trans (hh.trans hit.1.le)) hts) |
| · have hi := hin t ht |
| have hh := hdi _ _ hi |
| refine ⟨P.positive _ _ (Ioo_subset_Icc_self hh.1),?_,idx t,hh.1,rfl⟩ |
| have hevent : Q =ᶠ[𝓝 t] qi (idx t) := by |
| filter_upwards [isOpen_Ioo.mem_nhds hi] with u hu |
| exact hQ _ _ hu |
| exact hh.2.congr_of_eventuallyEq hevent |
|
|
| end SourcePieces |
| end |
| end Contingency.Interpolation |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory |
| namespace Contingency.Interpolation |
| noncomputable section |
| variable {q : ℕ} |
|
|
| theorem slices_constant (S : Finset (OpenBox (q+1))) (l x y : ℝ) |
| (hx : x∈Ioo l (nextEndpoint (endpoints S) l)) |
| (hy : y∈Ioo l (nextEndpoint (endpoints S) l)) : slices S x=slices S y := by |
| classical |
| unfold slices |
| congr 1 |
| ext B |
| simp only [Finset.mem_filter] |
| by_cases hB : B∈S |
| · have h1 := endpoint_comparisons (endpoints S) l x y (B.lower 0) hx hy (lower_mem_endpoints S B hB) |
| have h2 := endpoint_comparisons (endpoints S) l x y (B.upper 0) hx hy (upper_mem_endpoints S B hB) |
| simp only [hB,true_and,h1.1,h2.2] |
| · simp [hB] |
|
|
| def activeEndpoints (S : Finset (OpenBox (q+1))) : Finset ℝ := by |
| classical |
| exact (endpoints S).filter fun l => |
| ∃ x∈Ioo l (nextEndpoint (endpoints S) l),(boxUnion (slices S x)).Nonempty |
|
|
| theorem activeEndpoint_mem (S : Finset (OpenBox (q+1))) (l : ℝ) (hl : l∈activeEndpoints S) : |
| l∈endpoints S := by |
| classical |
| exact (Finset.mem_filter.mp hl).1 |
|
|
| theorem activeEndpoint_lt (S : Finset (OpenBox (q+1))) (l : ℝ) (hl : l∈activeEndpoints S) : |
| l<nextEndpoint (endpoints S) l := by |
| classical |
| obtain ⟨x,hx,_⟩ := (Finset.mem_filter.mp hl).2 |
| exact hx.1.trans hx.2 |
|
|
| def gridMidpoint (S : Finset (OpenBox (q+1))) (l : ℝ) : ℝ := |
| (l+nextEndpoint (endpoints S) l)/2 |
|
|
| theorem midpoint_mem (S : Finset (OpenBox (q+1))) (l : ℝ) (hl : l∈activeEndpoints S) : |
| gridMidpoint S l∈Ioo l (nextEndpoint (endpoints S) l) := by |
| have hh := activeEndpoint_lt S l hl |
| constructor <;> dsimp [gridMidpoint] <;> linarith |
| |
| theorem activeSlice_nonempty (S : Finset (OpenBox (q+1))) (l : ℝ) (hl : l∈activeEndpoints S) : |
| (boxUnion (slices S (gridMidpoint S l))).Nonempty := by |
| classical |
| obtain ⟨x,hx,hs⟩ := (Finset.mem_filter.mp hl).2 |
| rw [← slices_constant S l x (gridMidpoint S l) hx (midpoint_mem S l hl)] |
| exact hs |
|
|
| def gridLower (S : Finset (OpenBox (q+1))) : Fin (activeEndpoints S).card ↪o ℝ := |
| (activeEndpoints S).orderEmbOfFin rfl |
|
|
| theorem gridLower_mem (S : Finset (OpenBox (q+1))) (i : Fin (activeEndpoints S).card) : |
| gridLower S i∈activeEndpoints S := Finset.orderEmbOfFin_mem _ _ _ |
|
|
| def boxPieces (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) : SourcePieces (activeEndpoints S).card where |
| lo := gridLower S |
| hi := fun i => nextEndpoint (endpoints S) (gridLower S i) |
| lt := fun i => activeEndpoint_lt S _ (gridLower_mem S i) |
| ordered := fun left right hij => nextEndpoint_le (endpoints S) (gridLower S left) (gridLower S right) |
| (activeEndpoint_mem S _ (gridLower_mem S right)) ((gridLower S).strictMono hij) |
| f := fun i x => ∫ y in boxUnion (slices S (gridMidpoint S (gridLower S i))),F.f (Fin.cons x y) |
| continuous := fun index => (F.marginal_continuous (slices S (gridMidpoint S (gridLower S index)))).continuousOn |
| positive := fun i x _ => (F.slice x).integral_pos _ (activeSlice_nonempty S _ (gridLower_mem S i)) |
|
|
| theorem boxPieces_slice (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) |
| (i : Fin (activeEndpoints S).card) (x : ℝ) |
| (hx : x∈Ioo ((boxPieces S F).lo i) ((boxPieces S F).hi i)) : |
| (boxPieces S F).f i x=∫ y in boxUnion (slices S x),F.f (Fin.cons x y) := by |
| change (∫ y in boxUnion (slices S (gridMidpoint S (gridLower S i))),F.f (Fin.cons x y))=_ |
| rw [slices_constant S (gridLower S i) _ x (midpoint_mem S _ (gridLower_mem S i)) hx] |
|
|
| theorem boxPieces_cover (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) (x : ℝ) |
| (hx : x∉endpoints S) (hs : (boxUnion (slices S x)).Nonempty) : |
| ∃ i,x∈Ioo ((boxPieces S F).lo i) ((boxPieces S F).hi i) := by |
| classical |
| obtain ⟨y,hy⟩ := hs |
| obtain ⟨B,hB,hBy⟩ := (mem_boxUnion S (Fin.cons x y)).mp ((mem_slices S x y).mp hy) |
| have hxB := hBy 0 |
| simp only [Fin.cons_zero] at hxB |
| obtain ⟨l,hl,hxl⟩ := grid_covers (endpoints S) x _ _ |
| (lower_mem_endpoints S B hB) (upper_mem_endpoints S B hB) hxB.1 hxB.2 hx |
| have hlA : l∈activeEndpoints S := Finset.mem_filter.mpr ⟨hl,x,hxl,y,hy⟩ |
| have hr : Set.range (gridLower S)=(activeEndpoints S : Set ℝ) := Finset.range_orderEmbOfFin _ _ |
| have hrl : l∈Set.range (gridLower S) := by rw [hr]; exact hlA |
| obtain ⟨i,hi⟩ := hrl |
| refine ⟨i,?_⟩ |
| change x∈Ioo (gridLower S i) (nextEndpoint (endpoints S) (gridLower S i)) |
| rw [hi] |
| exact hxl |
|
|
| end |
| end Contingency.Interpolation |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory |
| open scoped BigOperators |
| namespace Contingency.Interpolation.SourcePieces |
| noncomputable section |
| variable {n : ℕ} |
|
|
| def source (P : SourcePieces n) (x : ℝ) : ℝ := |
| ∑ i,(Ioo (P.lo i) (P.hi i)).indicator (P.f i) x |
|
|
| theorem support_disjoint (P : SourcePieces n) : |
| Pairwise (fun i j => Disjoint (Ioo (P.lo i) (P.hi i)) (Ioo (P.lo j) (P.hi j))) := by |
| intro i j hij |
| rcases lt_or_gt_of_ne hij with hh|hh |
| · exact Set.disjoint_left.mpr fun x hx hy => not_lt_of_ge (hx.2.le.trans (P.ordered i j hh)) hy.1 |
| · exact Set.disjoint_left.mpr fun x hx hy => not_lt_of_ge (hy.2.le.trans (P.ordered j i hh)) hx.1 |
|
|
| theorem source_on (P : SourcePieces n) (i : Fin n) (x : ℝ) (hx : x∈Ioo (P.lo i) (P.hi i)) : |
| P.source x=P.f i x := by |
| classical |
| rw [source,Finset.sum_eq_single i] |
| · exact Set.indicator_of_mem hx _ |
| · intro j _ hji |
| apply Set.indicator_of_notMem |
| intro hj |
| exact Set.disjoint_left.mp (P.support_disjoint hji) hj hx |
| · simp |
|
|
| theorem source_off (P : SourcePieces n) (x : ℝ) (hx : ∀ i,x∉Ioo (P.lo i) (P.hi i)) : |
| P.source x=0 := by simp [source,hx] |
|
|
| theorem piece_integrable (P : SourcePieces n) (i : Fin n) : |
| IntegrableOn (P.f i) (Ioo (P.lo i) (P.hi i)) := |
| ((P.continuous i).integrableOn_compact isCompact_Icc).mono_set Ioo_subset_Icc_self |
|
|
| theorem source_integrable (P : SourcePieces n) : Integrable P.source := |
| integrable_finsetSum _ fun i _ => (P.piece_integrable i).integrable_indicator measurableSet_Ioo |
|
|
| theorem source_integral (P : SourcePieces n) : (∫ x,P.source x)=P.total := by |
| dsimp only [source,total,totalMass] |
| rw [integral_finsetSum] |
| · apply Finset.sum_congr rfl |
| intro i _ |
| rw [integral_indicator measurableSet_Ioo,← integral_Ioc_eq_integral_Ioo, |
| ← intervalIntegral.integral_of_le (P.lt i).le] |
| rfl |
| · intro i _ |
| exact (P.piece_integrable i).integrable_indicator measurableSet_Ioo |
|
|
| end |
| end Contingency.Interpolation.SourcePieces |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory |
| namespace Contingency.Interpolation |
| noncomputable section |
| variable {q : ℕ} |
|
|
| |
|
|
| theorem boxPieces_source_eq (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) (x : ℝ) |
| (hx : x∉endpoints S) : (boxPieces S F).source x=marginal S F x := by |
| classical |
| by_cases hs : (boxUnion (slices S x)).Nonempty |
| · obtain ⟨i,hi⟩ := boxPieces_cover S F x hx hs |
| rw [(boxPieces S F).source_on i x hi,boxPieces_slice S F i x hi] |
| rfl |
| · have hzero : marginal S F x=0 := by |
| rw [marginal,Set.not_nonempty_iff_eq_empty.mp hs] |
| simp |
| rw [hzero] |
| apply SourcePieces.source_off |
| intro i hi |
| have hne := activeSlice_nonempty S _ (gridLower_mem S i) |
| rw [slices_constant S (gridLower S i) _ x (midpoint_mem S _ (gridLower_mem S i)) hi] at hne |
| exact hs hne |
|
|
| theorem boxPieces_source_ae (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) : |
| (boxPieces S F).source =ᵐ[volume] marginal S F := by |
| filter_upwards [(endpoints S).finite_toSet.countable.ae_notMem volume] with x hx |
| exact boxPieces_source_eq S F x hx |
|
|
| |
|
|
| theorem boxPieces_total (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) : |
| (boxPieces S F).total=∫ z in boxUnion S,F.f z := by |
| rw [← SourcePieces.source_integral,integral_congr_ae (boxPieces_source_ae S F)] |
| exact (marginal_fubini S F).2 |
|
|
| theorem activeEndpoints_nonempty (S : Finset (OpenBox (q+1))) (F : GoodWeight (q+1)) |
| (hs : (boxUnion S).Nonempty) : 0 < (activeEndpoints S).card := by |
| by_contra hh |
| have he : (activeEndpoints S).card=0 := Nat.eq_zero_of_not_pos hh |
| have hm : (boxPieces S F).total=0 := by |
| dsimp [SourcePieces.total,totalMass] |
| have : IsEmpty (Fin (activeEndpoints S).card) := he ▸ inferInstanceAs (IsEmpty (Fin 0)) |
| exact Finset.sum_eq_zero fun i _ => isEmptyElim i |
| rw [boxPieces_total S F] at hm |
| exact (F.integral_pos S hs).ne' hm |
|
|
| end |
| end Contingency.Interpolation |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory Filter |
| open scoped Topology |
| namespace Contingency.Interpolation |
| noncomputable section |
|
|
| |
|
|
| theorem piece_interpolation {n m : ℕ} (P : SourcePieces n) (Q : SourcePieces m) |
| (hn : 0 < n) (hm : 0 < m) (H : ℝ → ℝ) (S : Set ℝ) |
| (α β : ℝ) (ha : 0 < α) (hb : 0 < β) (hsum : α+β=1) |
| (hS : MeasurableSet S) (hH : IntegrableOn H S) (hpH : ∀ x∈S,0 ≤ H x) |
| (hmem : ∀ i x,x∈Ioo (P.lo i) (P.hi i) → |
| ∀ j y,y∈Ioo (Q.lo j) (Q.hi j) → α*x+β*y∈S) |
| (hcomp : ∀ i x,x∈Ioo (P.lo i) (P.hi i) → |
| ∀ j y,y∈Ioo (Q.lo j) (Q.hi j) → P.f i x^α*Q.f j y^β ≤ H (α*x+β*y)) : |
| P.total^α*Q.total^β ≤ ∫ x in S,H x := by |
| obtain ⟨U,F,hu,hud⟩ := P.quantile hn |
| obtain ⟨V,G,hv,hvd⟩ := Q.quantile hm |
| let D := P.good ∩ Q.good |
| have hD : MeasurableSet D := P.good_measurable.inter Q.good_measurable |
| have hdae : D =ᵐ[volume] Ioo (0:ℝ) 1 := by |
| filter_upwards [P.good_ae hn,Q.good_ae hm] with x hx hy |
| change (x∈P.good) = (x∈Ioo (0:ℝ) 1) at hx |
| change (x∈Q.good) = (x∈Ioo (0:ℝ) 1) at hy |
| change (x∈P.good ∧ x∈Q.good) = (x∈Ioo (0:ℝ) 1) |
| rw [hx,hy]; simp |
| have hdvol : volume D=1 := by rw [measure_congr hdae]; simp |
| let z := fun t => α*U t+β*V t |
| let z' := fun t => α*(P.total/F t)+β*(Q.total/G t) |
| have hz : StrictMonoOn z D := by |
| intro x hx y hy hxy |
| exact add_lt_add (mul_lt_mul_of_pos_left (hu hx.1 hy.1 hxy) ha) |
| (mul_lt_mul_of_pos_left (hv hx.2 hy.2 hxy) hb) |
| have hzder (t) (ht : t∈D) : HasDerivAt z (z' t) t := by |
| exact ((hud t ht.1).2.1.const_mul α).add ((hvd t ht.2).2.1.const_mul β) |
| have hzpos (t) (ht : t∈D) : 0 < z' t := |
| add_pos (mul_pos ha (div_pos (P.total_pos hn) (hud t ht.1).1)) |
| (mul_pos hb (div_pos (Q.total_pos hm) (hvd t ht.2).1)) |
| have hsub : z '' D ⊆ S := by |
| rintro _ ⟨t,ht,rfl⟩ |
| obtain ⟨i,hi,_⟩ := (hud t ht.1).2.2 |
| obtain ⟨j,hj,_⟩ := (hvd t ht.2).2.2 |
| exact hmem i _ hi j _ hj |
| have hzwi (t) (ht : t∈D) : HasDerivWithinAt z (z' t) D t := |
| (hzder t ht).hasDerivWithinAt |
| have hjint := (integrableOn_image_iff_integrableOn_abs_deriv_smul hD hzwi hz.injOn H).mp (hH.mono_set hsub) |
| have heq := integral_image_eq_integral_abs_deriv_smul hD hzwi hz.injOn H |
| have hecomp (t) (ht : t∈D) : P.total^α*Q.total^β ≤ |z' t| • H (z t) := by |
| rw [smul_eq_mul,abs_of_pos (hzpos t ht)] |
| obtain ⟨i,hi,hFi⟩ := (hud t ht.1).2.2 |
| obtain ⟨j,hj,hGj⟩ := (hvd t ht.2).2.2 |
| have h1 := transport_amgm P.total Q.total (F t) (G t) α β |
| (P.total_pos hn) (Q.total_pos hm) (hud t ht.1).1 (hvd t ht.2).1 ha.le hb.le hsum |
| have h2 := mul_le_mul_of_nonneg_left (hcomp i _ hi j _ hj) (hzpos t ht).le |
| rw [← hFi,← hGj] at h2 |
| dsimp [z,z'] at * |
| nlinarith only [h1,h2] |
| have hinter : (∫ t in D,P.total^α*Q.total^β) ≤ ∫ t in D,|z' t| • H (z t) := by |
| exact setIntegral_mono_on (integrableOn_const (by rw [hdvol]; exact ENNReal.one_ne_top)) hjint hD hecomp |
| have hcint : (∫ t in D,P.total^α*Q.total^β)=P.total^α*Q.total^β := by |
| simp [Measure.real,hdvol] |
| rw [hcint,← heq] at hinter |
| exact hinter.trans (setIntegral_mono_set hH (by |
| filter_upwards [ae_restrict_mem hS] with x hx |
| exact hpH x hx) hsub.eventuallyLE) |
|
|
| end |
| end Contingency.Interpolation |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory |
| open scoped Pointwise |
| namespace Contingency.Interpolation |
| noncomputable section |
|
|
| |
| theorem cons_interpolation {q : ℕ} (α β x y : ℝ) (u v : Fin q → ℝ) : |
| α • Fin.cons x u+β • Fin.cons y v=Fin.cons (α*x+β*y) (α • u+β • v) := by |
| funext i |
| refine Fin.cases ?_ (fun j => ?_) i <;> simp |
| |
| |
| |
| theorem good_box_interpolation (q : ℕ) (S₁ S₂ S₀ : Finset (OpenBox q)) |
| (F₁ F₂ F₀ : GoodWeight q) (α β : ℝ) (ha : 0<α) (hb : 0<β) (hsum : α+β=1) |
| (hmem : ∀ x∈boxUnion S₁,∀ y∈boxUnion S₂,α • x+β • y∈boxUnion S₀) |
| (hcomp : ∀ x∈boxUnion S₁,∀ y∈boxUnion S₂,F₁.f x^α*F₂.f y^β ≤ F₀.f (α • x+β • y)) : |
| (∫ x in boxUnion S₁,F₁.f x)^α*(∫ x in boxUnion S₂,F₂.f x)^β ≤ ∫ x in boxUnion S₀,F₀.f x := by |
| induction q with |
| | zero => |
| by_cases h₁ : (boxUnion S₁).Nonempty |
| · by_cases h₂ : (boxUnion S₂).Nonempty |
| · obtain ⟨x,hx⟩ := h₁ |
| obtain ⟨y,hy⟩ := h₂ |
| have hint (S : Finset (OpenBox 0)) (F : GoodWeight 0) (z : Fin 0 → ℝ) (hz : z∈boxUnion S) : |
| (∫ w in boxUnion S,F.f w)=F.f z := by |
| rw [← integral_indicator (boxUnion_measurable S),Measure.volume_pi_eq_dirac z,integral_dirac] |
| exact Set.indicator_of_mem hz _ |
| rw [hint S₁ F₁ x hx,hint S₂ F₂ y hy,hint S₀ F₀ _ (hmem x hx y hy)] |
| exact hcomp x hx y hy |
| · rw [Set.not_nonempty_iff_eq_empty.mp h₂] |
| simp only [setIntegral_empty,Real.zero_rpow hb.ne',mul_zero] |
| exact F₀.integral_nonneg S₀ |
| · rw [Set.not_nonempty_iff_eq_empty.mp h₁] |
| simp only [setIntegral_empty,Real.zero_rpow ha.ne',zero_mul] |
| exact F₀.integral_nonneg S₀ |
| | succ q ih => |
| by_cases h₁ : (boxUnion S₁).Nonempty |
| · by_cases h₂ : (boxUnion S₂).Nonempty |
| · have hinter := piece_interpolation (boxPieces S₁ F₁) (boxPieces S₂ F₂) |
| (activeEndpoints_nonempty S₁ F₁ h₁) (activeEndpoints_nonempty S₂ F₂ h₂) |
| (marginal S₀ F₀) univ α β ha hb hsum MeasurableSet.univ |
| (integrableOn_univ.mpr (marginal_fubini S₀ F₀).1) |
| (fun x _ => marginal_nonneg S₀ F₀ x) (fun _ _ _ _ _ _ => mem_univ _) (by |
| intro i x hx j y hy |
| rw [boxPieces_slice S₁ F₁ i x hx,boxPieces_slice S₂ F₂ j y hy] |
| apply ih (slices S₁ x) (slices S₂ y) (slices S₀ (α*x+β*y)) |
| (F₁.slice x) (F₂.slice y) (F₀.slice (α*x+β*y)) |
| · intro u hu v hv |
| apply (mem_slices S₀ _ _).mpr |
| rw [← cons_interpolation] |
| exact hmem _ ((mem_slices S₁ x u).mp hu) _ ((mem_slices S₂ y v).mp hv) |
| · intro u hu v hv |
| have hh := hcomp _ ((mem_slices S₁ x u).mp hu) _ ((mem_slices S₂ y v).mp hv) |
| rw [cons_interpolation] at hh |
| exact hh) |
| simpa only [boxPieces_total,setIntegral_univ,(marginal_fubini S₀ F₀).2] using hinter |
| · rw [Set.not_nonempty_iff_eq_empty.mp h₂] |
| simp only [setIntegral_empty,Real.zero_rpow hb.ne',mul_zero] |
| exact F₀.integral_nonneg S₀ |
| · rw [Set.not_nonempty_iff_eq_empty.mp h₁] |
| simp only [setIntegral_empty,Real.zero_rpow ha.ne',zero_mul] |
| exact F₀.integral_nonneg S₀ |
|
|
| end |
| end Contingency.Interpolation |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory |
| open scoped Pointwise |
| namespace Contingency.Interpolation |
| noncomputable section |
| variable {q : ℕ} |
|
|
| def clampBox (l u x : Fin q → ℝ) : Fin q → ℝ := fun i => max (l i) (min (u i) (x i)) |
|
|
| theorem clampBox_mem (l u : Fin q → ℝ) (hle : l ≤ u) (x : Fin q → ℝ) : |
| clampBox l u x∈Icc l u := by |
| constructor |
| · intro i; exact le_max_left _ _ |
| · intro i; exact max_le (hle i) (min_le_left _ _) |
| |
| theorem clampBox_eq (l u x : Fin q → ℝ) (hx : x∈Icc l u) : clampBox l u x=x := by |
| funext i |
| exact (congrArg (max (l i)) (min_eq_right (hx.2 i))).trans (max_eq_right (hx.1 i)) |
|
|
| theorem clampBox_continuous (l u : Fin q → ℝ) : Continuous (clampBox l u) := |
| continuous_pi fun i => continuous_const.max (continuous_const.min (continuous_apply i)) |
|
|
| |
|
|
| theorem good_extension (l u : Fin q → ℝ) (hle : l ≤ u) (f : (Fin q → ℝ) → ℝ) |
| (hc : ContinuousOn f (Icc l u)) (hp : ∀ x∈Icc l u,0<f x) : |
| ∃ F : GoodWeight q,∀ x∈Icc l u,F.f x=f x := by |
| obtain ⟨C,hC⟩ := isCompact_Icc.bddAbove_image (continuous_norm.comp_continuousOn hc) |
| refine ⟨⟨fun x => f (clampBox l u x),?_,?_,C,?_⟩,?_⟩ |
| · exact hc.comp_continuous (clampBox_continuous l u) (clampBox_mem l u hle) |
| · intro x; exact hp _ (clampBox_mem l u hle x) |
| · intro x; exact hC ⟨clampBox l u x,clampBox_mem l u hle x,rfl⟩ |
| · intro x hx; exact congrArg f (clampBox_eq l u x hx) |
| |
| |
| |
| theorem finiteBoxInterpolation : FiniteBoxInterpolation := by |
| intro q S₁ S₂ S₀ t ht ht1 l u hbox f₁ f₂ f₀ hc₁ hc₂ hc₀ hp hmem hcomp |
| have hsub₁ : boxUnion S₁ ⊆ Icc l u := fun x hx => hbox (subset_closure (Or.inl (Or.inl hx))) |
| have hsub₂ : boxUnion S₂ ⊆ Icc l u := fun x hx => hbox (subset_closure (Or.inl (Or.inr hx))) |
| have hsub₀ : boxUnion S₀ ⊆ Icc l u := fun x hx => hbox (subset_closure (Or.inr hx)) |
| have hnon : 0 ≤ ∫ x in boxUnion S₀,f₀ x := |
| setIntegral_nonneg (boxUnion_measurable _) (fun x hx => (hp x (hsub₀ hx)).2.2.le) |
| by_cases h₁ : (boxUnion S₁).Nonempty |
| · by_cases h₂ : (boxUnion S₂).Nonempty |
| · obtain ⟨z,hz⟩ := h₁ |
| have hlu : l ≤ u := (hsub₁ hz).1.trans (hsub₁ hz).2 |
| obtain ⟨F₁,he₁⟩ := good_extension l u hlu f₁ hc₁ (fun x hx => (hp x hx).1) |
| obtain ⟨F₂,he₂⟩ := good_extension l u hlu f₂ hc₂ (fun x hx => (hp x hx).2.1) |
| obtain ⟨F₀,he₀⟩ := good_extension l u hlu f₀ hc₀ (fun x hx => (hp x hx).2.2) |
| have hinter := good_box_interpolation q S₁ S₂ S₀ F₁ F₂ F₀ (1-t) t (by linarith) ht (by ring) hmem (by |
| intro x hx y hy |
| rw [he₁ x (hsub₁ hx),he₂ y (hsub₂ hy),he₀ _ (hsub₀ (hmem x hx y hy))] |
| exact hcomp x hx y hy) |
| have hi₁ : (∫ x in boxUnion S₁,F₁.f x)=∫ x in boxUnion S₁,f₁ x := |
| setIntegral_congr_fun (boxUnion_measurable _) (fun x hx => he₁ x (hsub₁ hx)) |
| have hi₂ : (∫ x in boxUnion S₂,F₂.f x)=∫ x in boxUnion S₂,f₂ x := |
| setIntegral_congr_fun (boxUnion_measurable _) (fun x hx => he₂ x (hsub₂ hx)) |
| have hi₀ : (∫ x in boxUnion S₀,F₀.f x)=∫ x in boxUnion S₀,f₀ x := |
| setIntegral_congr_fun (boxUnion_measurable _) (fun x hx => he₀ x (hsub₀ hx)) |
| rwa [hi₁,hi₂,hi₀] at hinter |
| · rw [Set.not_nonempty_iff_eq_empty.mp h₂] |
| simpa only [setIntegral_empty,Real.zero_rpow ht.ne',mul_zero] using hnon |
| · rw [Set.not_nonempty_iff_eq_empty.mp h₁] |
| simpa only [setIntegral_empty,Real.zero_rpow (show 1-t ≠ 0 by linarith),zero_mul] using hnon |
|
|
| end |
| end Contingency.Interpolation |
|
|
| |
|
|
| |
|
|
| open Set MeasureTheory |
| open scoped Pointwise |
| namespace Contingency.Interpolation |
| noncomputable section |
| variable {q : ℕ} |
|
|
| def OpenBox.proper (B : OpenBox q) : Prop := ∀ i,B.lower i<B.upper i |
|
|
| def OpenBox.mix (B C : OpenBox q) (α β : ℝ) : OpenBox q := |
| ⟨fun i => α*B.lower i+β*C.lower i,fun i => α*B.upper i+β*C.upper i⟩ |
|
|
| theorem OpenBox.proper_of_mem (B : OpenBox q) (x : Fin q → ℝ) (hx : x∈B.carrier) : B.proper := |
| fun i => (hx i (mem_univ i)).1.trans (hx i (mem_univ i)).2 |
|
|
| theorem interval_mix (l u l' u' z α β : ℝ) (hlu : l<u) (hlu' : l'<u') |
| (ha : 0<α) (hb : 0<β) (hz : α*l+β*l'<z ∧ z<α*u+β*u') : |
| ∃ x∈Ioo l u,∃ y∈Ioo l' u',α*x+β*y=z := by |
| let D := α*(u-l)+β*(u'-l') |
| have hD : 0<D := add_pos (mul_pos ha (sub_pos.mpr hlu)) (mul_pos hb (sub_pos.mpr hlu')) |
| let s := (z-(α*l+β*l'))/D |
| have hs : 0<s := div_pos (sub_pos.mpr hz.1) hD |
| have hs1 : s<1 := (div_lt_one hD).mpr (by dsimp [D]; linarith [hz.2]) |
| refine ⟨l+s*(u-l),⟨?_,?_⟩,l'+s*(u'-l'),⟨?_,?_⟩,?_⟩ |
| · nlinarith [mul_pos hs (sub_pos.mpr hlu)] |
| · nlinarith [mul_pos (sub_pos.mpr hs1) (sub_pos.mpr hlu)] |
| · nlinarith [mul_pos hs (sub_pos.mpr hlu')] |
| · nlinarith [mul_pos (sub_pos.mpr hs1) (sub_pos.mpr hlu')] |
| · have he : s*D=z-(α*l+β*l') := div_mul_cancel₀ _ hD.ne' |
| dsimp [D] at he |
| nlinarith only [he] |
|
|
| theorem OpenBox.mem_mix_iff (B C : OpenBox q) (hB : B.proper) (hC : C.proper) |
| (α β : ℝ) (ha : 0<α) (hb : 0<β) (z : Fin q → ℝ) : |
| z∈(B.mix C α β).carrier ↔ ∃ x∈B.carrier,∃ y∈C.carrier,α • x+β • y=z := by |
| constructor |
| · intro hz |
| have h (i : Fin q) := interval_mix (B.lower i) (B.upper i) (C.lower i) (C.upper i) |
| (z i) α β (hB i) (hC i) ha hb (hz i (mem_univ i)) |
| choose x hx y hy he using h |
| exact ⟨x,fun i _ => hx i,y,fun i _ => hy i,funext he⟩ |
| · rintro ⟨x,hx,y,hy,rfl⟩ |
| intro i _ |
| exact ⟨add_lt_add (mul_lt_mul_of_pos_left (hx i (mem_univ i)).1 ha) |
| (mul_lt_mul_of_pos_left (hy i (mem_univ i)).1 hb), |
| add_lt_add (mul_lt_mul_of_pos_left (hx i (mem_univ i)).2 ha) |
| (mul_lt_mul_of_pos_left (hy i (mem_univ i)).2 hb)⟩ |
|
|
| def mixBoxes (S T : Finset (OpenBox q)) (α β : ℝ) : Finset (OpenBox q) := by |
| classical |
| exact ((S.filter OpenBox.proper) ×ˢ (T.filter OpenBox.proper)).image fun p => p.1.mix p.2 α β |
|
|
| theorem mem_mixBoxes (S T : Finset (OpenBox q)) (α β : ℝ) (ha : 0<α) (hb : 0<β) (z : Fin q → ℝ) : |
| z∈boxUnion (mixBoxes S T α β) ↔ ∃ x∈boxUnion S,∃ y∈boxUnion T,α • x+β • y=z := by |
| classical |
| simp only [boxUnion,mem_iUnion,mixBoxes,Finset.mem_image,Finset.mem_product,Finset.mem_filter] |
| constructor |
| · rintro ⟨B,⟨⟨B₁,B₂⟩,⟨⟨h₁,hp₁⟩,⟨h₂,hp₂⟩⟩,rfl⟩,hz⟩ |
| obtain ⟨x,hx,y,hy,he⟩ := (B₁.mem_mix_iff B₂ hp₁ hp₂ α β ha hb z).mp hz |
| exact ⟨x,⟨B₁,h₁,hx⟩,y,⟨B₂,h₂,hy⟩,he⟩ |
| · rintro ⟨x,⟨B₁,h₁,hx⟩,y,⟨B₂,h₂,hy⟩,he⟩ |
| refine ⟨B₁.mix B₂ α β,⟨(B₁,B₂),⟨⟨h₁,B₁.proper_of_mem x hx⟩,⟨h₂,B₂.proper_of_mem y hy⟩⟩,rfl⟩,?_⟩ |
| exact (B₁.mem_mix_iff B₂ (B₁.proper_of_mem x hx) (B₂.proper_of_mem y hy) α β ha hb z).mpr ⟨x,hx,y,hy,he⟩ |
|
|
| |
| theorem logconcave_interpolation (S T : Finset (OpenBox q)) (F : GoodWeight q) |
| (α β : ℝ) (ha : 0<α) (hb : 0<β) (hab : α+β=1) |
| (hc : ∀ x y,F.f x^α*F.f y^β ≤ F.f (α • x+β • y)) : |
| (∫ x in boxUnion S,F.f x)^α*(∫ x in boxUnion T,F.f x)^β ≤ |
| ∫ x in boxUnion (mixBoxes S T α β),F.f x := by |
| apply good_box_interpolation q S T (mixBoxes S T α β) F F F α β ha hb hab |
| · intro x hx y hy |
| exact (mem_mixBoxes S T α β ha hb _).mpr ⟨x,hx,y,hy,rfl⟩ |
| · intro x _ y _; exact hc x y |
| |
| end |
| end Contingency.Interpolation |
| |
| end |
| |
| end OAI |
| |
