Blame for lean/OAI/NumberTheory/Jacobsthal/Partitions/CommonCellSum.lean

import OAI.NumberTheory.Jacobsthal.Primes.PrimeCompactWeights
import OAI.NumberTheory.Jacobsthal.Probability.ActualCouplingUpdates

namespace OAI

namespace Erdos970
open scoped _root_.Erdos970

section

namespace NumberTheoryLean.ContinuousParentBins

open _root_.Set _root_.MeasureTheory
open scoped ENNReal
open FinitePathGeometry PrimeTiltBounds PrimeTiltMonotone ContinuousRatioBins
open HarmonicExponentMeasure WeightGlobalBounds

theorem multiplier_source_ratio {i : Side} {s t : ℝ} (hs : Valid i s) (ht : Valid i t) (u : ℝ) :
    multiplier i s u = (weight i t/weight i s)*multiplier i t u := by
  by_cases hu : u = 0
  · simp [multiplier,hu]
  · unfold multiplier
    field_simp [hu,(weight_pos hs).ne',(weight_pos ht).ne']

theorem continuous_bin_mass_ratio {i : Side} {s t a b : ℝ} (hs : Valid i s) (ht : Valid i t)
    (hsa : minRatio i s ≤ a) (hta : minRatio i t ≤ a) :
    weightedRatioLaw i s (Ico a b) = ENNReal.ofReal (weight i t/weight i s) * weightedRatioLaw i t (Ico a b) := by
  have hq : 0 ≤ weight i t/weight i s := (div_pos (weight_pos ht) (weight_pos hs)).le
  simp only [weightedRatioLaw, withDensity_apply _ measurableSet_Ico]
  rw [ratio_restrict_bin hsa, ratio_restrict_bin hta, ← lintegral_const_mul' _ _ ENNReal.ofReal_ne_top]
  apply lintegral_congr
  intro u
  rw [multiplier_source_ratio hs ht u, ENNReal.ofReal_mul hq]

theorem continuousBin_parent_ratio {i : Side} {s t a b : ℝ} (hs : Valid i s) (ht : Valid i t)
    (hsa : minRatio i s ≤ a) (hta : minRatio i t ≤ a) :
    continuousBin i s a b = (weight i t/weight i s)*continuousBin i t a b := by
  unfold continuousBin
  rw [continuous_bin_mass_ratio hs ht hsa hta, ENNReal.toReal_mul,
    ENNReal.toReal_ofReal (div_pos (weight_pos ht) (weight_pos hs)).le]

theorem positive_ratio_error {a b d : ℝ} (ha : 0 < a) (hb : 0 < b)
    (hlog : |Real.log a-Real.log b| ≤ d) : |a/b-1| ≤ Real.exp d-1 := by
  have hq := div_pos ha hb
  rw [← Real.log_div ha.ne' hb.ne'] at hlog
  have hlo := Real.exp_le_exp.mpr (abs_le.mp hlog).1
  have hup := Real.exp_le_exp.mpr (abs_le.mp hlog).2
  rw [Real.exp_log hq] at hlo hup
  have hsum : 2 ≤ Real.exp d+Real.exp (-d) := by
    linarith [Real.add_one_le_exp d, Real.add_one_le_exp (-d)]
  rw [abs_le]
  constructor <;> linarith

theorem continuous_parent_bin_error : ∃ C : ℝ, 0 < C ∧ ∀ S : ℝ, 3 ≤ S →
    ∀ i : Side, ∀ s t a b : ℝ, Valid i s → Valid i t → s ≤ S → t ≤ S →
      minRatio i s ≤ a → minRatio i t ≤ a →
      |continuousBin i s a b-continuousBin i t a b| ≤
        (Real.exp (C*(1+S)^3*|s-t|)-1)*continuousBin i t a b := by
  obtain ⟨C,hC,hbound⟩ := weights_log_lipschitz
  refine ⟨C,hC,?_⟩
  intro S hS i s t a b hs ht hsS htS hsa hta
  have hlogs : |Real.log (weight i s)-Real.log (weight i t)| ≤ C*(1+S)^3*|s-t| := by
    cases i with
    | even => exact (hbound S hS).1 s t hs ht hsS htS
    | odd => exact (hbound S hS).2 s t hs ht hsS htS
  have hr := positive_ratio_error (weight_pos ht) (weight_pos hs)
    ((abs_sub_comm _ _).trans_le hlogs)
  have hmass : 0 ≤ continuousBin i t a b := ENNReal.toReal_nonneg
  rw [continuousBin_parent_ratio hs ht hsa hta]
  rw [show (weight i t/weight i s)*continuousBin i t a b-continuousBin i t a b =
    (weight i t/weight i s-1)*continuousBin i t a b by ring, abs_mul, abs_of_nonneg hmass]
  exact mul_le_mul_of_nonneg_right hr hmass

end NumberTheoryLean.ContinuousParentBins

end

section

namespace NumberTheoryLean.NearbyParentFullBins

open _root_.Set _root_.MeasureTheory
open FinitePathGeometry FinitePathMeasures PrimeHistories PrimeKilledChain
open PrimeBinMembership ActualPrimeBins ContinuousKilledBins
open NormalizedPrimeBins ContinuousRatioBins ContinuousParentBins RegeneratingInverseBands

 theorem nearby_parent_full_bin_error : ∃ c C D w₀ : ℝ, 0 < c ∧ 0 < C ∧ 0 < D ∧ 1 < w₀ ∧
    ∀ w : ℝ, w₀ ≤ w → ∀ ell S : ℝ, ∀ start : Node, ∀ h : History w ell S start,
    ∀ v : ℝ, ∀ z : CostState, ∀ a b : ℝ,
      1 ≤ ell → 3 ≤ S → 0 < start.gap → Valid start.side start.ratio → start.ratio ≤ S → Consistent start →
      stateRatio z.1 ≤ S → h.node.side = stateSide z.1 →
      minRatio h.node.side h.node.ratio < a → minRatio (stateSide z.1) (stateRatio z.1) < a →
      a ≤ b → b ≤ S → b ≤ h.node.gap/ell-1 → b ≤ gapValue v z/ell-1 →
      |(chain w ell S start (some h) (liveBin a b)).toReal -
        (continuousChain v ell S (.inl z) (Sum.inl '' ratioBinSet a b)).toReal| ≤
      C*(1+S)^5*((b-a)^2+Real.exp (-c*Real.sqrt ((1/2 : ℝ)*Real.log w))) +
        epsilon w*continuousBin h.node.side h.node.ratio a b +
        (Real.exp (D*(1+S)^3*|h.node.ratio-stateRatio z.1|)-1)*
          continuousBin (stateSide z.1) (stateRatio z.1) a b := by
  obtain ⟨c,C,w₀,hc,hC,hw₀,hprime⟩ := normalized_bin_error
  obtain ⟨D,hD,hparent⟩ := continuous_parent_bin_error
  refine ⟨c,C,D,w₀,hc,hC,hD,hw₀,?_⟩
  intro w hw ell S start h v z a b hell hS hr hs hsS hcons htS hside hma hta hab hbS harrP harrC
  have hw1 := hw₀.trans_le hw
  have hell0 : 0 < ell := by linarith
  have hnvalid := terminal_valid hs h.admissible
  have hngap := terminal_gap_positive hell0.le hr hs h.admissible
  have hnS := terminal_ratio_le hsS h.admissible
  have hncons := history_consistent hell0.le hr hs hcons h
  have htvalid : Valid h.node.side (stateRatio z.1) := by rw [hside]; exact stateRatio_valid z.1
  have hta' : minRatio h.node.side (stateRatio z.1) < a := by rwa [hside]
  have ha : 0 < a := (PrimeTiltMonotone.minRatio_pos hnvalid).trans hma
  have hlow : (1/2 : ℝ) ≤ h.node.gap/(b+1) := by
    have h : ell ≤ h.node.gap/(b+1) := by
      apply (le_div_iff₀ (by linarith : 0 < b+1)).mpr
      have hm := (le_div_iff₀ hell0).mp (show b+1 ≤ h.node.gap/ell by linarith)
      nlinarith
    linarith
  rw [chain_full_bin_real h hw1 hell0 hngap hnvalid hncons hma hab hbS harrP,
    continuousChain_full_bin_real v hell0 z hbS harrC, ← hside]
  exact (abs_sub_le _ (continuousBin h.node.side h.node.ratio a b) _).trans (add_le_add
    (hprime w hw h.node.gap S hngap hS h.node.side h.node.ratio a b hnvalid hnS hma.le hab hbS hlow)
    (hparent S hS h.node.side h.node.ratio (stateRatio z.1) a b hnvalid htvalid hnS htS hma.le hta'.le))

end NumberTheoryLean.NearbyParentFullBins

end

section

namespace NumberTheoryLean.ActualSupportIntervals

open _root_.Set _root_.MeasureTheory ProbabilityTheory
open scoped ENNReal
open FinitePathGeometry FinitePathMeasures PrimeHistories PrimeKilledChain
open PrimeTiltGeometry ActualCouplingUpdates ContinuousKilledBins LowStateHorizon
open ArrivalKernelGeometry RegeneratingInverseBands PairedCostGrouping

noncomputable def upperSupport (S ell r : ℝ) : ℝ := min S (r/ell-1)

theorem prime_child_interval {w ell S : ℝ} {start : Node} (h : History w ell S start)
    (hell : 0 < ell) (hr : 0 < h.node.gap) (hs : Valid h.node.side h.node.ratio)
    (p : ℕ) (hp : p ∈ nodeChildren w ell S h.node) :
    (h.append p hp).node.ratio ∈ Icc (minRatio h.node.side h.node.ratio) (upperSupport S ell h.node.gap) := by
  classical
  have hp' := (Finset.mem_filter.mp hp).2
  have ht0 := valid_pos (child_valid hs hp)
  have hx := hp'.1
  have heq := nextExponent_childRatio hr (child_exponent_positive hell.le hp)
  have hu : childRatio w h.node.gap p < h.node.gap/ell-1 := by
    rw [← heq] at hx
    have hmul := (lt_div_iff₀ (by linarith : 0 < childRatio w h.node.gap p+1)).mp hx
    have hdiv : childRatio w h.node.gap p+1 < h.node.gap/ell := (lt_div_iff₀ hell).mpr (by nlinarith)
    linarith
  rw [History.append_node]
  exact ⟨hp'.2.2.1,le_min hp'.2.2.2 hu.le⟩

theorem prime_row_interval {w ell S : ℝ} {start : Node} (h : History w ell S start)
    (hell : 0 < ell) (hr : 0 < h.node.gap) (hs : Valid h.node.side h.node.ratio) :
    ∀ᵐ k ∂chain w ell S start (some h),
      match k with
      | none => True
      | some k => k.node.ratio ∈ Icc (minRatio h.node.side h.node.ratio) (upperSupport S ell h.node.gap) := by
  filter_upwards [prime_follows h] with k hk
  cases k with
  | none => trivial
  | some k =>
    obtain ⟨p,hp,rfl⟩ := hk
    exact prime_child_interval h hell hr hs p hp

theorem costKernel_lower_support (z : CostState) :
    ∀ᵐ y ∂costKernel z, minRatio (stateSide z.1) (stateRatio z.1) ≤ stateRatio y.1 := by
  have hm : Measurable (fun s : State => (s,z.2+cost (stateRatio s))) :=
    measurable_id.prodMk (measurable_const.add (cost_measurable.comp stateRatio_measurable))
  have hP : MeasurableSet {y : CostState | minRatio (stateSide z.1) (stateRatio z.1) ≤ stateRatio y.1} :=
    measurableSet_le measurable_const (stateRatio_measurable.comp measurable_fst)
  rw [costKernel_eq_map]
  exact (ae_map_iff hm.aemeasurable hP).mpr (stateKernel_ae_minRatio z.1)

theorem continuous_interval_measurable (v ell S : ℝ) (z : CostState) :
    MeasurableSet {y : CostState | stateRatio y.1 ∈
      Icc (minRatio (stateSide z.1) (stateRatio z.1)) (upperSupport S ell (gapValue v z))} :=
  (stateRatio_measurable.comp measurable_fst) measurableSet_Icc

theorem continuous_low_interval (v S : ℝ) {ell : ℝ} (hell : 0 < ell) (z : CostState) :
    ∀ᵐ y ∂lowKernel costKernel v ell S z, stateRatio y.1 ∈
      Icc (minRatio (stateSide z.1) (stateRatio z.1)) (upperSupport S ell (gapValue v z)) := by
  rw [lowKernel,Kernel.restrict_apply]
  filter_upwards [ae_restrict_of_ae (costKernel_time_update z),ae_restrict_of_ae (costKernel_lower_support z),
    ae_restrict_mem (lowDomain_measurable v ell S)] with y htime hlo hD
  have hy : y = (y.1,z.2+cost (stateRatio y.1)) := Prod.ext rfl htime
  have hcur : currentExponent v y = nextExponent (gapValue v z) (stateRatio y.1) := by
    calc
      _ = currentExponent v (y.1,z.2+cost (stateRatio y.1)) := congrArg (currentExponent v) hy
      _ = _ := currentExponent_update v z y.1
  have hupper : stateRatio y.1 < gapValue v z/ell-1 := by
    have hx : ell < nextExponent (gapValue v z) (stateRatio y.1) := by
      rw [← hcur]
      exact hD.1
    have ht0 := OccupationBoundaries.stateRatio_pos y.1
    have hmul := (lt_div_iff₀ (by linarith : 0 < stateRatio y.1+1)).mp hx
    have hdiv : stateRatio y.1+1 < gapValue v z/ell := (lt_div_iff₀ hell).mpr (by nlinarith)
    linarith
  exact ⟨hlo,le_min hD.2 hupper.le⟩

theorem continuous_row_interval (v S : ℝ) {ell : ℝ} (hell : 0 < ell) (z : CostState) :
    ∀ᵐ y ∂continuousChain v ell S (.inl z), liftPredicate (fun y : CostState => stateRatio y.1 ∈
      Icc (minRatio (stateSide z.1) (stateRatio z.1)) (upperSupport S ell (gapValue v z))) y :=
  complete_ae _ z (continuous_interval_measurable v ell S z) (continuous_low_interval v S hell z)

end NumberTheoryLean.ActualSupportIntervals

end

section

namespace NumberTheoryLean.ActualMeshBins

open _root_.Set _root_.MeasureTheory ProbabilityTheory
open scoped ENNReal
open FinitePathGeometry FinitePathMeasures PrimeHistories PrimeKilledChain
open ActualProcessCoupling ActualCouplingSupport ActualPrimeBins ContinuousKilledBins
open MeshRatioLabels MeshBoundaryGeometry ActualSupportIntervals PrimeBinMembership
open NearbyParentFullBins ContinuousRatioBins RegeneratingInverseBands

variable {w ell S : ℝ} {start : Node}

theorem prime_label_eq_bin {mesh : ℝ} (hm : 0 < mesh) (hs : Valid start.side start.ratio)
    (hsS : start.ratio ≤ S) (j : Label S mesh) (hj : j ≠ cemeteryLabel S mesh) :
    (primeLabel w ell S mesh start) ⁻¹' {j} = liveBin (lowerEdge j) (upperEdge j) := by
  ext p
  cases p with
  | none =>
    change cemeteryLabel S mesh = j ↔ False
    simp [Ne.symm hj]
  | some h =>
    have ht := valid_pos (terminal_valid hs h.admissible)
    have hS := terminal_ratio_le hsS h.admissible
    exact ratioLabel_eq_iff hm ht.le hS j

theorem continuous_label_mass_eq_bin (v ell S : ℝ) {mesh : ℝ} (hm : 0 < mesh)
    (z : CostState) (j : Label S mesh) (hj : j ≠ cemeteryLabel S mesh) :
    continuousChain v ell S (.inl z) ((continuousLabel S mesh) ⁻¹' {j}) =
      continuousChain v ell S (.inl z) (Sum.inl '' ratioBinSet (lowerEdge j) (upperEdge j)) := by
  apply measure_congr
  filter_upwards [continuous_supported v ell S (.inl z)] with y hy
  apply propext
  cases y with
  | inr u =>
    change (cemeteryLabel S mesh = j) ↔ ∃ x ∈ ratioBinSet (lowerEdge j) (upperEdge j), (Sum.inl x : CemeteryKernel.Space CostState) = Sum.inr u
    simp [Ne.symm hj]
  | inl y =>
    have heq := ratioLabel_eq_iff hm (OccupationBoundaries.stateRatio_pos y.1).le hy j
    change (ratioLabel S mesh (stateRatio y.1) = j) ↔ ∃ x ∈ ratioBinSet (lowerEdge j) (upperEdge j), (Sum.inl x : CemeteryKernel.Space CostState) = Sum.inl y
    simpa only [Set.mem_image,Sum.inl.injEq,exists_eq_right,ratioBinSet,mem_ofPred_eq,lowerEdge,upperEdge] using heq

theorem cell_below_S_not_cemetery {S mesh : ℝ} (hm : 0 < mesh) (j : Label S mesh)
    (hj : upperEdge j ≤ S) : j ≠ cemeteryLabel S mesh := by
  intro heq
  subst j
  have hf := Nat.lt_floor_add_one (S/mesh)
  have hmul : S < ((⌊S/mesh⌋₊:ℝ)+1)*mesh := (div_lt_iff₀ hm).mp hf
  change (((binCount S mesh+1:ℕ):ℝ)+1)*mesh ≤ S at hj
  simp only [Nat.cast_add,Nat.cast_one,binCount] at hj
  nlinarith

theorem mesh_cells_disjoint {S mesh : ℝ} (hm : 0 < mesh) :
    Pairwise (fun j k : Label S mesh => Disjoint (Ico (lowerEdge j) (upperEdge j)) (Ico (lowerEdge k) (upperEdge k))) := by
  intro j k hjk
  apply Set.disjoint_left.mpr
  intro t htj htk
  have hne : j.val ≠ k.val := fun h => hjk (Fin.ext h)
  rcases lt_or_gt_of_ne hne with hlt | hgt
  · have hle : (j.val:ℝ)+1 ≤ (k.val:ℝ) := by exact_mod_cast Nat.succ_le_of_lt hlt
    have he : upperEdge j ≤ lowerEdge k := mul_le_mul_of_nonneg_right hle hm.le
    exact (htj.2.trans_le (he.trans htk.1)).false
  · have hle : (k.val:ℝ)+1 ≤ (j.val:ℝ) := by exact_mod_cast Nat.succ_le_of_lt hgt
    have he : upperEdge k ≤ lowerEdge j := mul_le_mul_of_nonneg_right hle hm.le
    exact (htk.2.trans_le (he.trans htj.1)).false

theorem continuous_mesh_sum_le_one {S mesh s : ℝ} {i : Side} (hm : 0 < mesh) (hs : Valid i s)
    (I : Finset (Label S mesh)) :
    (∑ j ∈ I,continuousBin i s (lowerEdge j) (upperEdge j)) ≤ 1 := by
  let := weightedRatioLaw_probability hs
  have hUnion := measure_biUnion_finset (μ:=weightedRatioLaw i s)
    (s:=I) (f:=fun j => Ico (lowerEdge j) (upperEdge j))
    (fun _ _ _ _ hne => mesh_cells_disjoint hm hne) (fun _ _ => measurableSet_Ico)
  have hmass : (∑ j ∈ I,weightedRatioLaw i s (Ico (lowerEdge j) (upperEdge j))) ≤ 1 := by
    rw [← hUnion]
    exact (measure_mono (subset_univ _)).trans_eq measure_univ
  unfold continuousBin
  rw [← ENNReal.toReal_sum (fun j _ => measure_ne_top (weightedRatioLaw i s) (Ico (lowerEdge j) (upperEdge j)))]
  simpa only [ENNReal.toReal_one] using ENNReal.toReal_mono ENNReal.one_ne_top hmass

theorem common_cell_error : ∃ c C D w₀ : ℝ, 0 < c ∧ 0 < C ∧ 0 < D ∧ 1 < w₀ ∧
    ∀ w : ℝ, w₀ ≤ w → ∀ ell S : ℝ, ∀ start : Node, ∀ h : History w ell S start,
    ∀ v : ℝ, ∀ z : CostState, ∀ mesh : ℝ, ∀ j : Label S mesh,
      1 ≤ ell → 3 ≤ S → 0 < start.gap → Valid start.side start.ratio → start.ratio ≤ S → Consistent start →
      stateRatio z.1 ≤ S → h.node.side = stateSide z.1 → 0 < mesh →
      fullCell (minRatio h.node.side h.node.ratio) (minRatio (stateSide z.1) (stateRatio z.1))
        (upperSupport S ell h.node.gap) (upperSupport S ell (gapValue v z)) j →
      |(chain w ell S start (some h) ((primeLabel w ell S mesh start) ⁻¹' {j})).toReal-
        (continuousChain v ell S (.inl z) ((continuousLabel S mesh) ⁻¹' {j})).toReal| ≤
        C*(1+S)^5*(mesh^2+Real.exp (-c*Real.sqrt ((1/2:ℝ)*Real.log w)))+
        epsilon w*continuousBin h.node.side h.node.ratio (lowerEdge j) (upperEdge j)+
        (Real.exp (D*(1+S)^3*|h.node.ratio-stateRatio z.1|)-1)*
          continuousBin (stateSide z.1) (stateRatio z.1) (lowerEdge j) (upperEdge j) := by
  obtain ⟨c,C,D,w₀,hc,hC,hD,hw₀,hbound⟩ := nearby_parent_full_bin_error
  refine ⟨c,C,D,w₀,hc,hC,hD,hw₀,?_⟩
  intro w hw ell S start h v z mesh j hell hS hr hs hsS hcons hzS hside hm hcell
  have hLd := (le_max_left _ _).trans_lt hcell.1
  have hLc := (le_max_right _ _).trans_lt hcell.1
  have hUd := hcell.2.trans (min_le_left _ _)
  have hUc := hcell.2.trans (min_le_right _ _)
  have hbS := hUd.trans (min_le_left _ _)
  have hbp := hUd.trans (min_le_right _ _)
  have hbc := hUc.trans (min_le_right _ _)
  have hj := cell_below_S_not_cemetery hm j hbS
  rw [prime_label_eq_bin hm hs hsS j hj,continuous_label_mass_eq_bin v ell S hm z j hj]
  have hab : lowerEdge j ≤ upperEdge j := by unfold lowerEdge upperEdge; nlinarith
  have he := hbound w hw ell S start h v z (lowerEdge j) (upperEdge j) hell hS hr hs hsS hcons hzS hside hLd hLc hab hbS hbp hbc
  have hwidth : upperEdge j-lowerEdge j = mesh := by unfold upperEdge lowerEdge; ring
  rwa [hwidth] at he

end NumberTheoryLean.ActualMeshBins

end

section

namespace NumberTheoryLean.CommonCellSum

open _root_.Set _root_.Finset _root_.MeasureTheory ProbabilityTheory
open FinitePathGeometry FinitePathMeasures PrimeHistories PrimeKilledChain
open MeshRatioLabels MeshBoundaryGeometry ActualSupportIntervals ActualMeshBins
open ActualProcessCoupling ContinuousKilledBins PrimeBinMembership
open ContinuousRatioBins RegeneratingInverseBands KernelBinConditioning

theorem common_cell_sum_error : ∃ c C D w₀ : ℝ, 0 < c ∧ 0 < C ∧ 0 < D ∧ 1 < w₀ ∧
    ∀ w : ℝ, w₀ ≤ w → ∀ ell S : ℝ, ∀ start : Node, ∀ h : History w ell S start,
    ∀ v : ℝ, ∀ z : CostState, ∀ mesh : ℝ, ∀ I : Finset (Label S mesh),
      1 ≤ ell → 3 ≤ S → 0 < start.gap → Valid start.side start.ratio → start.ratio ≤ S → Consistent start →
      stateRatio z.1 ≤ S → h.node.side = stateSide z.1 → 0 < mesh →
      (∀ j ∈ I, fullCell (minRatio h.node.side h.node.ratio) (minRatio (stateSide z.1) (stateRatio z.1))
        (upperSupport S ell h.node.gap) (upperSupport S ell (gapValue v z)) j) →
      (∑ j ∈ I, |labelMass (chain w ell S start) (primeLabel w ell S mesh start) (some h) j-
        labelMass (continuousChain v ell S) (continuousLabel S mesh) (.inl z) j|) ≤
        (S/mesh+2)*(C*(1+S)^5*(mesh^2+Real.exp (-c*Real.sqrt ((1/2:ℝ)*Real.log w))))+
        epsilon w+(Real.exp (D*(1+S)^3*|h.node.ratio-stateRatio z.1|)-1) := by
  obtain ⟨c,C,D,w₀,hc,hC,hD,hw₀,hbound⟩ := common_cell_error
  refine ⟨c,C,D,w₀,hc,hC,hD,hw₀,?_⟩
  intro w hw ell S start h v z mesh I hell hS hr hs hsS hcons hzS hside hm hcells
  let A := C*(1+S)^5*(mesh^2+Real.exp (-c*Real.sqrt ((1/2:ℝ)*Real.log w)))
  let Q := Real.exp (D*(1+S)^3*|h.node.ratio-stateRatio z.1|)-1
  let P : Label S mesh → ℝ := fun j => continuousBin h.node.side h.node.ratio (lowerEdge j) (upperEdge j)
  let R : Label S mesh → ℝ := fun j => continuousBin (stateSide z.1) (stateRatio z.1) (lowerEdge j) (upperEdge j)
  have hS1 : 0 ≤ 1+S := by linarith
  have hA : 0 ≤ A := by dsimp [A]; positivity
  have hQ : 0 ≤ Q := by
    apply sub_nonneg.mpr
    apply Real.one_le_exp_iff.mpr
    positivity
  have hPsum : (∑ j ∈ I,P j) ≤ 1 := continuous_mesh_sum_le_one hm (terminal_valid hs h.admissible) I
  have hRsum : (∑ j ∈ I,R j) ≤ 1 := continuous_mesh_sum_le_one hm (stateRatio_valid z.1) I
  have hcard : (I.card:ℝ) ≤ S/mesh+2 := by
    have h : (I.card:ℝ) ≤ (Fintype.card (Label S mesh):ℝ) := by exact_mod_cast Finset.card_le_univ I
    exact h.trans (label_card_le (by linarith) hm)
  calc
    _ ≤ ∑ j ∈ I,(A+epsilon w*P j+Q*R j) := by
      apply Finset.sum_le_sum
      intro j hj
      exact hbound w hw ell S start h v z mesh j hell hS hr hs hsS hcons hzS hside hm (hcells j hj)
    _ = (I.card:ℝ)*A+epsilon w*(∑ j ∈ I,P j)+Q*(∑ j ∈ I,R j) := by
      simp only [Finset.sum_add_distrib,Finset.sum_const,nsmul_eq_mul,← Finset.mul_sum]
    _ ≤ _ := by
      have h1 := mul_le_mul_of_nonneg_right hcard hA
      have h2 := mul_le_mul_of_nonneg_left hPsum (epsilon_pos w).le
      have h3 := mul_le_mul_of_nonneg_left hRsum hQ
      dsimp only [A,Q] at h1 h3 ⊢
      linarith

end NumberTheoryLean.CommonCellSum

end

end Erdos970

end OAI