import Mathlib
import OAI.Probability.Contingency.DenseAnalytic

namespace OAI

/-! Grid Cover. -/

noncomputable section

open Set MeasureTheory
open Set MeasureTheory
open scoped Pointwise
namespace Contingency.Grid
noncomputable section
variable {q K : ℕ}
open Contingency.Interpolation

theorem neighbors_symm (v w : Fin q → ℕ) (i : Fin q) (hn : neighbors v w i) : neighbors w v i :=
  ⟨hn.1.symm,fun j hj => (hn.2 j hj).symm⟩

theorem neighbors_unique (v w : Fin q → ℕ) (i j : Fin q)
    (hi : neighbors v w i) (hj : neighbors v w j) : i=j := by
  by_contra hne
  have he := hj.2 i hne
  rcases hi.1 with h | h <;> omega

theorem faceBox_swap (v w : Vertex q K) (i : Fin q) (r : ℝ)
    (hn : neighbors (corner v) (corner w) i) : faceBox v w i r=faceBox w v i r := by
  unfold faceBox
  congr 1 <;> funext j <;> split_ifs with hj
  · rw [max_comm]
  · have hh := hn.2 j hj
    dsimp [corner] at hh
    rw [hh]
  · rw [max_comm]
  · have hh := hn.2 j hj
    dsimp [corner] at hh
    rw [hh]

def Cut (V : Finset (Vertex q K)) :=
  {e : Vertex q K×Vertex q K // e.1∈V ∧ e.2∉V ∧ ∃ i,neighbors (corner e.1) (corner e.2) i}

instance cutFintype (V : Finset (Vertex q K)) : Fintype (Cut V) := by unfold Cut; exact Fintype.ofFinite _

def Cut.coord {V : Finset (Vertex q K)} (e : Cut V) : Fin q := Classical.choose e.property.2.2

theorem Cut.adjacent {V : Finset (Vertex q K)} (e : Cut V) :
    neighbors (corner e.val.1) (corner e.val.2) e.coord := Classical.choose_spec e.property.2.2

def Cut.neighborhood {V : Finset (Vertex q K)} (e : Cut V) (r : ℝ) : OpenBox q := faceBox e.val.1 e.val.2 e.coord r

theorem cut_cover_endpoints (V : Finset (Vertex q K)) (v w : Vertex q K) (hv : v∈V) (hw : w∉V)
    (x z : Fin q → ℝ) (hx : inside (corner v) x) (hz : inside (corner w) z)
    (r : ℝ) (hr : r ≤ 1) (hc : ∀ i,|x i-z i|<r) :
    ∃ e : Cut V,z∈(e.neighborhood r).carrier := by
  obtain ⟨u,u',i,hn,hl,hz⟩ := bounded_cut_face V v w hv hw x z hx hz r hr hc
  rcases hl with ⟨hu,hu'⟩ | ⟨hu,hu'⟩
  · let e : Cut V := ⟨(u,u'),hu,hu',i,hn⟩
    have he : e.coord=i := neighbors_unique _ _ _ _ e.adjacent hn
    exact ⟨e,by simpa only [Cut.neighborhood,he] using hz⟩
  · let e : Cut V := ⟨(u',u),hu',hu,i,neighbors_symm _ _ _ hn⟩
    have he : e.coord=i := neighbors_unique _ _ _ _ e.adjacent (neighbors_symm _ _ _ hn)
    refine ⟨e,?_⟩
    change z∈(faceBox u' u e.coord r).carrier
    rw [he,← faceBox_swap u u' i r hn]
    exact hz

 

theorem minkowski_cut_cover (V : Finset (Vertex q K)) (t : ℝ)
    (ht : 0<t) (ht1 : t<1) (hr : t*(K:ℝ) ≤ 1) :
    ∀ᵐ z : Fin q → ℝ ∂volume,
      z∈boxUnion (mixBoxes (boxes V) {cube q K} (1-t) t) \ boxUnion (boxes V) →
      ∃ e : Cut V,z∈(e.neighborhood (t*K)).carrier := by
  filter_upwards [ae_no_grid (q:=q)] with z hgrid
  rintro ⟨hz,hnz⟩
  obtain ⟨x,hx,y,hy,he⟩ := (mem_mixBoxes (boxes V) {cube q K} (1-t) t (by linarith) ht z).mp hz
  have hy' : ∀ i,0<y i ∧ y i<(K:ℝ) := (mem_cube y).mp (by simpa [boxUnion] using hy)
  have hx' := (mem_cube x).mp (bins_subset_cube V hx)
  have he' (i : Fin q) : z i=(1-t)*x i+t*y i := by simpa using (congrFun he i).symm
  have hzcube : z∈(cube q K).carrier := by
    apply (mem_cube z).mpr
    intro i
    rw [he']
    constructor
    · exact add_pos (mul_pos (by linarith) (hx' i).1) (mul_pos ht (hy' i).1)
    · have h1 := mul_lt_mul_of_pos_left (hx' i).2 (show 0<1-t by linarith)
      have h2 := mul_lt_mul_of_pos_left (hy' i).2 ht
      nlinarith only [h1,h2]
  obtain ⟨v,hv,hvx⟩ := (mem_boxes V x).mp hx
  obtain ⟨w,hwz⟩ := exists_bin z hzcube hgrid
  have hw : w∉V := fun hh => hnz ((mem_boxes V z).mpr ⟨w,hh,hwz⟩)
  apply cut_cover_endpoints V v w hv hw x z hvx hwz (t*K) hr
  intro i
  have hd : |x i-y i|<(K:ℝ) := by rw [abs_lt]; constructor <;> linarith [(hx' i).1,(hx' i).2,(hy' i).1,(hy' i).2]
  rw [he']
  have heq : x i-((1-t)*x i+t*y i)=t*(x i-y i) := by ring
  rw [heq,abs_mul,abs_of_pos ht]
  exact mul_lt_mul_of_pos_left hd ht

end
end Contingency.Grid

 

 

open Set MeasureTheory
open scoped BigOperators
namespace Contingency.Grid
noncomputable section
variable {q K : ℕ}
open Contingency.Interpolation

theorem box_integrable (F : GoodWeight q) (B : OpenBox q) : IntegrableOn F.f B.carrier := by
  simpa only [boxUnion,Finset.mem_singleton,iUnion_iUnion_eq_left] using F.integrable {B}

theorem bin_volume (v : Vertex q K) : volume (bin v).carrier=1 := by
  simp [bin,OpenBox.carrier,volume_pi_pi]

theorem box_volume_real (B : OpenBox q) (hp : ∀ i,B.lower i ≤ B.upper i) :
    (volume B.carrier).toReal=∏ i,(B.upper i-B.lower i) := by
  simp only [OpenBox.carrier,volume_pi_pi,Real.volume_Ioo,ENNReal.toReal_prod]
  congr 1
  funext i
  exact ENNReal.toReal_ofReal (sub_nonneg.mpr (hp i))

theorem faceBox_volume (v w : Vertex q K) (i : Fin q) (r : ℝ) (hr : 0 ≤ r) :
    (volume (faceBox v w i r).carrier).toReal=2*r*(1+2*r)^(q-1) := by
  have hlen (j : Fin q) : (faceBox v w i r).upper j-(faceBox v w i r).lower j=
      if j=i then 2*r else 1+2*r := by
    dsimp [faceBox]
    split_ifs <;> ring
  rw [box_volume_real _ (fun j => sub_nonneg.mp (by rw [hlen]; split_ifs <;> positivity))]
  simp_rw [hlen]
  classical
  rw [← Finset.mul_prod_erase Finset.univ (fun j => if j=i then 2*r else 1+2*r) (Finset.mem_univ i)]
  simp only [ite_true]
  have he : (∏ j∈Finset.univ.erase i,if j=i then 2*r else 1+2*r)=(1+2*r)^(q-1) := by
    calc
      _ = ∏ _j∈Finset.univ.erase i,(1+2*r) := Finset.prod_congr rfl (fun j hj => ite_eq_right (Finset.ne_of_mem_erase hj))
      _ = _ := by simp
  rw [he]

theorem integral_boxes (F : GoodWeight q) (V : Finset (Vertex q K)) :
    (∫ x in boxUnion (boxes V),F.f x)=∑ v∈V,∫ x in (bin v).carrier,F.f x := by
  have hs : boxUnion (boxes V)=⋃ v∈V,(bin v).carrier := by
    ext x
    simp only [mem_boxes,Set.mem_iUnion,mem_bin]
    constructor <;> rintro ⟨v,hv,hx⟩ <;> exact ⟨v,hv,hx⟩
  rw [hs]
  apply integral_biUnion_finset V
  · intro v _; exact (bin v).isOpen.measurableSet
  · intro v _ w _ hne; exact bins_disjoint hne
  · intro v _; exact box_integrable F (bin v)

theorem bin_integral_bounds (F : GoodWeight q) (W : Vertex q K → ℝ)
    (hp : ∀ v x,x∈(bin v).carrier → W v/4 ≤ F.f x ∧ F.f x ≤ 4*W v) (v : Vertex q K) :
    W v/4 ≤ ∫ x in (bin v).carrier,F.f x ∧ (∫ x in (bin v).carrier,F.f x) ≤ 4*W v := by
  have hi := box_integrable F (bin v)
  have hj (a : ℝ) : IntegrableOn (fun _ : Fin q → ℝ => a) (bin v).carrier :=
    integrableOn_const (by rw [bin_volume]; exact ENNReal.one_ne_top)
  have hc (a : ℝ) : (∫ _ in (bin v).carrier,a)=a := by simp [bin_volume,Measure.real]
  constructor
  · rw [← hc (W v/4)]
    exact setIntegral_mono_on (hj _) hi (bin v).isOpen.measurableSet (fun x hx => (hp v x hx).1)
  · rw [← hc (4*W v)]
    exact setIntegral_mono_on hi (hj _) (bin v).isOpen.measurableSet (fun x hx => (hp v x hx).2)

theorem boxes_integral_bounds (F : GoodWeight q) (W : Vertex q K → ℝ)
    (hp : ∀ v x,x∈(bin v).carrier → W v/4 ≤ F.f x ∧ F.f x ≤ 4*W v) (V : Finset (Vertex q K)) :
    (∑ v∈V,W v)/4 ≤ ∫ x in boxUnion (boxes V),F.f x ∧
      (∫ x in boxUnion (boxes V),F.f x) ≤ 4*∑ v∈V,W v := by
  rw [integral_boxes]
  constructor
  · rw [Finset.sum_div]
    exact Finset.sum_le_sum fun v _ => (bin_integral_bounds F W hp v).1
  · rw [Finset.mul_sum]
    exact Finset.sum_le_sum fun v _ => (bin_integral_bounds F W hp v).2

end
end Contingency.Grid

 

 

open Set MeasureTheory
open scoped BigOperators Pointwise
namespace Contingency.Grid
noncomputable section
variable {q K : ℕ}
open Contingency.Interpolation

theorem face_volume_bound (d : ℝ) (hd : 1 ≤ d) (hq : (q:ℝ) ≤ d)
    (v w : Vertex q K) (i : Fin q) :
    (volume (faceBox v w i (1/(4*d))).carrier).toReal ≤ 1 := by
  have hd0 : 0<d := by linarith
  rw [faceBox_volume _ _ _ _ (by positivity)]
  have hexp : (1+2*(1/(4*d)))^(q-1) ≤ 2 := by
    calc
      _ ≤ (Real.exp (2*(1/(4*d))))^(q-1) := by
        apply pow_le_pow_left₀ (by positivity)
        linarith only [Real.add_one_le_exp (2*(1/(4*d)))]
      _ = Real.exp ((q-1:ℕ)*(2*(1/(4*d)))) := (Real.exp_nat_mul _ _).symm
      _ ≤ Real.exp (1/2) := by
        apply Real.exp_le_exp.mpr
        have hq' : ((q-1:ℕ):ℝ) ≤ d := (Nat.cast_le.mpr (Nat.sub_le q 1)).trans hq
        have he : ((q-1:ℕ):ℝ)*(2*(1/(4*d)))=((q-1:ℕ):ℝ)/(2*d) := by ring
        rw [he]
        apply (div_le_iff₀ (by positivity : 0<2*d)).mpr
        linarith only [hq']
      _ ≤ 2 := by have hh := Real.exp_bound_div_one_sub_of_interval (x:=1/2) (by norm_num) (by norm_num); norm_num at hh ⊢; exact hh
  have hmul := mul_le_mul_of_nonneg_left hexp (show 0 ≤ 2*(1/(4*d)) by positivity)
  calc
    _ ≤ 2*(1/(4*d))*2 := hmul
    _ = 1/d := by ring
    _ ≤ 1 := (div_le_one hd0).mpr hd

theorem integral_cover (F : GoodWeight q) (V : Finset (Vertex q K)) (t : ℝ)
    (ht : 0<t) (ht1 : t<1) (hr : t*(K:ℝ) ≤ 1) :
    (∫ z in boxUnion (mixBoxes (boxes V) {cube q K} (1-t) t) \ boxUnion (boxes V),F.f z) ≤
      ∑ e : Cut V,∫ z in (e.neighborhood (t*K)).carrier,F.f z := by
  classical
  let G := boxUnion (mixBoxes (boxes V) {cube q K} (1-t) t) \ boxUnion (boxes V)
  have hG : MeasurableSet G := (boxUnion_measurable _).diff (boxUnion_measurable _)
  have hiG : Integrable (G.indicator F.f) :=
    ((F.integrable _).mono_set sdiff_subset).integrable_indicator hG
  have hi (e : Cut V) : Integrable ((e.neighborhood (t*K)).carrier.indicator F.f) :=
    (box_integrable F _).integrable_indicator (e.neighborhood (t*K)).isOpen.measurableSet
  have hh : (∫ z,G.indicator F.f z) ≤ ∫ z,∑ e : Cut V,(e.neighborhood (t*K)).carrier.indicator F.f z := by
    apply integral_mono_ae hiG (integrable_finsetSum _ (fun e _ => hi e))
    filter_upwards [minkowski_cut_cover V t ht ht1 hr] with z hz
    have hnon (e : Cut V) : 0 ≤ (e.neighborhood (t*K)).carrier.indicator F.f z := by
      by_cases he : z∈(e.neighborhood (t*K)).carrier <;> simp [he,(F.positive z).le]
    by_cases hzG : z∈G
    · obtain ⟨e,he⟩ := hz hzG
      rw [Set.indicator_of_mem hzG]
      calc
        _ = (e.neighborhood (t*K)).carrier.indicator F.f z := (Set.indicator_of_mem he _).symm
        _ ≤ _ := Finset.single_le_sum (fun e _ => hnon e) (Finset.mem_univ e)
    · rw [Set.indicator_of_notMem hzG]
      exact Finset.sum_nonneg fun e _ => hnon e
  rw [integral_indicator hG,integral_finsetSum _ (fun e _ => hi e)] at hh
  simp_rw [integral_indicator ((Cut.neighborhood _ _).isOpen.measurableSet)] at hh
  exact hh

end
end Contingency.Grid

 

 

open Set MeasureTheory
open scoped BigOperators Pointwise
namespace Contingency.Grid
noncomputable section
variable {q K : ℕ}
open Contingency.Interpolation

def border (V : Finset (Vertex q K)) (W : Vertex q K → ℝ) : ℝ :=
  ∑ e : Cut V,min (W e.val.1) (W e.val.2)

def Cut.reverse (V : Finset (Vertex q K)) : Cut V ≃ Cut Vᶜ where
  toFun e := ⟨(e.val.2,e.val.1),by
    refine ⟨by simpa using e.property.2.1,by simpa using e.property.1,?_⟩
    exact ⟨e.coord,neighbors_symm _ _ _ e.adjacent⟩⟩
  invFun e := ⟨(e.val.2,e.val.1),by
    refine ⟨by simpa using e.property.2.1,by simpa using e.property.1,?_⟩
    exact ⟨e.coord,neighbors_symm _ _ _ e.adjacent⟩⟩
  left_inv _ := rfl
  right_inv _ := rfl

theorem border_compl (V : Finset (Vertex q K)) (W : Vertex q K → ℝ) :
    border Vᶜ W=border V W := by
  unfold border
  rw [← (Cut.reverse V).sum_comp (fun e => min (W e.val.1) (W e.val.2))]
  apply Finset.sum_congr rfl
  intro e _
  exact min_comm _ _

theorem mass_partition (F : GoodWeight q) (V : Finset (Vertex q K)) :
    (∫ x in boxUnion (boxes V),F.f x)+(∫ x in boxUnion (boxes Vᶜ),F.f x)=
      ∫ x in (cube q K).carrier,F.f x := by
  rw [integral_boxes,integral_boxes,Finset.sum_add_sum_compl]
  rw [← integral_boxes F Finset.univ]
  exact setIntegral_congr_set cube_ae_union

theorem boxes_nonempty (V : Finset (Vertex q K)) (hV : V.Nonempty) :
    (boxUnion (boxes V)).Nonempty := by
  obtain ⟨v,hv⟩ := hV
  refine ⟨fun i => (v i:ℝ)+1/2,(mem_boxes V _).mpr ⟨v,hv,?_⟩⟩
  intro i
  dsimp [corner]
  constructor <;> linarith

theorem face_integral_bound (F : GoodWeight q) (W : Vertex q K → ℝ)
    (hW : ∀ v,0 ≤ W v) (d : ℝ) (hd : 1 ≤ d) (hq : (q:ℝ) ≤ d)
    (hp : ∀ (v w : Vertex q K) (i : Fin q),neighbors (corner v) (corner w) i →
      ∀ x,x∈(faceBox v w i (1/(4*d))).carrier → F.f x ≤ 4*min (W v) (W w))
    (V : Finset (Vertex q K)) (e : Cut V) :
    (∫ x in (e.neighborhood (1/(4*d))).carrier,F.f x) ≤ 4*min (W e.val.1) (W e.val.2) := by
  let B := e.neighborhood (1/(4*d))
  calc
    _ ≤ ∫ _x in B.carrier,4*min (W e.val.1) (W e.val.2) :=
      setIntegral_mono_on (box_integrable F B) (integrableOn_const B.isBounded.measure_lt_top.ne) B.isOpen.measurableSet
        (hp _ _ _ e.adjacent)
    _ = (volume B.carrier).toReal*(4*min (W e.val.1) (W e.val.2)) := by simp [Measure.real]
    _ ≤ _ := by
      exact mul_le_of_le_one_left (mul_nonneg (by norm_num) (le_min (hW _) (hW _))) (face_volume_bound d hd hq _ _ _)

theorem small_side_border (F : GoodWeight q) (W : Vertex q K → ℝ)
    (hW : ∀ v,0 ≤ W v) (d : ℝ) (hd : 1 ≤ d) (hq : (q:ℝ) ≤ d) (hK : 1 ≤ K)
    (hc : ∀ x y (α β : ℝ),0 ≤ α → 0 ≤ β → α+β=1 → F.f x^α*F.f y^β ≤ F.f (α • x+β • y))
    (hb : ∀ v x,x∈(bin v).carrier → W v/4 ≤ F.f x ∧ F.f x ≤ 4*W v)
    (hp : ∀ (v w : Vertex q K) (i : Fin q),neighbors (corner v) (corner w) i →
      ∀ x,x∈(faceBox v w i (1/(4*d))).carrier → F.f x ≤ 4*min (W v) (W w))
    (V : Finset (Vertex q K)) (hV : V.Nonempty)
    (hsmall : 2*(∫ x in boxUnion (boxes V),F.f x) ≤ ∫ x in (cube q K).carrier,F.f x) :
    Real.log 2/(64*d*K)*(∑ v∈V,W v) ≤ border V W := by
  let t : ℝ := 1/(4*d*K)
  have hd0 : 0<d := by linarith
  have hK' : (1:ℝ) ≤ K := by exact_mod_cast hK
  have hK0 : (0:ℝ)<K := by linarith
  have ht : 0<t := by dsimp [t]; positivity
  have ht1 : t<1 := by dsimp [t]; apply (div_lt_one (by positivity)).mpr; nlinarith
  have hr : t*(K:ℝ)=1/(4*d) := by dsimp [t]; field_simp
  have hr1 : t*(K:ℝ) ≤ 1 := by rw [hr]; apply (div_le_one (by positivity)).mpr; linarith
  have hsub : boxUnion (boxes V) ⊆ boxUnion ({cube q K} : Finset (OpenBox q)) := by
    simpa only [boxUnion,Finset.mem_singleton,iUnion_iUnion_eq_left] using bins_subset_cube V
  have hgain := mass_gain (boxes V) {cube q K} F hsub (boxes_nonempty V hV)
    (by simpa only [boxUnion,Finset.mem_singleton,iUnion_iUnion_eq_left] using hsmall) t ht ht1
    (fun x y => hc x y (1-t) t (by linarith) ht.le (by ring))
  have hcover := integral_cover F V t ht ht1 hr1
  rw [hr] at hcover
  have hface : (∑ e : Cut V,∫ x in (e.neighborhood (1/(4*d))).carrier,F.f x) ≤ 4*border V W := by
    unfold border
    rw [Finset.mul_sum]
    exact Finset.sum_le_sum fun e _ => face_integral_bound F W hW d hd hq hp V e
  have hlower := (boxes_integral_bounds F W hb V).1
  have hlog : 0<Real.log 2 := Real.log_pos (by norm_num)
  have hmult := mul_le_mul_of_nonneg_left hlower (mul_nonneg ht.le hlog.le)
  have he : t*Real.log 2*((∑ v∈V,W v)/4)/4=Real.log 2/(64*d*K)*(∑ v∈V,W v) := by dsimp [t]; ring
  rw [← he]
  linarith only [hmult,hgain,hcover,hface]

 

theorem border_bound (F : GoodWeight q) (W : Vertex q K → ℝ)
    (hW : ∀ v,0 ≤ W v) (d : ℝ) (hd : 1 ≤ d) (hq : (q:ℝ) ≤ d) (hK : 1 ≤ K)
    (hc : ∀ x y (α β : ℝ),0 ≤ α → 0 ≤ β → α+β=1 → F.f x^α*F.f y^β ≤ F.f (α • x+β • y))
    (hb : ∀ v x,x∈(bin v).carrier → W v/4 ≤ F.f x ∧ F.f x ≤ 4*W v)
    (hp : ∀ (v w : Vertex q K) (i : Fin q),neighbors (corner v) (corner w) i →
      ∀ x,x∈(faceBox v w i (1/(4*d))).carrier → F.f x ≤ 4*min (W v) (W w))
    (V : Finset (Vertex q K)) (hV : V.Nonempty) (hVc : Vᶜ.Nonempty) :
    Real.log 2/(64*d*K)*min (∑ v∈V,W v) (∑ v∈Vᶜ,W v) ≤ border V W := by
  have hnon : 0 ≤ Real.log 2/(64*d*K) := by positivity
  have hm := mass_partition F V
  by_cases hs : 2*(∫ x in boxUnion (boxes V),F.f x) ≤ ∫ x in (cube q K).carrier,F.f x
  · exact (mul_le_mul_of_nonneg_left (min_le_left _ _) hnon).trans
      (small_side_border F W hW d hd hq hK hc hb hp V hV hs)
  · have hs' : 2*(∫ x in boxUnion (boxes Vᶜ),F.f x) ≤ ∫ x in (cube q K).carrier,F.f x := by linarith
    have hh := small_side_border F W hW d hd hq hK hc hb hp Vᶜ hVc hs'
    rw [border_compl] at hh
    exact (mul_le_mul_of_nonneg_left (min_le_right _ _) hnon).trans hh

end
end Contingency.Grid

 

 

open Set MeasureTheory
open scoped BigOperators Pointwise
namespace Contingency.Grid
noncomputable section
variable {q K : ℕ}

 
def realCorner (v : Vertex q K) : Fin q → ℝ := fun i => v i

 
def exponentWeight (g : (Fin q → ℝ) → ℝ) (v : Vertex q K) : ℝ :=
  (2:ℝ)^(-(⌊g (realCorner v)⌋:ℝ))

theorem exponentWeight_pos (g : (Fin q → ℝ) → ℝ) (v : Vertex q K) :
    0<exponentWeight g v := Real.rpow_pos_of_pos (by norm_num) _

theorem exponentWeight_upper (g : (Fin q → ℝ) → ℝ) (v : Vertex q K) (x : Fin q → ℝ)
    (hh : g (realCorner v)-g x ≤ 2) : (2:ℝ)^(-g x) ≤ 4*exponentWeight g v := by
  have hf := Int.floor_le (g (realCorner v))
  calc
    _ ≤ (2:ℝ)^(-(⌊g (realCorner v)⌋:ℝ)+2) :=
      Real.rpow_le_rpow_of_exponent_le (by norm_num) (by linarith)
    _ = _ := by rw [Real.rpow_add (by norm_num : (0:ℝ)<2)]; norm_num [exponentWeight]; ring

theorem exponentWeight_lower (g : (Fin q → ℝ) → ℝ) (v : Vertex q K) (x : Fin q → ℝ)
    (hh : g x-g (realCorner v) ≤ 1) : exponentWeight g v/4 ≤ (2:ℝ)^(-g x) := by
  have hf := Int.lt_floor_add_one (g (realCorner v))
  calc
    _ = (2:ℝ)^(-(⌊g (realCorner v)⌋:ℝ)-2) := by
      rw [Real.rpow_sub (by norm_num : (0:ℝ)<2)]; norm_num [exponentWeight]
    _ ≤ _ := Real.rpow_le_rpow_of_exponent_le (by norm_num) (by linarith)

theorem bin_distance (v : Vertex q K) (x : Fin q → ℝ) (hx : x∈(bin v).carrier) :
    ‖x-realCorner v‖ ≤ 1 := by
  apply (pi_norm_le_iff_of_nonneg (by norm_num : (0:ℝ) ≤ 1)).mpr
  intro i
  have hh := (mem_bin v x).mp hx i
  dsimp [inside,corner] at hh
  simp only [Pi.sub_apply,realCorner,Real.norm_eq_abs,abs_le]
  constructor <;> linarith [hh.1,hh.2]

theorem face_distance (v w : Vertex q K) (i : Fin q) (r : ℝ) (hr : 0 ≤ r)
    (hn : neighbors (corner v) (corner w) i) (x : Fin q → ℝ)
    (hx : x∈(faceBox v w i r).carrier) : ‖x-realCorner v‖ ≤ 1+r := by
  apply (pi_norm_le_iff_of_nonneg (by linarith : (0:ℝ) ≤ 1+r)).mpr
  intro j
  have hh := (Set.mem_pi.mp hx) j (Set.mem_univ j)
  simp only [Set.mem_Ioo,faceBox] at hh
  simp only [Pi.sub_apply,realCorner,Real.norm_eq_abs,abs_le]
  by_cases hj : j=i
  · subst j
    simp only [ite_true,Nat.cast_max] at hh
    have hn' := hn.1
    dsimp [corner] at hn'
    rcases hn' with h | h
    · have he : (v i:ℝ)+1=(w i:ℝ) := by exact_mod_cast h
      have hm : max (v i:ℝ) (w i:ℝ)=(w i:ℝ) := max_eq_right (by linarith)
      rw [hm] at hh
      constructor <;> linarith [hh.1,hh.2]
    · have he : (w i:ℝ)+1=(v i:ℝ) := by exact_mod_cast h
      have hm : max (v i:ℝ) (w i:ℝ)=(v i:ℝ) := max_eq_left (by linarith)
      rw [hm] at hh
      constructor <;> linarith [hh.1,hh.2]
  · simp only [hj,ite_false] at hh
    constructor <;> linarith [hh.1,hh.2]

theorem weight_bin_comparison (g : (Fin q → ℝ) → ℝ) (L : ℝ) (hL : 0 ≤ L) (hL1 : L ≤ 1)
    (hg : ∀ x y,|g x-g y| ≤ L*‖x-y‖)
    (v : Vertex q K) (x : Fin q → ℝ) (hx : x∈(bin v).carrier) :
    exponentWeight g v/4 ≤ (2:ℝ)^(-g x) ∧ (2:ℝ)^(-g x) ≤ 4*exponentWeight g v := by
  have hh : |g x-g (realCorner v)| ≤ 1 :=
    (hg x (realCorner v)).trans ((mul_le_mul_of_nonneg_left (bin_distance v x hx) hL).trans (by simpa using hL1))
  constructor
  · exact exponentWeight_lower g v x (abs_le.mp hh).2
  · apply exponentWeight_upper
    linarith only [(abs_le.mp hh).1]

theorem weight_face_comparison (g : (Fin q → ℝ) → ℝ) (L r : ℝ) (hL : 0 ≤ L) (hr : 0 ≤ r)
    (hLr : L*(1+r) ≤ 2) (hg : ∀ x y,|g x-g y| ≤ L*‖x-y‖)
    (v w : Vertex q K) (i : Fin q) (hn : neighbors (corner v) (corner w) i)
    (x : Fin q → ℝ) (hx : x∈(faceBox v w i r).carrier) :
    (2:ℝ)^(-g x) ≤ 4*min (exponentWeight g v) (exponentWeight g w) := by
  have hv : (2:ℝ)^(-g x) ≤ 4*exponentWeight g v := by
    apply exponentWeight_upper
    have hh := (hg x (realCorner v)).trans ((mul_le_mul_of_nonneg_left (face_distance v w i r hr hn x hx) hL).trans hLr)
    linarith only [(abs_le.mp hh).1]
  have hw : (2:ℝ)^(-g x) ≤ 4*exponentWeight g w := by
    apply exponentWeight_upper
    have hx' : x∈(faceBox w v i r).carrier := by rw [← faceBox_swap v w i r hn]; exact hx
    have hh := (hg x (realCorner w)).trans ((mul_le_mul_of_nonneg_left (face_distance w v i r hr (neighbors_symm _ _ _ hn) x hx') hL).trans hLr)
    linarith only [(abs_le.mp hh).1]
  rw [mul_min_of_nonneg _ _ (by norm_num : (0:ℝ) ≤ 4)]
  exact le_min hv hw

end
end Contingency.Grid

 

 

open Set MeasureTheory
open scoped BigOperators Pointwise
namespace Contingency.Dense
noncomputable section
variable {a c q K : ℕ}
open Contingency.Grid Contingency.Interpolation

def binExponent (e : Fin q ≃ Fin a×Fin c) (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (w : Fin a → Fin c → ℝ) (d : ℝ) (x : Fin q → ℝ) : ℝ :=
  d^4*penalty R P w (d^8) d (fun s => x (e.symm s))

def binWeight (e : Fin q ≃ Fin a×Fin c) (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ)
    (w : Fin a → Fin c → ℝ) (d : ℝ) : Vertex q K → ℝ := exponentWeight (binExponent e R P w d)

theorem exponent_lipschitz (e : Fin q ≃ Fin a×Fin c)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (d : ℝ) (hd : 1 ≤ d) (he : (a*c:ℕ) ≤ d)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j)
    (hRmax : ∀ i,R i ≤ R (Fin.last a)) (hPmax : ∀ j,P j ≤ P (Fin.last c))
    (hw0 : ∀ i j,0 ≤ w i j) (hw : ∀ i j,w i j ≤ scale R P i.castSucc j.castSucc/d^8)
    (x y : Fin q → ℝ) : |binExponent e R P w d x-binExponent e R P w d y| ≤ ‖x-y‖ := by
  have hd0 : 0<d := by linarith
  let u : Fin a×Fin c → ℝ := fun s => x (e.symm s)
  let v : Fin a×Fin c → ℝ := fun s => y (e.symm s)
  have hn : ‖u-v‖ ≤ ‖x-y‖ := by
    apply (pi_norm_le_iff_of_nonneg (norm_nonneg _)).mpr
    intro s
    exact norm_le_pi_norm (x-y) (e.symm s)
  have hh := penalty_difference R P w (d^8) d (d/d^8*‖u-v‖) (by positivity) u v
    (fun i j => normalized_lipschitz R P w (d^8) d (by positivity) he hR hP hRmax hPmax hw0 hw u v i j)
  have hcoef : d^4*(d/d^8) ≤ 1 := by
    have hid : d^4*(d/d^8)=1/d^3 := by field_simp
    rw [hid]
    exact (div_le_one (by positivity)).mpr (one_le_pow₀ hd)
  unfold binExponent
  rw [← mul_sub,abs_mul,abs_of_nonneg (by positivity : 0 ≤ d^4)]
  calc
    _ ≤ d^4*(d/d^8*‖u-v‖) := mul_le_mul_of_nonneg_left hh (by positivity)
    _ ≤ ‖u-v‖ := by nlinarith only [mul_le_mul_of_nonneg_right hcoef (norm_nonneg (u-v))]
    _ ≤ _ := hn

theorem bin_density_eq (e : Fin q ≃ Fin a×Fin c)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (d : ℝ) (x : Fin q → ℝ) :
    (densityWeight e R P w (d^8) d (d^4) (by positivity)).f x=(2:ℝ)^(-binExponent e R P w d x) := by
  simp only [densityWeight,density,binExponent,neg_mul]

 

theorem bin_border_bound (e : Fin q ≃ Fin a×Fin c)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (d : ℝ) (hd : 1 ≤ d) (he : (a*c:ℕ) ≤ d) (hq : (q:ℝ) ≤ d) (hK : 1 ≤ K)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j)
    (hRmax : ∀ i,R i ≤ R (Fin.last a)) (hPmax : ∀ j,P j ≤ P (Fin.last c))
    (hw0 : ∀ i j,0 ≤ w i j) (hw : ∀ i j,w i j ≤ scale R P i.castSucc j.castSucc/d^8)
    (V : Finset (Vertex q K)) (hV : V.Nonempty) (hVc : Vᶜ.Nonempty) :
    Real.log 2/(64*d*K)*min (∑ v∈V,binWeight e R P w d v) (∑ v∈Vᶜ,binWeight e R P w d v) ≤
      border V (binWeight e R P w d) := by
  let F := densityWeight e R P w (d^8) d (d^4) (by positivity)
  have hlip (x y : Fin q → ℝ) : |binExponent e R P w d x-binExponent e R P w d y| ≤ 1*‖x-y‖ := by
    simpa only [one_mul] using exponent_lipschitz e R P w d hd he hR hP hRmax hPmax hw0 hw x y
  apply border_bound F _ (fun v => (exponentWeight_pos _ v).le) d hd hq hK
  · intro x y α β ha hb hab
    exact densityWeight_logconcave e R P w (d^8) d (d^4) (by positivity) x y α β ha hb hab
  · intro v x hx
    rw [show F.f x=(2:ℝ)^(-binExponent e R P w d x) from bin_density_eq _ _ _ _ _ _]
    exact weight_bin_comparison _ 1 (by norm_num) le_rfl hlip v x hx
  · intro v w' i hn x hx
    rw [show F.f x=(2:ℝ)^(-binExponent e R P w d x) from bin_density_eq _ _ _ _ _ _]
    apply weight_face_comparison _ 1 (1/(4*d)) (by norm_num) (by
      have hd0 : 0<d := by linarith
      positivity) _ hlip v w' i hn x hx
    have hd0 : 0<d := by linarith
    have hfrac : 1/(4*d) ≤ 1 := (div_le_one (by positivity)).mpr (by linarith)
    linarith
  · exact hV
  · exact hVc

 

theorem bin_conductance_numerator (e : Fin q ≃ Fin a×Fin c)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (d : ℝ) (hd : 1 ≤ d) (he : (a*c:ℕ) ≤ d) (hq : (q:ℝ) ≤ d) (hK : 1 ≤ K)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j)
    (hRmax : ∀ i,R i ≤ R (Fin.last a)) (hPmax : ∀ j,P j ≤ P (Fin.last c))
    (hw0 : ∀ i j,0 ≤ w i j) (hw : ∀ i j,w i j ≤ scale R P i.castSucc j.castSucc/d^8)
    (p : ℝ) (hp : 1/(16*d) ≤ p)
    (V : Finset (Vertex q K)) (hV : V.Nonempty) (hVc : Vᶜ.Nonempty) :
    1/(100000*d^2*K)*min (∑ v∈V,binWeight e R P w d v) (∑ v∈Vᶜ,binWeight e R P w d v) ≤
      p*border V (binWeight e R P w d) := by
  have hd0 : 0<d := by linarith
  have hK0 : (0:ℝ)<K := by exact_mod_cast (by omega : 0<K)
  have hb := bin_border_bound e R P w d hd he hq hK hR hP hRmax hPmax hw0 hw V hV hVc
  have hn : 0 ≤ border V (binWeight e R P w d) := by
    unfold border
    exact Finset.sum_nonneg fun v _ => le_min (exponentWeight_pos _ _).le (exponentWeight_pos _ _).le
  have hc : 1/(100000*d^2*K) ≤ (1/(16*d))*(Real.log 2/(64*d*K)) := by
    apply (div_le_iff₀ (by positivity : 0 < 100000*d^2*K)).mpr
    have hh : (1/(16*d))*(Real.log 2/(64*d*K))*(100000*d^2*K)=3125/32*Real.log 2 := by field_simp; norm_num
    rw [hh]
    linarith only [Real.log_two_gt_d9]
  have hmin : 0 ≤ min (∑ v∈V,binWeight e R P w d v) (∑ v∈Vᶜ,binWeight e R P w d v) :=
    le_min (Finset.sum_nonneg fun v _ => (exponentWeight_pos _ v).le) (Finset.sum_nonneg fun v _ => (exponentWeight_pos _ v).le)
  calc
    _ ≤ (1/(16*d))*(Real.log 2/(64*d*K))*min (∑ v∈V,binWeight e R P w d v) (∑ v∈Vᶜ,binWeight e R P w d v) := mul_le_mul_of_nonneg_right hc hmin
    _ ≤ (1/(16*d))*border V (binWeight e R P w d) := by rw [mul_assoc]; exact mul_le_mul_of_nonneg_left hb (by positivity)
    _ ≤ _ := mul_le_mul_of_nonneg_right hp hn

end
end Contingency.Dense

 

 

open Set MeasureTheory
open scoped BigOperators
namespace Contingency.Dense
noncomputable section
variable {a c q K : ℕ}
open Contingency.Grid Contingency.Interpolation

theorem region_volume_pos (f : (Fin (a+1)×Fin (c+1)) → (Fin q → ℝ) → ℝ)
    (hf : ∀ i,Continuous (f i)) (u : Fin q → ℝ) (hu : ∀ i,0<f i u) :
    0 < volume (region f 0) := by
  let S := {x | ∀ i,0<f i x}
  have ho : IsOpen S := by
    have he : S=⋂ i,{x | 0<f i x} := by ext x; simp [S]
    rw [he]
    exact isOpen_iInter_of_finite fun i => isOpen_lt continuous_const (hf i)
  exact (ho.measure_pos volume ⟨u,hu⟩).trans_le (measure_mono (fun x hx i => (hx i).le))

theorem dense_density_volume (e : Fin q ≃ Fin a×Fin c)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (d : ℝ) (hd : 4 ≤ d) (hq : (q:ℝ) ≤ d) (u : Fin q → ℝ)
    (hu : ∀ i,1/(2*d) ≤ constraints e R P w i u) (S : Set (Fin q → ℝ)) :
    (∫⁻ x in S,ENNReal.ofReal ((densityWeight e R P w (d^8) d (d^4) (by positivity)).f x)) ≤
      4*volume (region (constraints e R P w) 0) := by
  let p (x : Fin q → ℝ) := penalty R P w (d^8) d (fun s => x (e.symm s))
  have hd0 : 0<d := by linarith
  apply density_layer_bound p ((penalty_continuous R P w (d^8) d).comp
    (continuous_pi fun _ => continuous_apply _)).measurable
    (fun x => penalty_nonneg _ _ _ _ _ _) (d^4) (by positivity) S
  intro j
  have hsub : {x | p x < ((j:ℝ)+1)/d^4} ∩ S ⊆
      region (constraints e R P w) (-(d/d^8+((j:ℝ)+1)/d^4)) := by
    intro x hx i
    have hh := le_penalty R P w (d^8) d (fun s => x (e.symm s)) i.1 i.2
    have hj := hx.1
    change p x < _ at hj
    change -constraints e R P w i x-d/d^8 ≤ p x at hh
    linarith only [hh,hj]
  calc
    _ ≤ volume (region (constraints e R P w) (-(d/d^8+((j:ℝ)+1)/d^4))) := measure_mono hsub
    _ ≤ ENNReal.ofReal (Real.exp (2*d^2*(d/d^8+((j:ℝ)+1)/d^4)))*volume (region (constraints e R P w) 0) :=
      relaxed_volume_dense _ (constraints_affine e R P w) d hd0 hq u hu _ (by positivity)
    _ ≤ ENNReal.ofReal ((4/3:ℝ)^(j+1))*volume (region (constraints e R P w) 0) := by
      gcongr
      exact dense_exponent_layer d hd j
    _ = _ := by
      rw [ENNReal.ofReal_pow (by norm_num),ENNReal.ofReal_div_of_pos (by norm_num : (0:ℝ)<3)]
      norm_num

theorem dense_bin_normalizer_bound (e : Fin q ≃ Fin a×Fin c)
    (R : Fin (a+1) → ℝ) (P : Fin (c+1) → ℝ) (w : Fin a → Fin c → ℝ)
    (d : ℝ) (hd : 4 ≤ d) (he : (a*c:ℕ) ≤ d) (hq : (q:ℝ) ≤ d)
    (hR : ∀ i,0<R i) (hP : ∀ j,0<P j)
    (hRmax : ∀ i,R i ≤ R (Fin.last a)) (hPmax : ∀ j,P j ≤ P (Fin.last c))
    (hw0 : ∀ i j,0 ≤ w i j) (hw : ∀ i j,w i j ≤ scale R P i.castSucc j.castSucc/d^8)
    (u : Fin q → ℝ) (hu : ∀ i,1/(2*d) ≤ constraints e R P w i u) :
    ENNReal.ofReal (∑ v : Vertex q K,binWeight e R P w d v) ≤
      16*volume (region (constraints e R P w) 0) := by
  let F := densityWeight e R P w (d^8) d (d^4) (by positivity)
  let S := boxUnion (boxes (Finset.univ : Finset (Vertex q K)))
  have hlip (x y : Fin q → ℝ) : |binExponent e R P w d x-binExponent e R P w d y| ≤ 1*‖x-y‖ := by
    simpa only [one_mul] using exponent_lipschitz e R P w d (by linarith) he hR hP hRmax hPmax hw0 hw x y
  have hb : ∀ (v : Vertex q K) x,x∈(bin v).carrier → binWeight e R P w d v/4 ≤ F.f x ∧ F.f x ≤ 4*binWeight e R P w d v := by
    intro v x hx
    rw [show F.f x=(2:ℝ)^(-binExponent e R P w d x) from bin_density_eq _ _ _ _ _ _]
    exact weight_bin_comparison _ 1 (by norm_num) le_rfl hlip v x hx
  have hint := (boxes_integral_bounds F (binWeight e R P w d) hb Finset.univ).1
  have hsum : (∑ v : Vertex q K,binWeight e R P w d v) ≤ 4*(∫ x in S,F.f x) := by
    dsimp [S]
    simpa only [mul_comm] using (div_le_iff₀ (by norm_num : (0:ℝ)<4)).mp hint
  calc
    _ ≤ ENNReal.ofReal (4*(∫ x in S,F.f x)) := ENNReal.ofReal_le_ofReal hsum
    _ = 4*(∫⁻ x in S,ENNReal.ofReal (F.f x)) := by
      rw [ENNReal.ofReal_mul (by norm_num),ofReal_integral_eq_lintegral_ofReal (F.integrable _) (Filter.Eventually.of_forall fun x => (F.positive x).le)]
      norm_num [S]
    _ ≤ 4*(4*volume (region (constraints e R P w) 0)) := by
      gcongr
      exact dense_density_volume e R P w d hd hq u hu S
    _ = _ := by rw [← mul_assoc]; norm_num

end
end Contingency.Dense

end

end OAI