import Mathlib
import OAI.Probability.BinarySweep.Trajectories.EndpointEntryBound
import OAI.Probability.BinarySweep.Trajectories.SparseOccupancy

namespace OAI

noncomputable section
open scoped BigOperators Classical

namespace BinaryCoordinateSweeps
open Sparse

attribute [local instance] Classical.propDecidable
variable {b h k : ℕ} {bits : Fin b → ℕ} (H : PathFamily bits h)

lemma card_gridOutside_mul (j : Fin b) :
    Fintype.card (GridOutside bits j)*2^bits j=gridSize bits := by
  have he := Fintype.card_congr (Equiv.piSplitAt j (fun i : Fin b => Slot (bits i)))
  simpa only [Fintype.card_prod,card_gridSlot,Slot,Fintype.card_fun,Fintype.card_bool,Fintype.card_fin,Nat.mul_comm] using he.symm

lemma sum_endpointLineCount (e : Fin k → GridSlot bits × GridSlot bits) (j : Fin b) :
    ∑y, endpointLineCount Finset.univ e j y=k := by
  have he := Fintype.card_congr (Equiv.sigmaFiberEquiv
    (fun i : ↥(Finset.univ : Finset (Fin k)) => endpointLine (e i) j))
  simpa only [Fintype.card_sigma,Fintype.card_coe,Finset.card_univ,Fintype.card_fin,
    endpointLineCount] using he

lemma heavy_count {L : Type*} [Fintype L] (f : L → ℕ) (τ : ℝ) :
    τ*(Finset.univ.filter (fun l => τ<(f l:ℝ))).card ≤ ∑l, (f l:ℝ) := by
  let S := Finset.univ.filter (fun l => τ<(f l:ℝ))
  calc
    _ = ∑l∈S, τ := by simp [S,mul_comm]
    _ ≤ ∑l∈S, (f l:ℝ) := Finset.sum_le_sum (fun l hl => (Finset.mem_filter.mp hl).2.le)
    _ ≤ ∑l, (f l:ℝ) := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _) (by intros; positivity)

def holeHeavyLines (j : Fin b) (η : ℝ) : Finset (GridOutside bits j) :=
  Finset.univ.filter (fun l => (2^bits j:ℕ)*η/2<(lineHoles H j l:ℝ))

def particleHeavyLines (e : Fin k → GridSlot bits × GridSlot bits) (j : Fin b) (η : ℝ) :
    Finset (GridOutside bits j) :=
  Finset.univ.filter (fun l => (2^bits j:ℕ)*η/2<(endpointLineCount Finset.univ e j l:ℝ))

lemma holeHeavy_card (j : Fin b) {η : ℝ} (hη : 0<η) :
    ((holeHeavyLines H j η).card:ℝ) ≤ 2*h/((2^bits j:ℕ)*η) := by
  have hh := heavy_count (lineHoles H j) ((2^bits j:ℕ)*η/2)
  rw [← Nat.cast_sum,sum_lineHoles] at hh
  apply (le_div_iff₀ (by positivity)).mpr
  change (2^bits j:ℕ)*η/2*(holeHeavyLines H j η).card≤(h:ℝ) at hh
  nlinarith

lemma particleHeavy_card (e : Fin k → GridSlot bits × GridSlot bits) (j : Fin b)
    {η : ℝ} (hη : 0<η) :
    (particleHeavyLines e j η).card ≤ ⌊2*(k:ℝ)/((2^bits j:ℕ)*η)⌋₊ := by
  apply Nat.le_floor
  have hh := heavy_count (endpointLineCount Finset.univ e j) ((2^bits j:ℕ)*η/2)
  rw [← Nat.cast_sum,sum_endpointLineCount] at hh
  apply (le_div_iff₀ (by positivity)).mpr
  change (2^bits j:ℕ)*η/2*(particleHeavyLines e j η).card≤(k:ℝ) at hh
  nlinarith

lemma endpoint_not_light (e : Fin k → GridSlot bits × GridSlot bits)
    (j : Fin b) (l : GridOutside bits j) (η : ℝ)
    (hn : ¬endpointLight H η e ⟨j,l⟩) :
    l∈holeHeavyLines H j η ∨ l∈particleHeavyLines e j η := by
  simp only [holeHeavyLines,particleHeavyLines,Finset.mem_filter,Finset.mem_univ,true_and]
  change ¬((lineHoles H j l:ℝ)+endpointLineCount Finset.univ e j l≤(2^bits j:ℕ)*η) at hn
  push Not at hn
  rcases lt_or_ge ((2^bits j:ℕ)*η/2) (lineHoles H j l:ℝ) with hh | hh
  · exact Or.inl hh
  · exact Or.inr (by linarith)

lemma endpoint_line_set_mass (j : Fin b) (S : Finset (GridOutside bits j)) :
    finiteProbability uniformWeight (fun z : GridSlot bits × GridSlot bits => endpointLine z j∈S)=
      (S.card:ℝ)*(2^bits j:ℕ)/gridSize bits := by
  change finiteProbability uniformWeight (fun z : GridSlot bits × GridSlot bits =>
    (fun i : {i : Fin b // i≠j} => independentPosition z j.castSucc i)∈S)=_
  rw [independent_line_set_uniform]
  have he : (Fintype.card (GridOutside bits j):ℝ)*(2^bits j:ℕ)=gridSize bits := by
    exact_mod_cast card_gridOutside_mul j
  have hs : (gridSize bits:ℝ)≠0 := by exact_mod_cast (gridSize_pos bits).ne'
  have hm : ((2^bits j:ℕ):ℝ)≠0 := by positivity
  rw [← he]
  field_simp

lemma holeHeavy_mass (j : Fin b) {η : ℝ} (hη : 0<η) :
    finiteProbability uniformWeight (fun z : GridSlot bits × GridSlot bits =>
      endpointLine z j∈holeHeavyLines H j η) ≤ 2*h/((gridSize bits:ℝ)*η) := by
  rw [endpoint_line_set_mass]
  have hh := holeHeavy_card H j hη
  have hs : (0:ℝ)<gridSize bits := by exact_mod_cast gridSize_pos bits
  have hm : (0:ℝ)<(2^bits j:ℕ) := by positivity
  calc
    _ ≤ (2*h/((2^bits j:ℕ)*η))*(2^bits j:ℕ)/gridSize bits := by gcongr
    _ = _ := by field_simp

lemma small_lines_mass (j : Fin b) {η : ℝ} (hη : 0<η)
    (S : Finset (GridOutside bits j)) (hS : S.card≤⌊2*(k:ℝ)/((2^bits j:ℕ)*η)⌋₊) :
    finiteProbability uniformWeight (fun z : GridSlot bits × GridSlot bits => endpointLine z j∈S) ≤
      2*k/((gridSize bits:ℝ)*η) := by
  rw [endpoint_line_set_mass]
  have hnon : 0≤2*(k:ℝ)/((2^bits j:ℕ)*η) := by positivity
  have hh : (S.card:ℝ)≤2*(k:ℝ)/((2^bits j:ℕ)*η) :=
    (Nat.cast_le.mpr hS).trans (Nat.floor_le hnon)
  have hs : (0:ℝ)<gridSize bits := by exact_mod_cast gridSize_pos bits
  have hm : (0:ℝ)<(2^bits j:ℕ) := by positivity
  calc
    _ ≤ (2*k/((2^bits j:ℕ)*η))*(2^bits j:ℕ)/gridSize bits := by gcongr
    _ = _ := by field_simp

lemma holeHeavy_occupancy_bound (j : Fin b) {η : ℝ} (hη : 0<η)
    (hsmall : 2*h/((gridSize bits:ℝ)*η)≤1) (w : ℕ) :
    productProbability uniformWeight (fun e : Fin k → GridSlot bits × GridSlot bits =>
      w ≤ (Finset.univ.filter (fun i => endpointLine (e i) j∈holeHeavyLines H j η)).card) ≤
      (2:ℝ)^k*(2*h/((gridSize bits:ℝ)*η))^w := by
  have he := occupancy_probability_le (I:=Fin k) uniformWeight uniformWeight_nonneg uniformWeight_sum
    (fun z : GridSlot bits × GridSlot bits => endpointLine z j∈holeHeavyLines H j η) _
    (by positivity) hsmall (holeHeavy_mass H j hη) w
  simp only [Fintype.card_fin] at he
  convert he using 1
  congr 1
  funext e
  congr 1
  congr 1
  ext i
  simp only [Finset.mem_filter,Finset.mem_univ,true_and]

lemma particleHeavy_occupancy_bound (j : Fin b) {η : ℝ} (hη : 0<η)
    (hsmall : 2*k/((gridSize bits:ℝ)*η)≤1) (w : ℕ) :
    productProbability uniformWeight (fun e : Fin k → GridSlot bits × GridSlot bits =>
      w ≤ (Finset.univ.filter (fun i => endpointLine (e i) j∈particleHeavyLines e j η)).card) ≤
      (Fintype.card (GridOutside bits j)+1:ℕ)^⌊2*(k:ℝ)/((2^bits j:ℕ)*η)⌋₊ *
        (2:ℝ)^k*(2*k/((gridSize bits:ℝ)*η))^w := by
  have hb := line_sets_occupancy_probability_le (I:=Fin k) uniformWeight uniformWeight_nonneg uniformWeight_sum
    (fun z : GridSlot bits × GridSlot bits => endpointLine z j) _ w _ (by positivity)
    hsmall (small_lines_mass j hη)
  apply le_trans (b:=productProbability uniformWeight (fun e : Fin k → GridSlot bits × GridSlot bits =>
    ∃S : Finset (GridOutside bits j), S.card≤⌊2*(k:ℝ)/((2^bits j:ℕ)*η)⌋₊ ∧
      w≤(Finset.univ.filter (fun i => endpointLine (e i) j∈S)).card))
  · exact productProbability_mono uniformWeight_nonneg (fun e he =>
      ⟨particleHeavyLines e j η,particleHeavy_card e j hη,he⟩)
  · simpa only [Fintype.card_fin] using hb

end BinaryCoordinateSweeps

end

end OAI