lean/OAI/Geometry/PinnedDistances/UnboundedContradiction.lean

import OAI.Geometry.PinnedDistances.TreeContradiction

namespace OAI

universe u1 u2 u3 u4 u5 u6 u7 u8 u9 u10 u11 u12
universe u13 u14 u15 u16 u17 u18 u19 u20 u21 u22 u23

section
namespace WeakPinned.Hierarchy.Depth
open MeasureTheory
variable {P : Type u1} [Fintype P] [DecidableEq P]
variable (d : Depth P)

lemma transformed_half (r : ℝ) (C : Finset P) (hC : C ∈ d.transformed r) :
    2*C.card≤Fintype.card P := by
  rw [transformed,Multiset.mem_add] at hC
  rcases hC with hC | hC
  · exact Nat.le_of_not_gt (Finset.mem_filter.mp hC).2
  · obtain ⟨B,hB,hBC⟩ := Multiset.mem_map.mp hC
    have hh := (d.mem_giants r B).mp hB
    subst C
    rw [Finset.card_compl]
    have := Finset.card_le_univ B
    omega

lemma mass_half (C : Finset P) (hC : Fintype.card P<2*C.card) : d.mass C=0 := by
  have hz (r : ℝ) : d.count r C=0 := by
    unfold count
    have hh : C ∉ d.transformed r := fun hc => hC.not_ge (d.transformed_half r C hc)
    simp [Multiset.count_eq_zero.mpr hh]
  simp [mass,hz]
end WeakPinned.Hierarchy.Depth

namespace WeakPinned.Global
open Hierarchy
variable {P : Type u2} [Fintype P] [DecidableEq P]
variable {K : Type u3} [Field K] [NumberField K]
variable (Z : P → K) (hZ : Function.Injective Z)
lemma cellMass_half (C : Finset P) (hC : Fintype.card P<2*C.card) : cellMass Z hZ C=0 := by
  simp only [cellMass,Depth.mass_half _ C hC,MeasureTheory.integral_zero,mul_zero,Finset.sum_const_zero,add_zero]

lemma totalMass_half (Z₂ : P → K) (h₂ : Function.Injective Z₂)
    (C : Finset P) (hC : 1/2<Variance.cellProb Finset.univ C) :
    totalMass Z Z₂ hZ h₂ C=0 := by
  have hn0 : (0:ℝ)<Fintype.card P := by
    by_contra! hn
    have hz : Fintype.card P=0 := by exact_mod_cast (le_antisymm hn (Nat.cast_nonneg _))
    simp [Variance.cellProb,hz] at hC
    linarith
  have hh : Fintype.card P<2*C.card := by
    simp only [Variance.cellProb,Finset.univ_inter,Finset.card_univ] at hC
    have hl := (lt_div_iff₀ hn0).mp hC
    exact_mod_cast (show (Fintype.card P:ℝ)<2*C.card by linarith)
  simp only [totalMass,cellMass_half _ _ C hh,add_zero]
end WeakPinned.Global

namespace WeakPinned.Variance
open scoped BigOperators
open Cuts SmallFiber
variable {P : Type u4} {I : Type u5} [Fintype P] [Fintype I] [DecidableEq P]

omit [Fintype P] in
lemma uniform_slice_nonneg (w : I → ℝ) (B : I → Finset P) (src : I → P) (lam : ℝ)
    (hw : ∀ i, 0≤w i) (C : Finset P) : 0 ≤ slice w (fun i => prob (B i)) src lam C := by
  unfold slice
  exact Finset.sum_nonneg (fun i _ => mul_nonneg (hw i) (by
    split_ifs
    · simp only [SmallFiber.mass,sum_prob_cell]; exact cellProb_nonneg _ _
    · exact le_rfl))

omit [Fintype P] in
lemma edgeCell_le_one (w : I → ℝ) (B : I → Finset P) (src : I → P)
    (hw : ∀ i, 0≤w i) (hW : (∑ i, w i)≤1) (C : Finset P) :
    edgeCell w (fun i => prob (B i)) src C≤1 := by
  rw [edgeCell_formula]
  apply le_trans _ hW
  apply Finset.sum_le_sum
  intro i _
  by_cases hi : src i ∈ C
  · simp only [ite_eq_left hi,SmallFiber.mass,sum_prob_cell]
    nlinarith [mul_le_mul_of_nonneg_left (cellProb_le_one (B i) C) (hw i)]
  · simp [hi,hw i]

/-- Positive balanced cut length pays all q-overlap except the small-fiber
slice and cell variance. This is the exact occurrence extraction inequality. -/
lemma balanced_mass_extraction (m : Finset P → ℝ) (hm : ∀ C, 0 ≤ m C)
    (hhalf : ∀ C, 1/2<cellProb Finset.univ C → m C=0)
    (w : I → ℝ) (B : I → Finset P) (src : I → P) (T δ : ℝ)
    (hw : ∀ i, 0≤w i) (hW : (∑ i, w i)≤1) (hδ : 0<δ) (_hδ4 : δ≤1/4)
    (hk : ∀ i, 2/((B i).card:ℝ)≤4*δ) :
    weightedIntegral m (edgeCell w (fun i => prob (B i)) src)≤
      weightedIntegral m (slice w (fun i => prob (B i)) src (4*δ))+
      (1/δ)*weightedIntegral m (varianceCell w B T)+
      (1/δ)*weightedIntegral m (fun C => tent δ (cellProb Finset.univ C)) := by
  have hpoint (C : Finset P) :
      m C*edgeCell w (fun i => prob (B i)) src C ≤
        m C*(slice w (fun i => prob (B i)) src (4*δ) C+
          (1/δ)*varianceCell w B T C+(1/δ)*tent δ (cellProb Finset.univ C)) := by
    by_cases hh : 1/2<cellProb Finset.univ C
    · rw [hhalf C hh]; simp
    have ha : cellProb Finset.univ C≤1/2 := le_of_not_gt hh
    apply mul_le_mul_of_nonneg_left _ (hm C)
    by_cases hs : cellProb Finset.univ C≤2*δ
    · have hx := small_mass_qCell (B := B) src T (2*δ) hw (by positivity) (fun i => by nlinarith [hk i]) C hs
      have he : (∑ i, w i*(if src i ∈ C then cellProb (B i) C else 0)) =
          edgeCell w (fun i => prob (B i)) src C := by
        rw [edgeCell_formula]; simp only [SmallFiber.mass,sum_prob_cell]
      have hf : (∑ i, w i*(if src i ∈ C ∧ cellProb (B i) C<2*(2*δ) then cellProb (B i) C else 0)) =
          slice w (fun i => prob (B i)) src (4*δ) C := by
        unfold slice
        simp only [SmallFiber.mass,sum_prob_cell,show (2:ℝ)*(2*δ)=4*δ by ring]
      rw [he,hf,show (2:ℝ)/(2*δ)=1/δ by ring] at hx
      exact hx.trans (le_add_of_nonneg_right (mul_nonneg (by positivity) (tent_nonneg _ _)))
    · have htent : δ≤tent δ (cellProb Finset.univ C) := tent_lower (le_of_not_ge hs) (by linarith)
      have hh : 1≤(1/δ)*tent δ (cellProb Finset.univ C) := by
        have := mul_le_mul_of_nonneg_left htent (show 0≤1/δ by positivity)
        simpa [ne_of_gt hδ] using this
      have he := (edgeCell_le_one w B src hw hW C).trans hh
      have hn := uniform_slice_nonneg w B src (4*δ) hw C
      have hv := mul_nonneg (show 0≤1/δ by positivity) (varianceCell_nonneg w B T hw C)
      linarith
  have hh := Finset.sum_le_sum (s:=Finset.univ) (fun C _ => hpoint C)
  change weightedIntegral m (edgeCell w (fun i => prob (B i)) src)≤_ at hh
  convert hh using 1
  simp only [weightedIntegral,mul_add,Finset.sum_add_distrib,Finset.mul_sum]
  have hcomm (f : Finset P → ℝ) :
      (1/δ) * ∑ C, m C * f C = ∑ C, m C * ((1/δ)*f C) := by
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro C _
    ring
  simp only [Finset.mul_sum] at hcomm
  rw [hcomm, hcomm]
end WeakPinned.Variance

namespace WeakPinned
open Filter Variance Global Cuts
open scoped Topology BigOperators

lemma change_scale_rate (W A X : ℕ → ℝ) (C : ℝ) (hC : 0<C)
    (hW : ∀ j, 0≤W j) (hA : ∀ j, 0≤A j) (hX : ∀ j, 0≤X j)
    (hWtop : Tendsto W atTop atTop)
    (hcomp : ∀ᶠ j in atTop, A j≤C*(W j+1))
    (hrate : Tendsto (fun j => X j/(W j+A j+1)) atTop (𝓝 0)) :
    Tendsto (fun j => X j/W j) atTop (𝓝 0) := by
  have hb : ∀ᶠ j in atTop, X j/W j≤(2+2*C)*(X j/(W j+A j+1)) := by
    filter_upwards [hWtop.eventually (eventually_ge_atTop (1:ℝ)),hcomp] with j hj hc
    have hw : 0<W j := by linarith
    have hd : 0<W j+A j+1 := by linarith [hA j]
    apply (div_le_iff₀ hw).mpr
    have hbound : W j+A j+1≤(2+2*C)*W j := by nlinarith
    have hh := mul_le_mul_of_nonneg_left hbound (hX j)
    convert (div_le_div_of_nonneg_right hh hd.le) using 1 <;> field_simp
  exact squeeze_zero' (Eventually.of_forall (fun j => div_nonneg (hX j) (hW j))) hb
    (by simpa using hrate.const_mul (2+2*C))

lemma balanced_extraction_rate (W A V L Q S a : ℕ → ℝ) (C δ b : ℝ)
    (hC : 0<C) (hδ : 0<δ) (hb : 0≤b) (hbC : 2*b*C≤1/8)
    (hW : ∀ j, 0≤W j) (hA : ∀ j, 0≤A j) (hV : ∀ j, 0≤V j)
    (hWtop : Tendsto W atTop atTop)
    (hcomp : ∀ᶠ j in atTop, A j≤C*(W j+1))
    (ha : Tendsto a atTop (𝓝 0))
    (hvar : Tendsto (fun j => V j/(W j+A j+1)) atTop (𝓝 0))
    (hQ : ∀ᶠ j in atTop, W j-a j*A j≤Q j)
    (hS : ∀ᶠ j in atTop, S j≤W j/8+b*A j+32)
    (hext : ∀ᶠ j in atTop, Q j≤S j+V j/δ+L j/δ) :
    ∀ᶠ j in atTop, (δ/4)*W j≤L j := by
  have hv := change_scale_rate W A V C hC hW hA hV hWtop hcomp hvar
  have ha0 : Tendsto (fun j => |a j|) atTop (𝓝 0) := by simpa using ha.abs
  filter_upwards [hWtop.eventually (eventually_ge_atTop (256:ℝ)),hcomp,
    ha0.eventually (gt_mem_nhds (show 0<1/(8*C) by positivity)),
    hv.eventually (gt_mem_nhds (show 0<δ/8 by positivity)),hQ,hS,hext] with j hw hc ha hv hq hs he
  have hw0 : 0<W j := by linarith
  have hac : A j≤2*C*W j := by nlinarith
  have ha' : a j*A j≤W j/4 := by
    have hh := mul_le_mul_of_nonneg_right (le_trans (le_abs_self (a j)) ha.le) (hA j)
    have hh' := mul_le_mul_of_nonneg_left hac (show 0≤1/(8*C) by positivity)
    have hz : (1/(8*C))*(2*C*W j)=W j/4 := by field_simp; ring
    rw [hz] at hh'
    exact hh.trans hh'
  have hbA : b*A j≤W j/8 := by
    have h1 := mul_le_mul_of_nonneg_left hac hb
    have h2 := mul_le_mul_of_nonneg_right hbC hw0.le
    nlinarith
  have hv' : V j/δ≤W j/8 := by
    have hh := (div_lt_iff₀ hw0).mp hv
    apply (div_le_iff₀ hδ).mpr
    nlinarith
  have hL : W j/4≤L j/δ := by linarith
  have := (le_div_iff₀ hδ).mp hL
  nlinarith

end WeakPinned

namespace WeakPinned
open Filter Variance Global Cuts SmallFiber
open scoped Topology BigOperators
variable {V : ℕ → Type u6} {I : ℕ → Type u7} {K : ℕ → Type u8} [∀ j, Fintype (V j)] [∀ j, Fintype (I j)] [∀ j, DecidableEq (V j)]
  [∀ j, Field (K j)] [∀ j, NumberField (K j)]
variable (G : ∀ j, Core.Fibers (V j) (I j)) (θ γ c : ℝ) (η : ℕ → ℝ)
  (Z₁ Z₂ : ∀ j, V j → K j) (h₁ : ∀ j, Function.Injective (Z₁ j)) (h₂ : ∀ j, Function.Injective (Z₂ j))

/-- The positive balanced-length estimate of the unbounded branch, on the
actual varying-field arithmetic models. -/
theorem arithmetic_balanced_length (hθ : 0<θ) (hγ : 0<γ) (hγ1 : γ<1) (hcγ : c<γ)
    (hn : Tendsto (fun j => (Fintype.card (V j):ℝ)) atTop atTop)
    (hη : Tendsto η atTop (𝓝 0)) (hη0 : ∀ j, 0≤η j) (hηb : ∀ j, η j≤θ/2)
    (hG : ∀ j, PreparedGraph (V j) (I j) (G j) θ γ c (η j))
    (t : ∀ j, I j → K j) (ht : ∀ j e y, y ∈ (G j).targets e →
      (Z₁ j ((G j).source e)-Z₁ j y)*(Z₂ j ((G j).source e)-Z₂ j y)=t j e)
    (hWtop : Tendsto (fun j => overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)) atTop atTop) :
    ∃ δ : ℝ, 0<δ ∧ δ≤1/8 ∧ ∀ᶠ j in atTop,
      (δ/4)*overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j) ≤
        weightedIntegral (totalMass (Z₁ j) (Z₂ j) (h₁ j) (h₂ j))
          (fun C => tent δ (cellProb Finset.univ C)) := by
  let C : ℝ := 64+8/θ
  have hC : 0<C := by dsimp [C]; positivity
  let τ : ℝ := min 1 (θ/(64*C))
  have hτ : 0<τ := lt_min (by norm_num) (by positivity)
  have hτ1 : τ≤1 := min_le_left _ _
  have hτC : 64*τ*C≤θ := by
    have hh := (le_div_iff₀ (show 0<64*C by positivity)).mp (min_le_right (1:ℝ) (θ/(64*C)))
    dsimp [τ]
    nlinarith
  let b : ℝ := 4*τ/θ
  have hb : 0≤b := by dsimp [b]; positivity
  have hbC : 2*b*C≤1/8 := by
    dsimp [b]
    apply (mul_le_mul_iff_left₀ hθ).mp
    field_simp
    nlinarith
  let R : ℝ := 8/τ^2+16/θ
  have hR : 0<R := by dsimp [R]; positivity
  let δ : ℝ := min (1/8) ((1/8)/R)
  have hδ : 0<δ := lt_min (by norm_num) (by positivity)
  have hδ8 : δ≤1/8 := min_le_left _ _
  have hδR : δ*R≤1/8 := (le_div_iff₀ hR).mp (min_le_right _ _)
  refine ⟨δ,hδ,hδ8,?_⟩
  let W := fun j => overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
  let A := fun j => potentialScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
  let m := fun j => totalMass (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
  let Q := fun j => weightedIntegral (m j) (G j).qCell
  let S := fun j => weightedIntegral (m j) (slice (G j).fiberWeight
    (fun e => prob ((G j).targets e)) (G j).source (4*δ))
  let a := fun j => 2-2*((θ-η j)/(θ+η j/8))
  have ha : Tendsto a atTop (𝓝 0) := by
    have hh := (tendsto_const_nhds (x:=(2:ℝ))).sub ((tendsto_const_nhds (x:=(2:ℝ))).mul
      (((tendsto_const_nhds (x:=θ)).sub hη).div (tendsto_const_nhds.add (hη.div_const 8))
      (show θ+(0:ℝ)/8≠0 by simpa using hθ.ne')))
    convert hh using 1
    simp [hθ.ne']
  have hcomp := arithmetic_scale_comparison G θ γ c η Z₁ Z₂ h₁ h₂ hθ hγ hγ1 hcγ hn hη hη0 hηb hG t ht
  apply balanced_extraction_rate W A (fiberVariance G c Z₁ Z₂ h₁ h₂) _ Q S a C δ b hC hδ hb hbC
    (fun j => overlapScale_nonneg _ _ _ _) (fun j => potentialScale_nonneg _ _ _ _)
    (fun j => Finset.sum_nonneg (fun B _ => mul_nonneg (totalMass_nonneg _ _ _ _ B)
      (varianceCell_nonneg _ _ _ (G j).fiberWeight_nonneg B))) hWtop hcomp ha
    (sampling_variance_rates G θ γ c η Z₁ Z₂ h₁ h₂ hθ hγ hγ1 hcγ hn hη hη0 hηb hG t ht).1
  · exact Eventually.of_forall (fun j => (hG j).overlap_lower (by linarith [hηb j]) (hη0 j)
      (m j) (baseConstant (Z₁ j) (Z₂ j) (h₁ j) (h₂ j))
      (totalPotential (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)) (totalPotential_nonneg _ _ _ _)
      (totalMass_overlap _ _ _ _ (hG j).card_ge))
  · filter_upwards [hn.eventually (eventually_ge_atTop (2/τ))] with j hj
    have hh := (hG j).arithmetic_slice (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
      (by linarith [hηb j]) (t j) (ht j) τ (4*δ) 0 (by positivity) (by linarith) hτ hτ1
      (by have := (div_le_iff₀ hτ).mp hj; nlinarith) (by norm_num)
    have hi : 1/(θ-η j)≤2/θ := by
      apply (div_le_div_iff₀ (by linarith [hηb j] : 0<θ-η j) hθ).mpr
      linarith [hηb j]
    have h1 : 2*(4*δ)/τ^2+2*(4*δ)/(θ-η j)≤1/8 := by
      have hh' := mul_le_mul_of_nonneg_left hi (show 0≤8*δ by positivity)
      dsimp [R] at hδR
      simp only [div_eq_mul_inv] at hδR hh' ⊢
      nlinarith
    have h2 : 2*τ/(θ-η j)≤b := by
      have hh' := mul_le_mul_of_nonneg_left hi (show 0≤2*τ by positivity)
      dsimp [b]
      simp only [div_eq_mul_inv] at hh' ⊢
      nlinarith
    have hW0 := overlapScale_nonneg (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
    have hA0 := potentialScale_nonneg (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
    have h1' := mul_le_mul_of_nonneg_right h1 hW0
    have h2' := mul_le_mul_of_nonneg_right h2 hA0
    simp only [neg_zero,zero_div,Real.exp_zero,mul_zero,add_zero,mul_one] at hh
    dsimp [S,W,A]
    linarith
  · have hnγ := (tendsto_rpow_atTop hγ).comp hn
    filter_upwards [hnγ.eventually (eventually_ge_atTop (2/(4*δ)))] with j hj
    have hk (i : I j) : 2/(((G j).targets i).card:ℝ)≤4*δ := by
      have hsize := (hG j).fiber i
      have hn0 : 0<(((G j).targets i).card:ℝ) := (show 0<2/(4*δ) by positivity).trans_le (hj.trans hsize.le)
      apply (div_le_iff₀ hn0).mpr
      have hh := (div_le_iff₀ (show 0<4*δ by positivity)).mp (hj.trans hsize.le)
      nlinarith
    have hh := balanced_mass_extraction (m j) (totalMass_nonneg _ _ _ _)
      (totalMass_half _ _ _ _) (G j).fiberWeight (G j).targets (G j).source
      ((Fintype.card (V j):ℝ)^(1-c)) δ (G j).fiberWeight_nonneg
      ((G j).sum_fiberWeight ((hG j).edgeCount_pos (by linarith [hηb j]))).le hδ (by linarith) hk
    dsimp [Q,S,fiberVariance]
    have he : (G j).qCell = edgeCell (G j).fiberWeight (fun e => prob ((G j).targets e)) (G j).source := funext (G j).qCell_eq
    rw [←he] at hh
    simpa only [m,one_div,mul_comm,div_eq_mul_inv,one_mul] using hh
end WeakPinned
noncomputable section
namespace WeakPinned.Cuts
open Hierarchy Variance
variable {P : Type u9} [Fintype P] [DecidableEq P]
lemma tent_length_occurrence (d : Depth P) (hn : 2≤Fintype.card P) (δ : ℝ) (hδ : 0≤δ)
    (has : ∀ x, prob (Finset.univ : Finset P) x≤δ) :
    (∑ C ∈ d.allCuts, d.cutLength (fun B => tent δ (mass (prob Finset.univ) B)) C)=
      weightedIntegral d.mass (fun C => tent δ (cellProb Finset.univ C)) := by
  have ha : ∑ x, prob (Finset.univ : Finset P) x=1 :=
    sum_prob _ (Finset.univ_nonempty_iff.mpr (Fintype.card_pos_iff.mp (by omega)))
  symm
  simp only [← sum_prob_cell]
  change weightedIntegral d.mass (fun C => tent δ (mass (prob Finset.univ) C))=_
  exact d.symmetric_integral_cut_sum hn _ (fun C hC => tent_zero_left (mass_small _ δ hδ has C hC))
    (fun C => by rw [mass_complement _ ha,tent_symm])
end WeakPinned.Cuts

namespace WeakPinned.Global
open Hierarchy Variance Cuts MeasureTheory
open scoped BigOperators
variable {P : Type u10} [Fintype P] [DecidableEq P]
variable {K : Type u11} [Field K] [NumberField K]
variable (Z₁ Z₂ : P → K) (h₁ : Function.Injective Z₁) (h₂ : Function.Injective Z₂)

lemma average_swap (f : Depth P → Depth P → ℝ) :
    average Z₂ Z₁ h₂ h₁ f=average Z₁ Z₂ h₁ h₂ (fun d d' => f d' d) := by
  classical
  unfold average placeUnion
  rw [Finset.union_comm (badPlaces Z₂ h₂)]

omit [NumberField K] in
include h₁ in
lemma integrable_weighted_left (hn : 2≤Fintype.card P) (f : Finset P → ℝ) :
    AverageIntegrable Z₁ Z₂ (fun d _ => weightedIntegral d.mass f) := by
  intro v
  apply integrable_finsetSum
  intro C _
  exact (integrable_mass_left Z₁ Z₂ h₁ hn C v).mul_const (f C)

omit [NumberField K] in
include h₂ in
lemma integrable_weighted_right (hn : 2≤Fintype.card P) (f : Finset P → ℝ) :
    AverageIntegrable Z₁ Z₂ (fun _ d' => weightedIntegral d'.mass f) := by
  intro v
  apply integrable_finsetSum
  intro C _
  exact (integrable_mass_right Z₁ Z₂ h₂ hn C v).mul_const (f C)

lemma average_weighted_left (hn : 2≤Fintype.card P) (f : Finset P → ℝ) :
    average Z₁ Z₂ h₁ h₂ (fun d _ => weightedIntegral d.mass f)=weightedIntegral (cellMass Z₁ h₁) f := by
  simp only [weightedIntegral,mul_comm _ (f _)]
  rw [average_sum Z₁ Z₂ h₁ h₂ _ (fun C v => (integrable_mass_left Z₁ Z₂ h₁ hn C v).const_mul (f C))]
  simp_rw [average_mul,average_mass_left Z₁ Z₂ h₁ h₂ hn]

lemma average_weighted_right (hn : 2≤Fintype.card P) (f : Finset P → ℝ) :
    average Z₁ Z₂ h₁ h₂ (fun _ d' => weightedIntegral d'.mass f)=weightedIntegral (cellMass Z₂ h₂) f := by
  simp only [weightedIntegral,mul_comm _ (f _)]
  rw [average_sum Z₁ Z₂ h₁ h₂ _ (fun C v => (integrable_mass_right Z₁ Z₂ h₂ hn C v).const_mul (f C))]
  simp_rw [average_mul,average_mass_right Z₁ Z₂ h₁ h₂ hn]

def localTotalIntegral (f : Finset P → ℝ) (d d' : Depth P) : ℝ :=
  weightedIntegral d.mass f+weightedIntegral d'.mass f

omit [NumberField K] in
include h₁ h₂ in
lemma integrable_total_integral (hn : 2≤Fintype.card P) (f : Finset P → ℝ) :
    AverageIntegrable Z₁ Z₂ (localTotalIntegral f) := fun v =>
  (integrable_weighted_left Z₁ Z₂ h₁ hn f v).add (integrable_weighted_right Z₁ Z₂ h₂ hn f v)

lemma average_total_integral (hn : 2≤Fintype.card P) (f : Finset P → ℝ) :
    average Z₁ Z₂ h₁ h₂ (localTotalIntegral f)=weightedIntegral (totalMass Z₁ Z₂ h₁ h₂) f := by
  change average Z₁ Z₂ h₁ h₂ (fun d d' => weightedIntegral d.mass f+weightedIntegral d'.mass f)=_
  rw [average_add Z₁ Z₂ h₁ h₂ (integrable_weighted_left Z₁ Z₂ h₁ hn f)
    (integrable_weighted_right Z₁ Z₂ h₂ hn f),average_weighted_left Z₁ Z₂ h₁ h₂ hn,
    average_weighted_right Z₁ Z₂ h₁ h₂ hn]
  simp only [weightedIntegral,totalMass,add_mul,Finset.sum_add_distrib]

end WeakPinned.Global

namespace WeakPinned.Core.Fibers
open Hierarchy Variance Cuts Global
variable {V : Type u12} {I : Type u13} [Fintype V] [Fintype I] [DecidableEq V]
variable (G : Fibers V I)
lemma two_length_upper (d d' : Depth V) (δ T : ℝ) (hδ : 0≤δ) (hT : 0<T)
    (hn : 2≤Fintype.card V) (hG : 0<G.edgeCount)
    (has : ∀ x, prob (Finset.univ : Finset V) x≤δ)
    (hps : ∀ e x, prob (G.targets e) x≤δ) (hpn : ∀ e, (G.targets e).Nonempty)
    (hrs : ∀ y x, prob (G.retainedSet T y) x≤δ) (hrn : ∀ y, (G.retainedSet T y).Nonempty) :
    δ^3*localTotalIntegral (fun C => tent δ (cellProb Finset.univ C)) d d'≤
      2*(fiberCutDiscrepancy G.fiberWeight (fun e => prob (G.targets e)) G.source δ d d'+
        fiberCutDiscrepancy G.fiberWeight (fun e => prob (G.targets e)) G.source δ d' d)+
      6*localTotalIntegral (familyCutError G.fiberWeight G.targets δ) d d'+
      2*localTotalIntegral (familyCutError (G.retainedWeight T) (G.retainedSet T) δ) d d'+
      2*G.omittedMass T*localTotalIntegral (fun C => tent δ (cellProb Finset.univ C)) d d' := by
  have h1 := G.graph_length_upper d d' δ T hδ hT hn hG has hps hpn hrs hrn
  have h2 := G.graph_length_upper d' d δ T hδ hT hn hG has hps hpn hrs hrn
  simp only [tent_length_occurrence _ hn δ hδ has,
    family_charge_occurrence _ hn G.fiberWeight G.targets hpn δ hδ hps has,
    family_charge_occurrence _ hn (G.retainedWeight T) (G.retainedSet T) hrn δ hδ hrs has] at h1 h2
  dsimp only [localTotalIntegral]
  linarith
end WeakPinned.Core.Fibers

namespace WeakPinned.Global
open Hierarchy Variance Cuts MeasureTheory
variable {V : Type u14} {I : Type u15} [Fintype V] [Fintype I] [DecidableEq V]
variable {K : Type u16} [Field K] [NumberField K]
variable (G : Core.Fibers V I) (Z₁ Z₂ : V → K) (h₁ : Function.Injective Z₁) (h₂ : Function.Injective Z₂)

lemma arithmetic_length_upper (t : I → K) (ht : ∀ e y, y∈G.targets e →
      (Z₁ (G.source e)-Z₁ y)*(Z₂ (G.source e)-Z₂ y)=t e)
    (δ T : ℝ) (hδ : 0≤δ) (hT : 0<T) (hn : 2≤Fintype.card V) (hG : 0<G.edgeCount)
    (has : ∀ x, prob (Finset.univ : Finset V) x≤δ)
    (hps : ∀ e x, prob (G.targets e) x≤δ) (hpn : ∀ e, (G.targets e).Nonempty)
    (hrs : ∀ y x, prob (G.retainedSet T y) x≤δ) (hrn : ∀ y, (G.retainedSet T y).Nonempty) :
    δ^3*weightedIntegral (totalMass Z₁ Z₂ h₁ h₂) (fun C => tent δ (cellProb Finset.univ C))≤
      48+6*weightedIntegral (totalMass Z₁ Z₂ h₁ h₂) (familyCutError G.fiberWeight G.targets δ)+
      2*weightedIntegral (totalMass Z₁ Z₂ h₁ h₂) (familyCutError (G.retainedWeight T) (G.retainedSet T) δ)+
      2*G.omittedMass T*weightedIntegral (totalMass Z₁ Z₂ h₁ h₂) (fun C => tent δ (cellProb Finset.univ C)) := by
  have hL := integrable_total_integral Z₁ Z₂ h₁ h₂ hn (fun C => tent δ (cellProb Finset.univ C))
  have hF := integrable_total_integral Z₁ Z₂ h₁ h₂ hn (familyCutError G.fiberWeight G.targets δ)
  have hR := integrable_total_integral Z₁ Z₂ h₁ h₂ hn (familyCutError (G.retainedWeight T) (G.retainedSet T) δ)
  have hp := fun e => sum_prob (G.targets e) (hpn e)
  have hD := fiber_cut_discrepancy_integrable Z₁ Z₂ h₁ h₂ G.fiberWeight (fun e => prob (G.targets e)) G.source hp δ hδ hps
  have hD' := fiber_cut_discrepancy_integrable Z₂ Z₁ h₂ h₁ G.fiberWeight (fun e => prob (G.targets e)) G.source hp δ hδ hps
  have hh := average_mono Z₁ Z₂ h₁ h₂ (fun v => (hL v).const_mul (δ^3))
    (fun v => (((((hD v).add (hD' v)).const_mul 2).add ((hF v).const_mul 6)).add
      ((hR v).const_mul 2)).add ((hL v).const_mul (2*G.omittedMass T)))
    (fun d d' => G.two_length_upper d d' δ T hδ hT hn hG has hps hpn hrs hrn)
  rw [average_add Z₁ Z₂ h₁ h₂
    (fun v => ((((hD v).add (hD' v)).const_mul 2).add ((hF v).const_mul 6)).add ((hR v).const_mul 2))
    (fun v => (hL v).const_mul (2*G.omittedMass T))] at hh
  rw [average_add Z₁ Z₂ h₁ h₂
    (fun v => (((hD v).add (hD' v)).const_mul 2).add ((hF v).const_mul 6))
    (fun v => (hR v).const_mul 2)] at hh
  rw [average_add Z₁ Z₂ h₁ h₂
    (fun v => ((hD v).add (hD' v)).const_mul 2) (fun v => (hF v).const_mul 6)] at hh
  simp only [average_mul] at hh
  have hpx (e) : prob (G.targets e) (G.source e)=0 := by simp [prob,G.no_loop e]
  have hte (e) (z) (hz : prob (G.targets e) z≠0) :
      (Z₁ (G.source e)-Z₁ z)*(Z₂ (G.source e)-Z₂ z)=t e := by
    apply ht
    by_contra h
    exact hz (by simp [prob,h])
  have hd := arithmetic_fiber_cut Z₁ Z₂ h₁ h₂ G.fiberWeight (fun e => prob (G.targets e)) G.source t
    G.fiberWeight_nonneg (G.sum_fiberWeight hG) (fun e => Core.Fibers.prob_nn (G.targets e)) hp hpx hte δ hδ hps
  have hd' := arithmetic_fiber_cut Z₂ Z₁ h₂ h₁ G.fiberWeight (fun e => prob (G.targets e)) G.source t
    G.fiberWeight_nonneg (G.sum_fiberWeight hG) (fun e => Core.Fibers.prob_nn (G.targets e)) hp hpx
    (fun e z hz => by rw [mul_comm]; exact hte e z hz) δ hδ hps
  rw [average_swap] at hd'
  rw [average_add Z₁ Z₂ h₁ h₂ hD (fun v => hD' v)] at hh
  simp only [average_total_integral Z₁ Z₂ h₁ h₂ hn] at hh
  linarith
end WeakPinned.Global
noncomputable section
namespace WeakPinned
open Filter Variance Core.Fibers
open scoped Topology
variable {V : Type u17} {I : Type u18} [Fintype V] [Fintype I] [DecidableEq V]

omit [Fintype V] in
lemma prob_bound_of_size (B : Finset V) (δ : ℝ) (hδ : 0<δ) (hB : 1/δ≤(B.card:ℝ)) :
    B.Nonempty ∧ ∀ x, prob B x≤δ := by
  have hb : 0<(B.card:ℝ) := (one_div_pos.mpr hδ).trans_le hB
  refine ⟨Finset.card_pos.mp (by exact_mod_cast hb),?_⟩
  intro x
  unfold prob
  split_ifs
  · exact (div_le_iff₀ hb).mpr (by have := (div_le_iff₀ hδ).mp hB; nlinarith)
  · exact hδ.le

lemma PreparedGraph.omitted_bound {G : Core.Fibers V I} {θ γ c η : ℝ}
    (hG : PreparedGraph V I G θ γ c η) (hθ : 0<θ) (hη : η≤θ/2) :
    G.omittedMass ((Fintype.card V:ℝ)^γ) ≤ (4/θ)*(Fintype.card V:ℝ)^(γ-1) := by
  let n : ℝ := Fintype.card V
  have hn : 2≤n := by dsimp only [n]; exact_mod_cast hG.card_ge
  have hn0 : 0<n := by linarith
  have hE := hG.edgeCount_pos (by linarith)
  have hEl : (θ/4)*n^2≤G.edgeCount := by
    have hp : 0≤(n-1)*n := mul_nonneg (by linarith) hn0.le
    have hh := mul_nonneg (show 0≤θ-η-θ/2 by linarith) hp
    have hh' := mul_nonneg (show 0≤θ/4 by positivity) (show 0≤n*(n-2) by positivity)
    dsimp [n] at *
    nlinarith [hG.lower]
  apply (G.small_incoming_mass _ (Real.rpow_nonneg hn0.le γ)).trans
  change n*n^γ/G.edgeCount≤(4/θ)*n^(γ-1)
  rw [Real.rpow_sub hn0,Real.rpow_one]
  apply (div_le_iff₀ hE).mpr
  have hh := mul_le_mul_of_nonneg_left hEl (show 0≤(4/θ)*(n^γ/n) by positivity)
  have he : (4/θ)*(n^γ/n)*((θ/4)*n^2)=n*n^γ := by field_simp
  rw [he] at hh
  exact hh

variable {Vn : ℕ → Type u19} {In : ℕ → Type u20} [∀ j, Fintype (Vn j)] [∀ j, Fintype (In j)] [∀ j, DecidableEq (Vn j)]
lemma omitted_rate (G : ∀ j, Core.Fibers (Vn j) (In j)) (θ γ c : ℝ) (η : ℕ → ℝ)
    (hθ : 0<θ) (hγ1 : γ<1) (hη : ∀ j, η j≤θ/2)
    (hn : Tendsto (fun j => (Fintype.card (Vn j):ℝ)) atTop atTop)
    (hG : ∀ j, PreparedGraph (Vn j) (In j) (G j) θ γ c (η j)) :
    Tendsto (fun j => (G j).omittedMass ((Fintype.card (Vn j):ℝ)^γ)) atTop (𝓝 0) := by
  apply squeeze_zero (fun j => (G j).omittedMass_nonneg _) (fun j => (hG j).omitted_bound hθ (hη j))
  have hh := (tendsto_rpow_neg_atTop (show 0<1-γ by linarith)).comp hn
  have he : -(1-γ)=γ-1 := by ring
  rw [he] at hh
  simpa using hh.const_mul (4/θ)

lemma sampling_atoms_eventually (G : ∀ j, Core.Fibers (Vn j) (In j)) (θ γ c : ℝ) (η : ℕ → ℝ)
    (γ0 : 0<γ) (γ1 : γ<1) (δ : ℝ) (hδ : 0<δ)
    (hn : Tendsto (fun j => (Fintype.card (Vn j):ℝ)) atTop atTop)
    (hG : ∀ j, PreparedGraph (Vn j) (In j) (G j) θ γ c (η j)) :
    ∀ᶠ j in atTop,
      (∀ x, prob (Finset.univ : Finset (Vn j)) x≤δ) ∧
      (∀ e, ((G j).targets e).Nonempty) ∧ (∀ e x, prob ((G j).targets e) x≤δ) ∧
      (∀ y, ((G j).retainedSet ((Fintype.card (Vn j):ℝ)^γ) y).Nonempty) ∧
      (∀ y x, prob ((G j).retainedSet ((Fintype.card (Vn j):ℝ)^γ) y) x≤δ) := by
  have hpow := (tendsto_rpow_atTop γ0).comp hn
  filter_upwards [hn.eventually (eventually_ge_atTop (1/δ)),hpow.eventually (eventually_ge_atTop (1/δ))] with j hnδ hnγ
  have hn1 : (1:ℝ)≤Fintype.card (Vn j) := by exact_mod_cast (show 1≤Fintype.card (Vn j) by have := (hG j).card_ge; omega)
  have hs : (Fintype.card (Vn j):ℝ)^γ≤Fintype.card (Vn j) := by
    simpa using Real.rpow_le_rpow_of_exponent_le hn1 γ1.le
  have hf (e) := prob_bound_of_size ((G j).targets e) δ hδ (hnγ.trans ((hG j).fiber e).le)
  have hr (y) := prob_bound_of_size ((G j).retainedSet ((Fintype.card (Vn j):ℝ)^γ) y) δ hδ
    (hnγ.trans ((G j).retainedSet_size _ hs y))
  exact ⟨(prob_bound_of_size Finset.univ δ hδ (by simpa using hnδ)).2,
    fun e => (hf e).1,fun e => (hf e).2,fun y => (hr y).1,fun y => (hr y).2⟩
end WeakPinned
noncomputable section
namespace WeakPinned
open Filter Variance Global Cuts
open scoped Topology BigOperators

lemma length_rate_contradiction (W F R L o : ℕ → ℝ) (δ b : ℝ) (hδ : 0<δ) (hb : 0<b)
    (hW : Tendsto W atTop atTop)
    (hF : Tendsto (fun j => F j/W j) atTop (𝓝 0))
    (hR : Tendsto (fun j => R j/W j) atTop (𝓝 0))
    (ho : Tendsto o atTop (𝓝 0))
    (hlow : ∀ᶠ j in atTop, b*W j≤L j)
    (hupp : ∀ᶠ j in atTop, δ^3*L j≤48+6*F j+2*R j+2*o j*L j) : False := by
  have h48 : Tendsto (fun j => (48:ℝ)/W j) atTop (𝓝 0) := by
    simpa only [div_eq_mul_inv,mul_zero, Function.comp_apply] using (tendsto_inv_atTop_zero.comp hW).const_mul 48
  have he : Tendsto (fun j => (48+6*F j+2*R j)/W j) atTop (𝓝 0) := by
    convert (h48.add (hF.const_mul 6)).add (hR.const_mul 2) using 1
    · ext j; ring
    · norm_num
  have hbound := ho.eventually (gt_mem_nhds (show 0<δ^3/4 by positivity))
  have hsmall := he.eventually (gt_mem_nhds (show 0<δ^3*b/2 by positivity))
  obtain ⟨j,hjW,hjo,hje,hjl,hju⟩ := (hW.eventually (eventually_gt_atTop (0:ℝ)) |>.and
    (hbound.and (hsmall.and (hlow.and hupp)))).exists
  have hl0 : 0<L j := (mul_pos hb hjW).trans_le hjl
  have hopen := mul_le_mul_of_nonneg_right hjo.le hl0.le
  have he' := (div_lt_iff₀ hjW).mp hje
  have hl' := mul_le_mul_of_nonneg_left hjl (show 0≤δ^3/2 by positivity)
  nlinarith

variable {V : ℕ → Type u21} {I : ℕ → Type u22} {K : ℕ → Type u23} [∀ j, Fintype (V j)] [∀ j, Fintype (I j)] [∀ j, DecidableEq (V j)]
  [∀ j, Field (K j)] [∀ j, NumberField (K j)]
variable (G : ∀ j, Core.Fibers (V j) (I j)) (θ γ c : ℝ) (η : ℕ → ℝ)
  (Z₁ Z₂ : ∀ j, V j → K j) (h₁ : ∀ j, Function.Injective (Z₁ j)) (h₂ : ∀ j, Function.Injective (Z₂ j))

/-- The entire unbounded regime is impossible for the actual prepared
arithmetic models, allowing arbitrary and varying number fields. -/
theorem arithmetic_no_unbounded (hθ : 0<θ) (hγ : 0<γ) (hγ1 : γ<1) (hc : 0<c) (hcγ : c<γ)
    (hn : Tendsto (fun j => (Fintype.card (V j):ℝ)) atTop atTop)
    (hη : Tendsto η atTop (𝓝 0)) (hη0 : ∀ j, 0≤η j) (hηb : ∀ j, η j≤θ/2)
    (hG : ∀ j, PreparedGraph (V j) (I j) (G j) θ γ c (η j))
    (t : ∀ j, I j → K j) (ht : ∀ j e y, y∈(G j).targets e →
      (Z₁ j ((G j).source e)-Z₁ j y)*(Z₂ j ((G j).source e)-Z₂ j y)=t j e)
    (hWtop : Tendsto (fun j => overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)) atTop atTop) : False := by
  obtain ⟨δ,hδ,_,hlow⟩ := arithmetic_balanced_length G θ γ c η Z₁ Z₂ h₁ h₂ hθ hγ hγ1 hcγ hn hη hη0 hηb hG t ht hWtop
  let W := fun j => overlapScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
  let A := fun j => potentialScale (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
  let m := fun j => totalMass (Z₁ j) (Z₂ j) (h₁ j) (h₂ j)
  let F := fun j => weightedIntegral (m j) (familyCutError (G j).fiberWeight (G j).targets δ)
  let R := fun j => weightedIntegral (m j) (familyCutError
    ((G j).retainedWeight ((Fintype.card (V j):ℝ)^γ)) ((G j).retainedSet ((Fintype.card (V j):ℝ)^γ)) δ)
  have hF0 (j) : 0≤F j := Finset.sum_nonneg (fun C _ => mul_nonneg (totalMass_nonneg _ _ _ _ C)
    (Finset.sum_nonneg (fun e _ => mul_nonneg ((G j).fiberWeight_nonneg e) (cutError_nonneg _ _ _))))
  have hR0 (j) : 0≤R j := Finset.sum_nonneg (fun C _ => mul_nonneg (totalMass_nonneg _ _ _ _ C)
    (Finset.sum_nonneg (fun y _ => mul_nonneg ((G j).retainedWeight_nonneg _ y) (cutError_nonneg _ _ _))))
  have hcomp := arithmetic_scale_comparison G θ γ c η Z₁ Z₂ h₁ h₂ hθ hγ hγ1 hcγ hn hη hη0 hηb hG t ht
  have hcut := sampling_cut_approximation_rates G θ γ c η Z₁ Z₂ h₁ h₂ δ hδ hθ hγ hγ1 hc hcγ hn hη hη0 hηb hG t ht
  have hf := change_scale_rate W A F (64+8/θ) (by positivity)
    (fun j => overlapScale_nonneg _ _ _ _) (fun j => potentialScale_nonneg _ _ _ _) hF0 hWtop hcomp hcut.1
  have hr := change_scale_rate W A R (64+8/θ) (by positivity)
    (fun j => overlapScale_nonneg _ _ _ _) (fun j => potentialScale_nonneg _ _ _ _) hR0 hWtop hcomp hcut.2
  apply length_rate_contradiction W F R (fun j => weightedIntegral (m j) (fun C => tent δ (cellProb Finset.univ C)))
    (fun j => (G j).omittedMass ((Fintype.card (V j):ℝ)^γ)) δ (δ/4) hδ (by positivity)
    hWtop hf hr (omitted_rate G θ γ c η hθ hγ1 hηb hn hG) hlow
  filter_upwards [sampling_atoms_eventually G θ γ c η hγ hγ1 δ hδ hn hG] with j hj
  exact arithmetic_length_upper (G j) (Z₁ j) (Z₂ j) (h₁ j) (h₂ j) (t j) (ht j) δ
    ((Fintype.card (V j):ℝ)^γ) hδ.le (Real.rpow_pos_of_pos (by exact_mod_cast (show 0<Fintype.card (V j) by have := (hG j).card_ge; omega)) γ)
    (hG j).card_ge ((hG j).edgeCount_pos (by linarith [hηb j])) hj.1 hj.2.2.1 hj.2.1 hj.2.2.2.2 hj.2.2.2.1
end WeakPinned

end
end
end
end

end OAI