lean/OAI/Geometry/DoublingHilbert/Rectangles.lean

import OAI.Geometry.DoublingHilbert.Integration

namespace OAI

/-! Rectangle probability measures, transport estimates, and finite averaging. -/

open MeasureTheory Set Filter
open scoped BigOperators Topology

open MeasureTheory Set Filter
open scoped Topology
noncomputable section
namespace DoublingHilbert

/-- Uniform probability on a nondegenerate real interval. -/
structure Segment where
  lo : ℝ
  hi : ℝ
  lt : lo < hi

namespace Segment

def length (I : Segment) : ℝ := I.hi - I.lo

theorem length_pos (I : Segment) : 0 < I.length := sub_pos.mpr I.lt

def law (I : Segment) : Measure ℝ :=
  (ENNReal.ofReal I.length)⁻¹ • volume.restrict (Ioc I.lo I.hi)

instance (I : Segment) : IsProbabilityMeasure I.law := by
  constructor
  simp only [law, Measure.smul_apply, Measure.restrict_apply_univ, Real.volume_Ioc, length,
    smul_eq_mul]
  exact ENNReal.inv_mul_cancel (ENNReal.ofReal_ne_zero_iff.mpr I.length_pos)
    ENNReal.ofReal_ne_top

theorem ae_iff (I : Segment) {P : ℝ → Prop} :
    (∀ᵐ x ∂I.law, P x) ↔ ∀ᵐ x, x ∈ Ioc I.lo I.hi → P x := by
  rw [law, Measure.ae_ennreal_smul_measure_iff (ENNReal.inv_ne_zero.mpr ENNReal.ofReal_ne_top),
    ae_restrict_iff' measurableSet_Ioc]

theorem ae_mem (I : Segment) : ∀ᵐ x ∂I.law, x ∈ Ioo I.lo I.hi := by
  rw [I.ae_iff]
  filter_upwards [volume.ae_ne I.hi] with x hx hmem
  exact ⟨hmem.1, lt_of_le_of_ne hmem.2 hx⟩

theorem ae_of_ae (I : Segment) {P : ℝ → Prop} (hP : ∀ᵐ x, P x) :
    ∀ᵐ x ∂I.law, P x := I.ae_iff.mpr (hP.mono fun _ hx _ => hx)

theorem integral_eq {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (I : Segment) (g : ℝ → E) :
    (∫ x, g x ∂I.law) = I.length⁻¹ • ∫ x in I.lo..I.hi, g x := by
  rw [law, integral_smul_measure, ENNReal.toReal_inv, ENNReal.toReal_ofReal I.length_pos.le,
    intervalIntegral.integral_of_le I.lt.le]

theorem integrable_iff {E : Type*} [NormedAddCommGroup E]
    (I : Segment) {g : ℝ → E} :
    Integrable g I.law ↔ IntervalIntegrable g volume I.lo I.hi := by
  rw [law, integrable_smul_measure
    (ENNReal.inv_ne_zero.mpr ENNReal.ofReal_ne_top)
    (ENNReal.inv_ne_top.mpr (ENNReal.ofReal_ne_zero_iff.mpr I.length_pos)),
    intervalIntegrable_iff_integrableOn_Ioc_of_le I.lt.le]
  rfl

end Segment

structure Rectangle where
  x : Segment
  y : Segment

namespace Rectangle

def law (Q : Rectangle) : Measure (ℝ × ℝ) := Q.x.law.prod Q.y.law

def closed (Q : Rectangle) : Set (ℝ × ℝ) :=
  Icc Q.x.lo Q.x.hi ×ˢ Icc Q.y.lo Q.y.hi

def interior (Q : Rectangle) : Set (ℝ × ℝ) :=
  Ioo Q.x.lo Q.x.hi ×ˢ Ioo Q.y.lo Q.y.hi

instance (Q : Rectangle) : IsProbabilityMeasure Q.law := by
  unfold law
  infer_instance

theorem ae_mem (Q : Rectangle) : ∀ᵐ p ∂Q.law, p ∈ Q.interior := by
  exact ((Measure.quasiMeasurePreserving_fst.ae Q.x.ae_mem).and
    (Measure.quasiMeasurePreserving_snd.ae Q.y.ae_mem))

theorem ae_of_ae (Q : Rectangle) {P : ℝ × ℝ → Prop} (hP : ∀ᵐ p, P p) :
    ∀ᵐ p ∂Q.law, P p := by
  rw [Measure.volume_eq_prod] at hP
  have hx : Q.x.law ≪ volume := Measure.absolutelyContinuous_restrict.smul_left _
  have hy : Q.y.law ≪ volume := Measure.absolutelyContinuous_restrict.smul_left _
  exact (hx.prod hy).ae_le hP

theorem integral_eq {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (Q : Rectangle) (g : ℝ × ℝ → E) (hg : Integrable g Q.law) :
    (∫ p, g p ∂Q.law) = ∫ x, ∫ y, g (x, y) ∂Q.y.law ∂Q.x.law :=
  integral_prod g hg

theorem integral_eq_swap {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (Q : Rectangle) (g : ℝ × ℝ → E) (hg : Integrable g Q.law) :
    (∫ p, g p ∂Q.law) = ∫ y, ∫ x, g (x, y) ∂Q.x.law ∂Q.y.law :=
  (integral_prod g hg).trans (integral_integral_swap hg)

end Rectangle

section BoundedFields
variable {X E : Type*} [MeasurableSpace X] [NormedAddCommGroup E]

/-- Globally bounded strongly measurable fields; all derivative selections below have this property. -/
def IsBoundedField (g : X → E) : Prop :=
  StronglyMeasurable g ∧ ∃ M : ℝ, ∀ x, ‖g x‖ ≤ M

namespace IsBoundedField

theorem integrable {g : X → E} (hg : IsBoundedField g) (μ : Measure X)
    [IsFiniteMeasure μ] : Integrable g μ := by
  obtain ⟨M, hM⟩ := hg.2
  exact Integrable.of_bound hg.1.aestronglyMeasurable M (Eventually.of_forall hM)

theorem norm_sq {g : X → E} (hg : IsBoundedField g) :
    IsBoundedField (fun x => ‖g x‖ ^ 2) := by
  obtain ⟨M, hM⟩ := hg.2
  refine ⟨hg.1.norm.pow 2, M ^ 2, fun x => ?_⟩
  rw [Real.norm_eq_abs, abs_of_nonneg (sq_nonneg _)]
  exact pow_le_pow_left₀ (norm_nonneg _) (hM x) 2

theorem sub {f g : X → E} (hf : IsBoundedField f) (hg : IsBoundedField g) :
    IsBoundedField (fun x => f x - g x) := by
  obtain ⟨M, hM⟩ := hf.2
  obtain ⟨N, hN⟩ := hg.2
  exact ⟨hf.1.sub hg.1, M + N, fun x => (norm_sub_le _ _).trans (add_le_add (hM x) (hN x))⟩

theorem const (e : E) : IsBoundedField (fun _ : X => e) :=
  ⟨stronglyMeasurable_const, ‖e‖, fun _ => le_rfl⟩

end IsBoundedField
end BoundedFields

end DoublingHilbert

namespace DoublingHilbert
open MeasureTheory Set Filter
open scoped Topology

namespace Rectangle

theorem law_eq (Q : Rectangle) : Q.law =
    (ENNReal.ofReal (Q.x.length * Q.y.length))⁻¹ •
      volume.restrict (Ioc Q.x.lo Q.x.hi ×ˢ Ioc Q.y.lo Q.y.hi) := by
  simp only [law, Segment.law, Measure.prod_smul_left, Measure.prod_smul_right,
    smul_smul, Measure.prod_restrict, ← Measure.volume_eq_prod,
    ENNReal.ofReal_mul Q.x.length_pos.le]
  rw [ENNReal.mul_inv (Or.inr ENNReal.ofReal_ne_top) (Or.inl ENNReal.ofReal_ne_top), mul_comm]

end Rectangle

namespace IsBoundedField
variable {X Y I E : Type*} [MeasurableSpace X] [MeasurableSpace Y]
  [NormedAddCommGroup E]

theorem comp_measurable {g : X → E} (hg : IsBoundedField g) {f : Y → X}
    (hf : Measurable f) : IsBoundedField (g ∘ f) :=
  ⟨hg.1.comp_measurable hf, by obtain ⟨M, hM⟩ := hg.2; exact ⟨M, fun y => hM (f y)⟩⟩

theorem select [Fintype I] [MeasurableSpace I] [MeasurableSingletonClass I]
    {g : I → X → E} (hg : ∀ i, IsBoundedField (g i))
    {σ : X → I} (hσ : Measurable σ) : IsBoundedField (fun p => g (σ p) p) := by
  classical
  choose M hM using fun i => (hg i).2
  have heq : (fun p => g (σ p) p) =
      fun p => ∑ i : I, {p | σ p = i}.indicator (g i) p := by
    funext p
    simp [Set.indicator_apply, eq_comm]
  refine ⟨?_, ∑ i, |M i|, fun p => ?_⟩
  · rw [heq]
    convert (Finset.stronglyMeasurable_sum Finset.univ fun i _ =>
      (hg i).1.indicator (hσ (measurableSet_singleton i))) using 1
    funext p
    simp only [Finset.sum_apply]
    rfl
  · exact (hM (σ p) p).trans ((le_abs_self _).trans
      (Finset.single_le_sum (fun i _ => abs_nonneg (M i)) (Finset.mem_univ _)))

variable [NormedSpace ℝ E]

theorem integral_snd {g : X × Y → E} (hg : IsBoundedField g) (ν : Measure Y)
    [IsProbabilityMeasure ν] : IsBoundedField (fun x => ∫ y, g (x, y) ∂ν) := by
  obtain ⟨M, hM⟩ := hg.2
  refine ⟨hg.1.integral_prod_right', M, fun x => ?_⟩
  simpa only [probReal_univ, mul_one] using
    norm_integral_le_of_norm_le_const (μ := ν) (Eventually.of_forall fun y => hM (x, y))

theorem integral_fst {g : X × Y → E} (hg : IsBoundedField g) (μ : Measure X)
    [IsProbabilityMeasure μ] : IsBoundedField (fun y => ∫ x, g (x, y) ∂μ) := by
  obtain ⟨M, hM⟩ := hg.2
  refine ⟨hg.1.integral_prod_left', M, fun y => ?_⟩
  simpa only [probReal_univ, mul_one] using
    norm_integral_le_of_norm_le_const (μ := μ) (Eventually.of_forall fun x => hM (x, y))

end IsBoundedField
end DoublingHilbert

namespace DoublingHilbert
open MeasureTheory Set Filter
open scoped Topology
noncomputable section

section RectangleFTC
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [CompleteSpace E] [FiniteDimensional ℝ E]

omit [CompleteSpace E] in
theorem boundedField_column {f : Base → E} {C : NNReal} (hf : LipschitzWith C f)
    (v : Base) : IsBoundedField (column f v) :=
  ⟨stronglyMeasurable_column f v, C * ‖v‖, norm_column_le hf v⟩

omit [CompleteSpace E] [FiniteDimensional ℝ E] in
theorem norm_integral_rectangle_le_x (Q : Rectangle) {G : Base → E}
    (hG : IsBoundedField G) {R : ℝ}
    (hline : ∀ᵐ y ∂Q.y.law, ‖∫ x, G (x, y) ∂Q.x.law‖ ≤ R) :
    ‖∫ p, G p ∂Q.law‖ ≤ R := by
  rw [Q.integral_eq_swap G (hG.integrable Q.law)]
  simpa only [probReal_univ, mul_one] using norm_integral_le_of_norm_le_const hline

omit [CompleteSpace E] [FiniteDimensional ℝ E] in
theorem norm_integral_rectangle_le_y (Q : Rectangle) {G : Base → E}
    (hG : IsBoundedField G) {R : ℝ}
    (hline : ∀ᵐ x ∂Q.x.law, ‖∫ y, G (x, y) ∂Q.y.law‖ ≤ R) :
    ‖∫ p, G p ∂Q.law‖ ≤ R := by
  rw [Q.integral_eq G (hG.integrable Q.law)]
  simpa only [probReal_univ, mul_one] using norm_integral_le_of_norm_le_const hline

/-- Endpoint transport for a measurably selected horizontal sheet on each row. -/
theorem horizontal_mean_bound {ι : Type*} [Fintype ι] [MeasurableSpace ι]
    [MeasurableSingletonClass ι] (Q : Rectangle)
    {F : Base → E} {G : ι → Base → E} {C : NNReal} {C' : ι → NNReal}
    (hF : LipschitzWith C F) (hG : ∀ i, LipschitzWith (C' i) (G i))
    {σ : ℝ → ι} (hσ : Measurable σ) {R : ℝ}
    (hleft : ∀ᵐ y ∂Q.y.law, ‖G (σ y) (Q.x.lo, y) - F (Q.x.lo, y)‖ ≤ R)
    (hright : ∀ᵐ y ∂Q.y.law, ‖G (σ y) (Q.x.hi, y) - F (Q.x.hi, y)‖ ≤ R) :
    ‖(∫ p, column (G (σ p.2)) (1, 0) p ∂Q.law) -
      (∫ p, column F (1, 0) p ∂Q.law)‖ ≤ 2 * R / Q.x.length := by
  have hB : IsBoundedField (fun p => column (G (σ p.2)) (1, 0) p) :=
    IsBoundedField.select (fun i => boundedField_column (hG i) (1, 0))
    (hσ.comp measurable_snd)
  have hBF := boundedField_column hF (1, 0)
  rw [← integral_sub (hB.integrable Q.law) (hBF.integrable Q.law)]
  apply norm_integral_rectangle_le_x Q (hB.sub hBF)
  have hlines : ∀ᵐ y, ∀ i, ∀ a b : ℝ,
      (∫ x in a..b, column (G i) (1, 0) (x, y)) = G i (b, y) - G i (a, y) :=
    ae_all_iff.mpr fun i => ae_integral_column_x (hG i)
  filter_upwards [Q.y.ae_of_ae hlines, Q.y.ae_of_ae (ae_integral_column_x hF), hleft, hright]
    with y hy hFy hly hry
  rw [Q.x.integral_eq, intervalIntegral.integral_sub
    (intervalIntegrable_column_x (hG (σ y)) (1, 0) y _ _)
    (intervalIntegrable_column_x hF (1, 0) y _ _), hy, hFy]
  have heq : G (σ y) (Q.x.hi, y) - G (σ y) (Q.x.lo, y) -
      (F (Q.x.hi, y) - F (Q.x.lo, y)) =
      (G (σ y) (Q.x.hi, y) - F (Q.x.hi, y)) -
      (G (σ y) (Q.x.lo, y) - F (Q.x.lo, y)) := by abel
  rw [heq, norm_smul, Real.norm_eq_abs, abs_inv, abs_of_pos Q.x.length_pos]
  have hh := (norm_sub_le (G (σ y) (Q.x.hi, y) - F (Q.x.hi, y))
    (G (σ y) (Q.x.lo, y) - F (Q.x.lo, y))).trans
      (add_le_add hry hly)
  calc
    _ ≤ Q.x.length⁻¹ * (R + R) := mul_le_mul_of_nonneg_left hh (inv_nonneg.mpr Q.x.length_pos.le)
    _ = _ := by ring

/-- Endpoint transport for a selected vertical sheet on each column. -/
theorem vertical_mean_bound {ι : Type*} [Fintype ι] [MeasurableSpace ι]
    [MeasurableSingletonClass ι] (Q : Rectangle)
    {F : Base → E} {G : ι → Base → E} {C : NNReal} {C' : ι → NNReal}
    (hF : LipschitzWith C F) (hG : ∀ i, LipschitzWith (C' i) (G i))
    {σ : ℝ → ι} (hσ : Measurable σ) {R : ℝ}
    (hbottom : ∀ᵐ x ∂Q.x.law, ‖G (σ x) (x, Q.y.lo) - F (x, Q.y.lo)‖ ≤ R)
    (htop : ∀ᵐ x ∂Q.x.law, ‖G (σ x) (x, Q.y.hi) - F (x, Q.y.hi)‖ ≤ R) :
    ‖(∫ p, column (G (σ p.1)) (0, 1) p ∂Q.law) -
      (∫ p, column F (0, 1) p ∂Q.law)‖ ≤ 2 * R / Q.y.length := by
  have hB : IsBoundedField (fun p => column (G (σ p.1)) (0, 1) p) :=
    IsBoundedField.select (fun i => boundedField_column (hG i) (0, 1))
    (hσ.comp measurable_fst)
  have hBF := boundedField_column hF (0, 1)
  rw [← integral_sub (hB.integrable Q.law) (hBF.integrable Q.law)]
  apply norm_integral_rectangle_le_y Q (hB.sub hBF)
  have hlines : ∀ᵐ x, ∀ i, ∀ a b : ℝ,
      (∫ y in a..b, column (G i) (0, 1) (x, y)) = G i (x, b) - G i (x, a) :=
    ae_all_iff.mpr fun i => ae_integral_column_y (hG i)
  filter_upwards [Q.x.ae_of_ae hlines, Q.x.ae_of_ae (ae_integral_column_y hF), hbottom, htop]
    with x hx hFx hbx htx
  rw [Q.y.integral_eq, intervalIntegral.integral_sub
    (intervalIntegrable_column_y (hG (σ x)) (0, 1) x _ _)
    (intervalIntegrable_column_y hF (0, 1) x _ _), hx, hFx]
  have heq : G (σ x) (x, Q.y.hi) - G (σ x) (x, Q.y.lo) -
      (F (x, Q.y.hi) - F (x, Q.y.lo)) =
      (G (σ x) (x, Q.y.hi) - F (x, Q.y.hi)) -
      (G (σ x) (x, Q.y.lo) - F (x, Q.y.lo)) := by abel
  rw [heq, norm_smul, Real.norm_eq_abs, abs_inv, abs_of_pos Q.y.length_pos]
  have hh := (norm_sub_le (G (σ x) (x, Q.y.hi) - F (x, Q.y.hi))
    (G (σ x) (x, Q.y.lo) - F (x, Q.y.lo))).trans
      (add_le_add htx hbx)
  calc
    _ ≤ Q.y.length⁻¹ * (R + R) := mul_le_mul_of_nonneg_left hh (inv_nonneg.mpr Q.y.length_pos.le)
    _ = _ := by ring

end RectangleFTC
end
end DoublingHilbert

namespace DoublingHilbert
open MeasureTheory Set Filter
open scoped Topology
noncomputable section
namespace Rectangle

def area (Q : Rectangle) : ℝ := Q.x.length * Q.y.length

theorem area_pos (Q : Rectangle) : 0 < Q.area := mul_pos Q.x.length_pos Q.y.length_pos

theorem law_eq_closed (Q : Rectangle) : Q.law =
    (ENNReal.ofReal Q.area)⁻¹ • volume.restrict Q.closed := by
  simp only [law, Segment.law, restrict_Ioc_eq_restrict_Icc,
    Measure.prod_smul_left, Measure.prod_smul_right, smul_smul, Measure.prod_restrict,
    ← Measure.volume_eq_prod, area, closed, ENNReal.ofReal_mul Q.x.length_pos.le]
  rw [ENNReal.mul_inv (Or.inr ENNReal.ofReal_ne_top) (Or.inl ENNReal.ofReal_ne_top), mul_comm]

theorem volume_closed (Q : Rectangle) : volume Q.closed = ENNReal.ofReal Q.area := by
  rw [closed, Measure.volume_eq_prod, Measure.prod_prod, Real.volume_Icc, Real.volume_Icc]
  exact (ENNReal.ofReal_mul Q.x.length_pos.le).symm

theorem integral_eq_average_closed {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (Q : Rectangle) (g : Base → E) :
    (∫ p, g p ∂Q.law) = ⨍ p in Q.closed, g p := by
  rw [setAverage_eq', law_eq_closed, volume_closed]

theorem integral_eq_closed {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (Q : Rectangle) (g : Base → E) :
    (∫ p, g p ∂Q.law) = Q.area⁻¹ • ∫ p in Q.closed, g p := by
  rw [law_eq_closed, integral_smul_measure, ENNReal.toReal_inv,
    ENNReal.toReal_ofReal Q.area_pos.le]

theorem area_mul_integral (Q : Rectangle) (g : Base → ℝ) :
    Q.area * (∫ p, g p ∂Q.law) = ∫ p in Q.closed, g p := by
  rw [Q.integral_eq_closed, smul_eq_mul, ← mul_assoc, mul_inv_cancel₀ Q.area_pos.ne', one_mul]

/-- Trimming at most half of each side increases a nonnegative mean by at most four. -/
theorem integral_le_four_of_subset (P Q : Rectangle) {g : Base → ℝ}
    (hg : IsBoundedField g) (hpos : ∀ p, 0 ≤ g p)
    (hsub : Q.closed ⊆ P.closed)
    (hx : P.x.length / 2 ≤ Q.x.length) (hy : P.y.length / 2 ≤ Q.y.length) :
    (∫ p, g p ∂Q.law) ≤ 4 * (∫ p, g p ∂P.law) := by
  have : IsFiniteMeasure (volume.restrict P.closed) :=
    isFiniteMeasure_restrict.mpr (by rw [P.volume_closed]; exact ENNReal.ofReal_ne_top)
  have hi := setIntegral_mono_set (s := Q.closed) (t := P.closed) (hg.integrable (volume.restrict P.closed))
    (Eventually.of_forall hpos) (Eventually.of_forall hsub)
  rw [← Q.area_mul_integral g, ← P.area_mul_integral g] at hi
  have ha : P.area ≤ 4 * Q.area := by
    have := mul_le_mul hx hy (div_nonneg P.y.length_pos.le (by norm_num)) Q.x.length_pos.le
    dsimp [area]
    nlinarith
  have hpmean : 0 ≤ (∫ p, g p ∂P.law) := integral_nonneg hpos
  have hmul := mul_le_mul_of_nonneg_right ha hpmean
  nlinarith [Q.area_pos]

def square (p : Base) (r : ℝ) (hr : 0 < r) : Rectangle :=
  ⟨⟨p.1 - r, p.1 + r, by linarith⟩, ⟨p.2 - r, p.2 + r, by linarith⟩⟩

theorem square_closed (p : Base) (r : ℝ) (hr : 0 < r) :
    (square p r hr).closed = Metric.closedBall p r := by
  rw [← Prod.eta p, ← closedBall_prod_same, Real.closedBall_eq_Icc, Real.closedBall_eq_Icc]
  rfl

end Rectangle

section LocalSquare
variable {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
  [CompleteSpace E] [FiniteDimensional ℝ E]

omit [CompleteSpace E] in
/-- Actual Lebesgue-good derivative points supply arbitrarily accurate base squares. -/
theorem goodSheetPoint_exists_rectangle {f : constructedSet → E} {D : NNReal}
    (hf : LipschitzWith D f) {w : Tuple} {p : Base} (hp : goodSheetPoint f w p)
    {ε : ℝ} (hε : 0 < ε) :
    ∃ Q : Rectangle, Q.closed ⊆ sheetDomain w ∧
      (∫ q, ‖column (globalSheet hf w) (1, 0) q -
        sheetColumn (embeddingSheet f w) (sheetDomain w) (1, 0) p‖ ^ 2 ∂Q.law) < ε ∧
      (∫ q, ‖column (globalSheet hf w) (0, 1) q -
        sheetColumn (embeddingSheet f w) (sheetDomain w) (0, 1) p‖ ^ 2 ∂Q.law) < ε := by
  have he : ∀ᶠ r : ℝ in 𝓝[>] 0, Metric.closedBall p r ⊆ sheetDomain w :=
    (eventually_closedBall_subset ((isOpen_sheetDomain w).mem_nhds hp.1)).filter_mono
      nhdsWithin_le_nhds
  have hx := hp.2.2.1.eventually (gt_mem_nhds hε)
  have hy := hp.2.2.2.eventually (gt_mem_nhds hε)
  have hpos : ∀ᶠ r : ℝ in 𝓝[>] 0, 0 < r := self_mem_nhdsWithin
  obtain ⟨r, hr, hsub, hrx, hry⟩ := (hpos.and (he.and (hx.and hy))).exists
  refine ⟨Rectangle.square p r hr, ?_, ?_, ?_⟩
  · rwa [Rectangle.square_closed]
  · rw [Rectangle.integral_eq_average_closed, Rectangle.square_closed]
    refine lt_of_eq_of_lt ?_ hrx
    apply setAverage_congr_fun measurableSet_closedBall
    exact Eventually.of_forall fun q hq => by rw [column_globalSheet hf w (hsub hq)]
  · rw [Rectangle.integral_eq_average_closed, Rectangle.square_closed]
    refine lt_of_eq_of_lt ?_ hry
    apply setAverage_congr_fun measurableSet_closedBall
    exact Eventually.of_forall fun q hq => by rw [column_globalSheet hf w (hsub hq)]

end LocalSquare
end
end DoublingHilbert

namespace DoublingHilbert
open MeasureTheory Set Filter
open scoped Topology
noncomputable section

namespace Segment

def grid (a h : ℝ) (n : ℕ) (hh : 0 < h) (hn : 0 < n) : Segment :=
  ⟨a, a + n * h, by
    have hn' : (0 : ℝ) < n := by exact_mod_cast hn
    exact lt_add_of_pos_right a (mul_pos hn' hh)⟩

def cell (a h : ℝ) (hh : 0 < h) (i : ℕ) : Segment :=
  ⟨a + i * h, a + (↑(i + 1) : ℝ) * h, by push_cast; nlinarith⟩

@[simp] theorem grid_length (a h : ℝ) (n : ℕ) (hh : 0 < h) (hn : 0 < n) :
    (grid a h n hh hn).length = n * h := by simp [grid, length]

@[simp] theorem cell_length (a h : ℝ) (hh : 0 < h) (i : ℕ) :
    (cell a h hh i).length = h := by simp [cell, length]; ring

/-- Exact finite averaging over adjacent equal cells. -/
theorem integral_grid {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a h : ℝ) {n : ℕ} (hh : 0 < h) (hn : 0 < n) {g : ℝ → E}
    (hg : IsBoundedField g) :
    (∫ x, g x ∂(grid a h n hh hn).law) =
      (n : ℝ)⁻¹ • ∑ i : Fin n, ∫ x, g x ∂(cell a h hh i).law := by
  have hsum := intervalIntegral.sum_integral_adjacent_intervals
    (a := fun i : ℕ => a + i * h) (n := n) (f := g) (μ := volume)
    (fun i _ => (cell a h hh i).integrable_iff.mp (hg.integrable _))
  simp only [Nat.cast_zero, zero_mul, add_zero] at hsum
  rw [← Fin.sum_univ_eq_sum_range] at hsum
  simp_rw [integral_eq, grid_length, cell_length]
  rw [← Finset.smul_sum, smul_smul]
  have hs : (n : ℝ)⁻¹ * h⁻¹ = ((n : ℝ) * h)⁻¹ := by ring
  rw [hs]
  congr 1
  exact hsum.symm

end Segment

namespace Rectangle

/-- Exact integration by columns. -/
theorem integral_grid_x {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a h : ℝ) {n : ℕ} (hh : 0 < h) (hn : 0 < n) (J : Segment) {g : ℝ × ℝ → E}
    (hg : IsBoundedField g) :
    (∫ p, g p ∂(Rectangle.mk (Segment.grid a h n hh hn) J).law) =
      (n : ℝ)⁻¹ • ∑ i : Fin n, ∫ p, g p ∂(Rectangle.mk (Segment.cell a h hh i) J).law := by
  rw [(Rectangle.mk (Segment.grid a h n hh hn) J).integral_eq g
    (hg.integrable _), Segment.integral_grid a h hh hn (hg.integral_snd J.law)]
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  exact ((Rectangle.mk (Segment.cell a h hh i) J).integral_eq g
    (hg.integrable _)).symm

/-- Exact integration by rows. -/
theorem integral_grid_y {E : Type*} [NormedAddCommGroup E] [NormedSpace ℝ E]
    (a h : ℝ) {n : ℕ} (hh : 0 < h) (hn : 0 < n) (I : Segment) {g : ℝ × ℝ → E}
    (hg : IsBoundedField g) :
    (∫ p, g p ∂(Rectangle.mk I (Segment.grid a h n hh hn)).law) =
      (n : ℝ)⁻¹ • ∑ i : Fin n, ∫ p, g p ∂(Rectangle.mk I (Segment.cell a h hh i)).law := by
  rw [(Rectangle.mk I (Segment.grid a h n hh hn)).integral_eq_swap g
    (hg.integrable _), Segment.integral_grid a h hh hn (hg.integral_fst I.law)]
  congr 1
  apply Finset.sum_congr rfl
  intro i _
  exact ((Rectangle.mk I (Segment.cell a h hh i)).integral_eq_swap g
    (hg.integrable _)).symm

end Rectangle
end
end DoublingHilbert

end

end OAI