import OAI.Probability.RadialTransition.DeletedInteractions

namespace OAI

noncomputable section


open MeasureTheory Set Filter Function

open scoped ContDiff NNReal BigOperators ENNReal

namespace RadialTransition

def halfCube (L : ℝ) : Set Position := {x | ∀ k, 0 ≤ x k ∧ x k < L}

lemma measurableSet_halfCube (L : ℝ) : MeasurableSet (halfCube L) := by
  have he : halfCube L = ⋂ k : Fin 3, {x : Position | 0 ≤ x k ∧ x k < L} := by
    ext x; simp only [halfCube, mem_ofPred_eq, mem_iInter]
  rw [he]
  apply MeasurableSet.iInter
  intro k
  exact (isClosed_le continuous_const (PiLp.continuous_apply 2 (fun _ : Fin 3 => ℝ) k)).measurableSet.inter
    (isOpen_lt (PiLp.continuous_apply 2 (fun _ : Fin 3 => ℝ) k) continuous_const).measurableSet

lemma halfCube_ae_cube (L : ℝ) : halfCube L =ᵐ[volume] cube L := by
  have hh := Measure.univ_pi_Ico_ae_eq_Icc (μ := fun _ : Fin 3 => (volume : Measure ℝ))
    (f := fun _ => (0:ℝ)) (g := fun _ => L)
  have hp := (PiLp.volume_preserving_ofLp (Fin 3)).quasiMeasurePreserving.ae hh
  filter_upwards [hp] with x hx
  apply propext
  change (∀ k, 0 ≤ x k ∧ x k < L) ↔ (∀ k, 0 ≤ x k ∧ x k ≤ L)
  have hx' := eq_iff_iff.mp hx
  simpa only [Set.pi, Set.Ico, Set.Icc, Membership.mem, Set.Mem, Set.ofPred, Set.univ, Set.mem_univ, true_implies, forall_const, Pi.le_def, forall_and] using hx'

lemma restrict_halfCube (L : ℝ) : volume.restrict (halfCube L) = volume.restrict (cube L) :=
  Measure.restrict_congr_set (halfCube_ae_cube L)

abbrev GridIndex (q : ℕ) := Fin 3 → Fin q

def gridEmbed {q : ℕ} (i : GridIndex q) : Cell := fun k => (i k : ℤ)

lemma gridEmbed_injective (q : ℕ) : Function.Injective (@gridEmbed q) := by
  intro i j h
  funext k
  apply Fin.ext
  have hh : (i k : ℤ) = (j k : ℤ) := congrFun h k
  exact_mod_cast hh

lemma halfCube_grid_cover (q : ℕ) (x : Position) (hx : x ∈ halfCube ((q:ℝ)/4)) :
    ∃ i : GridIndex q, cellOf x = gridEmbed i := by
  have hh (k : Fin 3) : 0 ≤ cellOf x k ∧ cellOf x k < (q:ℤ) := by
    constructor
    · exact Int.floor_nonneg.mpr (by nlinarith [(hx k).1])
    · apply Int.floor_lt.mpr
      exact_mod_cast (show 4*x k < (q:ℝ) by linarith [(hx k).2])
  let i : GridIndex q := fun k => ⟨(cellOf x k).toNat, by have := hh k; omega⟩
  refine ⟨i, ?_⟩
  funext k
  simp only [gridEmbed, i]
  exact (Int.toNat_of_nonneg (hh k).1).symm

lemma gridEmbed_mem_halfCube_iff {q : ℕ} (i : GridIndex q) (x : Position)
    (hx : cellOf x = gridEmbed i) : x ∈ halfCube ((q:ℝ)/4) := by
  intro k
  have hl := Int.floor_le (4*x k)
  have hu := Int.lt_floor_add_one (4*x k)
  have he : ⌊4*x k⌋ = (i k : ℤ) := congrFun hx k
  rw [he] at hl hu
  have hi : (i k : ℝ) + 1 ≤ (q:ℝ) := by exact_mod_cast (i k).isLt
  have hin : 0 ≤ (i k : ℝ) := by positivity
  constructor <;> push_cast at * <;> linarith

lemma halfCube_eq_gridUnion (q : ℕ) :
    halfCube ((q:ℝ)/4) = ⋃ i : GridIndex q, gridRegion (gridEmbed i) := by
  ext x
  simp only [mem_iUnion, gridRegion, mem_ofPred_eq]
  exact ⟨halfCube_grid_cover q x, fun ⟨i,hi⟩ => gridEmbed_mem_halfCube_iff i x hi⟩

lemma volume_halfCube (L : ℝ) : volume (halfCube L) = ENNReal.ofReal L ^ 3 := by
  rw [measure_congr (halfCube_ae_cube L), volume_cube]

def macroOf (q : ℕ) (k : Cell) : Cell := fun d => k d / (q:ℤ)

def blockEmbed {m q : ℕ} (i : GridIndex m) (j : GridIndex q) : GridIndex (m*q) :=
  fun d => ⟨(i d : ℕ)*q+(j d : ℕ), by
    calc
      _ < (i d : ℕ)*q+q := Nat.add_lt_add_left (j d).isLt _
      _ = ((i d : ℕ)+1)*q := by ring
      _ ≤ m*q := Nat.mul_le_mul_right q (Nat.succ_le_of_lt (i d).isLt)⟩

lemma blockEmbed_macro {m q : ℕ} (hq : 0 < q) (i : GridIndex m) (j : GridIndex q) :
    macroOf q (gridEmbed (blockEmbed i j)) = gridEmbed i := by
  funext d
  simp only [macroOf, gridEmbed, blockEmbed]
  have hj := (j d).isLt
  have hq' : (0:ℤ) < q := by exact_mod_cast hq
  have hj' : (0:ℤ) ≤ (j d : ℕ) ∧ (j d : ℤ) < q := by exact_mod_cast (show 0 ≤ (j d:ℕ) ∧ (j d:ℕ) < q from ⟨Nat.zero_le _, hj⟩)
  push_cast
  rw [Int.add_ediv_of_dvd_left (dvd_mul_left _ _),
    Int.mul_ediv_cancel _ (ne_of_gt hq'), Int.ediv_eq_zero_of_lt hj'.1 hj'.2, add_zero]

lemma blockEmbed_injective {m q : ℕ} (hq : 0 < q) :
    Function.Injective (fun p : GridIndex m × GridIndex q => blockEmbed p.1 p.2) := by
  intro p r h
  have hi : p.1 = r.1 := gridEmbed_injective m (by
    have := congrArg (fun k => macroOf q (gridEmbed k)) h
    simpa only [blockEmbed_macro hq] using this)
  apply Prod.ext hi
  funext d
  apply Fin.ext
  have hh := congrArg (fun k : GridIndex (m*q) => (k d : ℕ)) h
  simp only [blockEmbed, hi] at hh
  omega

lemma blockEmbed_surjective {m q : ℕ} (hq : 0 < q) :
    Function.Surjective (fun p : GridIndex m × GridIndex q => blockEmbed p.1 p.2) := by
  intro k
  let i : GridIndex m := fun d => ⟨(k d : ℕ)/q, Nat.div_lt_of_lt_mul (by simpa only [Nat.mul_comm m q] using (k d).isLt)⟩
  let j : GridIndex q := fun d => ⟨(k d : ℕ)%q, Nat.mod_lt _ hq⟩
  refine ⟨(i,j), ?_⟩
  funext d
  apply Fin.ext
  simpa only [blockEmbed, i, j, Nat.mul_comm] using Nat.div_add_mod (k d : ℕ) q

def boundaryCoord (q D : ℕ) : Finset (Fin q) :=
  Finset.univ.filter (fun a => (a:ℕ) < D ∨ q-D ≤ (a:ℕ))

lemma card_boundaryCoord (q D : ℕ) : (boundaryCoord q D).card ≤ 2*D := by
  let lo := Finset.univ.filter (fun a : Fin q => (a:ℕ) < D)
  let hi := Finset.univ.filter (fun a : Fin q => q-D ≤ (a:ℕ))
  have hlo : lo.card ≤ D := by
    calc
      _ ≤ (Finset.range D).card := Finset.card_le_card_of_injOn Fin.val
        (by intro a ha; exact Finset.mem_range.mpr (Finset.mem_filter.mp ha).2)
        (fun a _ b _ h => Fin.ext h)
      _ = D := Finset.card_range D
  have hhi : hi.card ≤ D := by
    calc
      _ ≤ (Finset.range D).card := Finset.card_le_card_of_injOn (fun a : Fin q => q-1-(a:ℕ))
        (by intro a ha; have hh := (Finset.mem_filter.mp ha).2; have := a.isLt; apply Finset.mem_range.mpr; change q-1-(a:ℕ) < D; omega)
        (by intro a ha b hb h; apply Fin.ext; have := a.isLt; have := b.isLt; change q-1-(a:ℕ) = q-1-(b:ℕ) at h; omega)
      _ = D := Finset.card_range D
  have he : boundaryCoord q D = lo ∪ hi := by
    ext a; simp only [boundaryCoord, lo, hi, Finset.mem_filter, Finset.mem_univ, true_and, Finset.mem_union]
  rw [he]
  exact le_trans (Finset.card_union_le lo hi) (by omega)

def boundarySlice (q D : ℕ) (d : Fin 3) : Finset (GridIndex q) :=
  Fintype.piFinset (fun k => if k = d then boundaryCoord q D else Finset.univ)

def boundaryGrid (q D : ℕ) : Finset (GridIndex q) :=
  Finset.univ.biUnion (boundarySlice q D)

lemma mem_boundaryGrid {q D : ℕ} {j : GridIndex q} :
    j ∈ boundaryGrid q D ↔ ∃ d, (j d:ℕ) < D ∨ q-D ≤ (j d:ℕ) := by
  simp only [boundaryGrid, Finset.mem_biUnion, Finset.mem_univ, true_and,
    boundarySlice, Fintype.mem_piFinset]
  constructor
  · rintro ⟨d,hd⟩
    refine ⟨d, ?_⟩
    have h := hd d
    simpa only [ite_true, boundaryCoord, Finset.mem_filter, Finset.mem_univ, true_and] using h
  · rintro ⟨d,hd⟩
    refine ⟨d, ?_⟩
    intro k
    split_ifs with h
    · subst k
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _, hd⟩
    · exact Finset.mem_univ _

lemma card_boundaryGrid (q D : ℕ) : (boundaryGrid q D).card ≤ 6*D*q^2 := by
  have hs (d : Fin 3) : (boundarySlice q D d).card = (boundaryCoord q D).card*q^2 := by
    rw [boundarySlice, Fintype.card_piFinset]
    fin_cases d <;> simp [Fin.prod_univ_three] <;> ring
  calc
    _ ≤ ∑ d : Fin 3, (boundarySlice q D d).card := Finset.card_biUnion_le
    _ = 3*((boundaryCoord q D).card*q^2) := by simp only [hs, Finset.sum_const, Finset.card_univ, Fintype.card_fin, smul_eq_mul]
    _ ≤ 3*(2*D*q^2) := Nat.mul_le_mul_left _ (Nat.mul_le_mul_right _ (card_boundaryCoord q D))
    _ = _ := by ring

lemma inner_block_macro {m q D : ℕ} (hq : 0 < q) (i : GridIndex m) (j : GridIndex q)
    (hj : j ∉ boundaryGrid q D) {k : Cell}
    (hk : ∀ d, |k d-gridEmbed (blockEmbed i j) d| ≤ (D:ℤ)) :
    macroOf q k = gridEmbed i := by
  have hj' : ∀ d, D ≤ (j d:ℕ) ∧ (j d:ℕ)+D < q := by
    have hh := mt mem_boundaryGrid.mpr hj
    intro d
    have hn : ¬ ((j d:ℕ) < D ∨ q-D ≤ (j d:ℕ)) := fun h => hh ⟨d,h⟩
    omega
  funext d
  apply (Int.ediv_eq_iff_of_pos (by exact_mod_cast hq)).mpr
  have hkd := abs_le.mp (hk d)
  have hlow : (D:ℤ) ≤ (j d:ℤ) := by exact_mod_cast (hj' d).1
  have hupp : (j d:ℤ)+(D:ℤ) < (q:ℤ) := by exact_mod_cast (hj' d).2
  change -(D:ℤ) ≤ k d-((i d:ℕ)*q+(j d:ℕ):ℕ) ∧ k d-((i d:ℕ)*q+(j d:ℕ):ℕ) ≤ (D:ℤ) at hkd
  push_cast at hkd
  change (i d:ℤ)*(q:ℤ) ≤ k d ∧ k d < (i d:ℤ)*(q:ℤ)+(q:ℤ)
  constructor <;> omega

lemma sum_blockGrid {m q : ℕ} (hq : 0 < q) (F : GridIndex (m*q) → ℝ) :
    ∑ k, F k = ∑ i : GridIndex m, ∑ j : GridIndex q, F (blockEmbed i j) := by
  have hh := Fintype.sum_equiv (Equiv.ofBijective _ ⟨blockEmbed_injective (m := m) hq, blockEmbed_surjective hq⟩)
    (fun p => F (blockEmbed p.1 p.2)) F (fun _ => rfl)
  rw [Fintype.sum_prod_type] at hh
  exact hh.symm

lemma grid_sum_boundary_bound {m q D : ℕ} (hq : 0 < q) {C : ℝ} (hC : 0 ≤ C)
    (F : GridIndex (m*q) → ℝ)
    (hF : ∀ k, F k ≤ C)
    (hzero : ∀ i j, j ∉ boundaryGrid q D → F (blockEmbed i j) = 0) :
    ∑ k, F k ≤ (m:ℝ)^3*(6*D*q^2)*C := by
  rw [sum_blockGrid hq]
  have hsum (i : GridIndex m) : ∑ j : GridIndex q, F (blockEmbed i j) ≤ (6*D*q^2:ℕ)*C := by
    calc
      _ = ∑ j ∈ boundaryGrid q D, F (blockEmbed i j) :=
        (Finset.sum_subset (Finset.subset_univ _) (fun j _ hj => hzero i j hj)).symm
      _ ≤ ∑ _j ∈ boundaryGrid q D, C := Finset.sum_le_sum (fun j _ => hF _)
      _ = ((boundaryGrid q D).card:ℝ)*C := by simp
      _ ≤ (6*D*q^2:ℕ)*C := mul_le_mul_of_nonneg_right (by exact_mod_cast card_boundaryGrid q D) hC
  calc
    _ ≤ ∑ _i : GridIndex m, (6*D*q^2:ℕ)*C := Finset.sum_le_sum (fun i _ => hsum i)
    _ = _ := by simp only [Finset.sum_const, Finset.card_univ, Fintype.card_fun, Fintype.card_fin]; push_cast; ring

end RadialTransition

end

end OAI