import OAI.Combinatorics.ListHadwiger.StagePacking

namespace OAI

namespace LinearListHadwiger.Sampling
open Finset ConnectivityTests
variable {V Ω : Type} [Fintype V] [DecidableEq V] [Fintype Ω]

theorem complement_failure_thousand (G : SimpleGraph V) [DecidableRel G.Adj]
    {n r ε : ℝ} {k : ℕ} (hk : 64 ≤ k) (hr : 0 < r) (hrk : r ≤ k)
    (hord : (Fintype.card V : ℝ) ≤ n) (hconn : KConnectedOn G univ k)
    {μ : Ω → ℝ} (hμ : ∀ ω, 0 ≤ μ ω) (U : Ω → Finset V)
    (hsurv : ∀ v, probability μ (fun ω => v ∈ U ω) ≤ 1/1000)
    (hε : 0 ≤ ε)
    (htail : ∀ A : Finset V, probability μ (fun ω => r/100 ≤
      |((U ω ∩ A).card : ℝ)-expectation μ (fun z => ((U z ∩ A).card : ℝ))|) ≤ ε) :
    probability μ (fun ω => ¬((∀ v, k ≤ 2*((univ \ U ω).filter (G.Adj v)).card) ∧
      KConnectedOn G (univ \ U ω) (k/32))) ≤
      (n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1))*ε := by
  classical
  obtain ⟨F,hFcard,hF,hFtest⟩ := cut_test G hk hord hconn
  have hD (v : V) : ∃ D ⊆ Density.neighbors G univ v, D.card=k :=
    exists_subset_card_eq (Knitting.min_degree G hconn (mem_univ v))
  choose D hD hDc using hD
  let Idx := V ⊕ ↥F
  let A : Idx → Finset V := fun i => match i with
    | .inl v => D v
    | .inr E => endpoints E.val
  let bad : Idx → Ω → Prop := fun i ω => r/100 ≤
    |((U ω ∩ A i).card : ℝ)-expectation μ (fun z => ((U z ∩ A i).card : ℝ))|
  have hbad (i : Idx) : probability μ (bad i) ≤ ε := htail (A i)
  have hgood (ω : Ω) (havoid : ∀ i, ¬bad i ω) :
      (∀ v, k ≤ 2*((univ \ U ω).filter (G.Adj v)).card) ∧
      KConnectedOn G (univ \ U ω) (k/32) := by
    have hsmall (i : Idx) (hAk : (A i).card ≤ k) : 32*(U ω ∩ A i).card < k := by
      have he := expectation_inter_card_le U hsurv (A i)
      have hAc : ((A i).card : ℝ) ≤ k := by exact_mod_cast hAk
      have hm : expectation μ (fun z => ((U z ∩ A i).card : ℝ)) ≤ (k:ℝ)/1000 := by
        nlinarith
      have hdev := (abs_lt.mp (lt_of_not_ge (havoid i))).2
      have hkpos : (0:ℝ) < k := by exact_mod_cast (by omega : 0 < k)
      have hh : (32:ℝ)*((U ω ∩ A i).card : ℝ) < k := by
        nlinarith
      exact_mod_cast hh
    have hneigh (v : V) : k ≤ 2*((univ \ U ω).filter (G.Adj v)).card := by
      have hc := hsmall (.inl v) (by dsimp [A]; exact (hDc v).le)
      have hd : (D v \ U ω).card+(D v ∩ U ω).card=k := by
        rw [card_sdiff_add_card_inter,hDc]
      have hsub : D v \ U ω ⊆ (univ \ U ω).filter (G.Adj v) := by
        intro w hw
        obtain ⟨hwD,hwU⟩ := mem_sdiff.mp hw
        have hadj := hD v hwD
        simp only [Density.neighbors,mem_filter,mem_univ,true_and] at hadj
        exact mem_filter.mpr ⟨mem_sdiff.mpr ⟨mem_univ _,hwU⟩,hadj⟩
      have hcard := card_le_card hsub
      dsimp [A] at hc
      rw [inter_comm] at hc
      omega
    refine ⟨hneigh,hFtest (U ω) hneigh ?_⟩
    intro E hE
    have he := (hF E hE).1
    have hcard : (endpoints E).card ≤ k := by
      have hb := endpoints_card_le E
      have hd := Nat.div_mul_le_self k 8
      omega
    have hc := hsmall (.inr ⟨E,hE⟩) hcard
    simpa [A,inter_comm] using hc
  have hprob : probability μ (fun ω => ¬((∀ v, k ≤ 2*((univ \ U ω).filter (G.Adj v)).card) ∧
      KConnectedOn G (univ \ U ω) (k/32))) ≤ probability μ (fun ω => ∃ i, bad i ω) := by
    apply probability_mono hμ
    intro ω h
    by_contra hn
    push Not at hn
    exact h (hgood ω hn)
  calc
    _ ≤ probability μ (fun ω => ∃ i, bad i ω) := hprob
    _ ≤ ∑ i, probability μ (bad i) := probability_union_le hμ bad
    _ ≤ ∑ _ : Idx, ε := sum_le_sum (fun i _ => hbad i)
    _ = ((Fintype.card V : ℝ)+F.card)*ε := by simp [Idx]
    _ ≤ _ := by gcongr

noncomputable def coin (p : ℝ) (b : Bool) : ℝ := if b then p else 1-p

lemma coin_nonneg {p : ℝ} (hp : 0 ≤ p) (hp1 : p ≤ 1) (b : Bool) :
    0 ≤ coin p b := by cases b <;> simp [coin] <;> linarith

lemma coin_sum (p : ℝ) : ∑ b : Bool, coin p b = 1 := by
  simp [coin]

noncomputable def chosen (x : V → Bool) : Finset V := univ.filter (fun v => x v = true)

lemma chosen_marginal (p : ℝ) (v : V) :
    probability (productMass (fun _ : V => coin p)) (fun x => v ∈ chosen x) = p := by
  classical
  have he : (fun x : V → Bool => v ∈ chosen x) = (fun x => x v = true) := by
    funext x
    simp [chosen]
  rw [he,probability_coordinate (fun _ => coin_sum p) v (fun b => b = true)]
  simp [probability,coin]

lemma chosen_mean (p : ℝ) (D : Finset V) :
    expectation (productMass (fun _ : V => coin p))
      (fun x => ((chosen x ∩ D).card : ℝ)) = (D.card : ℝ)*p := by
  rw [expectation_inter_card]
  simp only [chosen_marginal,sum_const,nsmul_eq_mul]

lemma chosen_bounded_change (D : Finset V) (i : V) (x y : V → Bool)
    (hxy : ∀ j, j ≠ i → x j = y j) :
    |((chosen x ∩ D).card : ℝ)-(chosen y ∩ D).card| ≤ 1 := by
  classical
  have he : (chosen x ∩ D).erase i = (chosen y ∩ D).erase i := by
    ext j
    by_cases hj : j = i
    · subst j; simp
    · simp [chosen,hj,hxy j hj]
  have hx := card_erase_le (s := chosen x ∩ D) (a := i)
  have hy := card_erase_le (s := chosen y ∩ D) (a := i)
  have hx' := pred_card_le_card_erase (s := chosen x ∩ D) (a := i)
  have hy' := pred_card_le_card_erase (s := chosen y ∩ D) (a := i)
  have hec := congrArg Finset.card he
  have h₁ : (chosen x ∩ D).card ≤ (chosen y ∩ D).card+1 := by omega
  have h₂ : (chosen y ∩ D).card ≤ (chosen x ∩ D).card+1 := by omega
  have h₁r : ((chosen x ∩ D).card : ℝ) ≤ (chosen y ∩ D).card+1 := by exact_mod_cast h₁
  have h₂r : ((chosen y ∩ D).card : ℝ) ≤ (chosen x ∩ D).card+1 := by exact_mod_cast h₂
  exact abs_le.mpr ⟨by linarith,by linarith⟩

lemma chosen_concentration {p u : ℝ} (hp : 0 ≤ p) (hp1 : p ≤ 1)
    (hn : 1 ≤ Fintype.card V) (hu : 0 < u) (D : Finset V) :
    probability (productMass (fun _ : V => coin p))
      (fun x => u ≤ |((chosen x ∩ D).card : ℝ)-(D.card : ℝ)*p|) ≤
      2*Real.exp (-u^2/(2*Fintype.card V)) := by
  have hh := bounded_differences_general hn (fun _ : V => coin p)
    (fun _ => coin_nonneg hp hp1) (fun _ => coin_sum p)
    (fun x => ((chosen x ∩ D).card : ℝ)) (by norm_num : (0:ℝ)<1) hu
    (chosen_bounded_change D)
  simpa only [chosen_mean,one_pow,mul_one] using hh

theorem exists_sparse_split {I : Type} [Fintype I]
    (G : SimpleGraph V) [DecidableRel G.Adj] {k : ℕ} {n : ℝ}
    (hk : 64 ≤ k) (hord : (Fintype.card V : ℝ) ≤ n)
    (hc : KConnectedOn G univ k) (D : I → Finset V)
    (hD : ∀ i, (D i).card = k)
    (hsmall : ((Fintype.card I : ℝ)+n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1)) *
      (2*Real.exp (-((k:ℝ)/2000)^2/(2*Fintype.card V))) < 1) :
    ∃ A : Finset V,
      (∀ i, k ≤ 2000*(A ∩ D i).card ∧ k ≤ 2*((univ \ A) ∩ D i).card) ∧
      KConnectedOn G (univ \ A) (k/32) := by
  classical
  let μ := productMass (fun _ : V => coin (1/1000))
  let ε := 2*Real.exp (-((k:ℝ)/2000)^2/(2*Fintype.card V))
  have hkpos : (0:ℝ)<k := by exact_mod_cast (by omega : 0<k)
  have hn : 1 ≤ Fintype.card V := by
    have hh := hc.1
    simp only [card_univ] at hh
    omega
  have hμ : ∀ x, 0 ≤ μ x := productMass_nonneg
    (fun _ => coin_nonneg (by norm_num) (by norm_num))
  have hμs : ∑ x, μ x = 1 := productMass_sum (fun _ => coin_sum _)
  let bad (i : I) (x : V → Bool) : Prop := ¬(k ≤ 2000*(chosen x ∩ D i).card ∧
    k ≤ 2*((univ \ chosen x) ∩ D i).card)
  have hbad (i : I) : probability μ (bad i) ≤ ε := by
    have hh := chosen_concentration (V := V) (p := 1/1000) (by norm_num)
      (by norm_num) hn (show (0:ℝ)<k/2000 by positivity) (D i)
    refine (probability_mono hμ ?_).trans hh
    intro x hx
    by_contra hd
    have hdev := abs_lt.mp (lt_of_not_ge hd)
    rw [hD i] at hdev
    have he : ((univ \ chosen x) ∩ D i).card + (chosen x ∩ D i).card = k := by
      rw [show (univ \ chosen x) ∩ D i = D i \ chosen x by ext; simp; tauto,
        inter_comm (chosen x)]
      exact (card_sdiff_add_card_inter _ _).trans (hD i)
    have he' : (((univ \ chosen x) ∩ D i).card : ℝ) + (chosen x ∩ D i).card = k := by
      exact_mod_cast he
    apply hx
    constructor
    · have hh : (k:ℝ) ≤ 2000*(chosen x ∩ D i).card := by linarith
      exact_mod_cast hh
    · have hh : (k:ℝ) ≤ 2*((univ \ chosen x) ∩ D i).card := by linarith
      exact_mod_cast hh
  let cbad (x : V → Bool) : Prop := ¬((∀ v,
    k ≤ 2*((univ \ chosen x).filter (G.Adj v)).card) ∧
    KConnectedOn G (univ \ chosen x) (k/32))
  have hcomp : probability μ cbad ≤
      (n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1))*ε := by
    apply complement_failure_thousand G hk hkpos le_rfl hord hc hμ chosen
    · intro v
      exact (chosen_marginal (1/1000) v).le
    · dsimp [ε]; positivity
    · intro A
      have hh := chosen_concentration (V := V) (p := 1/1000) (by norm_num)
        (by norm_num) hn (show (0:ℝ)<k/2000 by positivity) A
      refine (probability_mono hμ ?_).trans hh
      intro x hx
      rw [chosen_mean] at hx
      exact (by linarith : (k:ℝ)/2000 ≤ k/100).trans hx
  have hfail : probability μ (fun x => (∃ i, bad i x) ∨ cbad x) < 1 := by
    have hu := probability_union_le hμ bad
    have hs : (∑ i, probability μ (bad i)) ≤ (Fintype.card I : ℝ)*ε := by
      calc
        _ ≤ ∑ _i : I, ε := sum_le_sum (fun i _ => hbad i)
        _ = _ := by simp
    have ho := probability_or_le hμ (fun x => ∃ i, bad i x) cbad
    have he : ((Fintype.card I:ℝ)+n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1))*ε =
        (Fintype.card I : ℝ)*ε+(n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1))*ε := by ring
    rw [he] at hsmall
    linarith
  obtain ⟨x,_,hx⟩ := exists_positive_avoiding hμ hμs hfail
  refine ⟨chosen x,?_,?_⟩
  · intro i
    by_contra hh
    exact hx (Or.inl ⟨i,hh⟩)
  · have hh : ¬cbad x := fun hh => hx (Or.inr hh)
    exact (not_not.mp hh).2

open Filter

lemma sparse_split_numeric_cutoff :
    ∀ᶠ t : ℝ in atTop, ∀ n k N m : ℝ,
      1 ≤ N → N ≤ n → n ≤ t^(11/10:ℝ) → t ≤ k → 0 ≤ m → m ≤ n →
      (m+n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1)) *
        (2*Real.exp (-(k/2000)^2/(2*N))) < 1 := by
  have hp := (tendsto_rpow_atTop (show (0:ℝ)<1/5 by norm_num)).eventually
    (eventually_ge_atTop (8000000:ℝ))
  filter_upwards [eventually_gt_atTop (1:ℝ),hp,complement_numeric_cutoff]
    with t ht hp hc
  intro n k N m hN hNn hn htk hm hmn
  have htpos : 0<t := by linarith
  have hkpos : 0<k := lt_of_lt_of_le htpos htk
  have hn1 : 1≤n := hN.trans hNn
  have hp7 : 0≤t^(7/10:ℝ) := Real.rpow_nonneg htpos.le _
  have hpow : t^(7/10:ℝ)*(t^(1/5:ℝ)*t^(11/10:ℝ))=t^2 := by
    rw [← Real.rpow_add htpos,← Real.rpow_add htpos]
    norm_num
  have hbase : t^(7/10:ℝ)*(8000000*N) ≤ k^2 := by
    calc
      _ ≤ t^(7/10:ℝ)*(8000000*t^(11/10:ℝ)) := by gcongr; exact hNn.trans hn
      _ ≤ t^(7/10:ℝ)*(t^(1/5:ℝ)*t^(11/10:ℝ)) := by gcongr
      _ = t^2 := hpow
      _ ≤ k^2 := by nlinarith
  have he : t^(7/10:ℝ) ≤ (k/2000)^2/(2*N) := by
    apply (le_div_iff₀ (by linarith : 0<2*N)).mpr
    nlinarith
  have htail : 2*Real.exp (-(k/2000)^2/(2*N)) ≤ 2*Real.exp (-t^(7/10:ℝ)) := by
    apply mul_le_mul_of_nonneg_left _ (by norm_num)
    apply Real.exp_le_exp.mpr
    rw [neg_div]
    linarith
  let H : ℝ := n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1)
  have hHpos : 0 ≤ H := by dsimp [H]; positivity
  have hcoef : m+n+(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1) ≤ 2*H := by
    dsimp [H]
    have hp0 : 0≤(n+1)^(⌈10*(n/k)*Real.log (2*n)⌉₊+1) := by positivity
    linarith
  calc
    _ ≤ (2*H)*(2*Real.exp (-(k/2000)^2/(2*N))) :=
      mul_le_mul_of_nonneg_right hcoef (by positivity)
    _ ≤ (2*H)*(2*Real.exp (-t^(7/10:ℝ))) :=
      mul_le_mul_of_nonneg_left htail (by positivity)
    _ = 2*(H*(2*Real.exp (-t^(7/10:ℝ)))) := by ring
    _ ≤ 2*(1/100) := mul_le_mul_of_nonneg_left (hc n k hn1 hn htk) (by norm_num)
    _ < 1 := by norm_num

theorem sparse_split_cutoff :
    ∃ T : ℝ, ∀ t n : ℝ, T ≤ t → 1 ≤ n → n ≤ t^(11/10:ℝ) →
      ∀ (V I : Type) [Fintype V] [DecidableEq V] [Fintype I],
      ∀ (G : SimpleGraph V) [DecidableRel G.Adj],
      ∀ k : ℕ, t ≤ k → (Fintype.card V : ℝ) ≤ n → (Fintype.card I : ℝ) ≤ n →
      KConnectedOn G univ k → ∀ D : I → Finset V, (∀ i, (D i).card=k) →
      ∃ A : Finset V,
        (∀ i, k ≤ 2000*(A ∩ D i).card ∧ k ≤ 2*((univ \ A) ∩ D i).card) ∧
        KConnectedOn G (univ \ A) (k/32) := by
  obtain ⟨T,hT⟩ := eventually_atTop.mp sparse_split_numeric_cutoff
  refine ⟨max T 64,?_⟩
  intro t n ht hn hnt V I _ _ _ G _ k htk hord hI hc D hD
  have hk : 64≤k := by
    have hh : (64:ℝ)≤k := (le_max_right T 64).trans (ht.trans htk)
    exact_mod_cast hh
  apply exists_sparse_split G hk hord hc D hD
  have hN : (1:ℝ)≤Fintype.card V := by
    have hh := hc.1
    simp only [card_univ] at hh
    exact_mod_cast (by omega : 1≤Fintype.card V)
  exact hT t ((le_max_left _ _).trans ht) n k (Fintype.card V) (Fintype.card I)
    hN hord hnt htk (Nat.cast_nonneg _) hI

end LinearListHadwiger.Sampling

namespace LinearListHadwiger.Sampling
open Finset
variable {V : Type} [Fintype V] [DecidableEq V]

theorem sparse_split_on_cutoff :
    ∃ T : ℝ, ∀ t n : ℝ, T ≤ t → 1 ≤ n → n ≤ t^(11/10:ℝ) →
      ∀ (V : Type) [Fintype V] [DecidableEq V],
      ∀ (G : SimpleGraph V) [DecidableRel G.Adj],
      ∀ (S : Finset V) (k : ℕ), t ≤ k → (Fintype.card V : ℝ) ≤ n →
      KConnectedOn G S k → (∀ v, k ≤ (S.filter (G.Adj v)).card) →
      ∃ A B : Finset V, A ⊆ S ∧ B ⊆ S ∧ Disjoint A B ∧
        (∀ v, k ≤ 2000*(A.filter (G.Adj v)).card ∧
          k ≤ 2*(B.filter (G.Adj v)).card) ∧ KConnectedOn G B (k/32) := by
  obtain ⟨T,hT⟩ := sparse_split_cutoff
  refine ⟨T,?_⟩
  intro t n ht hn hnt V _ _ G _ S k htk hord hc hdeg
  classical
  let N (v : V) : Finset (↑S : Set V) := univ.filter (fun w => G.Adj v w.val)
  have hNc (v : V) : (N v).card=(S.filter (G.Adj v)).card := by
    rw [←card_image_of_injective (N v) Subtype.val_injective]
    congr 1
    ext w
    simp only [N,mem_image,mem_filter,mem_univ,true_and]
    constructor
    · rintro ⟨u,hu,rfl⟩
      exact ⟨u.property,hu⟩
    · rintro ⟨hw,hvw⟩
      exact ⟨⟨w,hw⟩,hvw,rfl⟩
  have hD : ∀ v, ∃ D ⊆ N v, D.card=k := fun v =>
    exists_subset_card_eq (by rw [hNc]; exact hdeg v)
  choose D hDN hDc using hD
  have hSord : (Fintype.card (↑S : Set V) : ℝ) ≤ n := by
    have hs : Fintype.card (↑S : Set V) ≤ Fintype.card V := Fintype.card_subtype_le _
    exact (show (Fintype.card (↑S : Set V) : ℝ) ≤ Fintype.card V by
      exact_mod_cast hs).trans hord
  obtain ⟨A',hA',hB'⟩ := hT t n ht hn hnt (↑S : Set V) V (G.induce (↑S : Set V))
    k htk hSord hord (Knitting.induce_connected G S hc) D hDc
  let A := A'.image Subtype.val
  let B := (univ\A').image Subtype.val
  have himage_subset (E : Finset (↑S : Set V)) : E.image Subtype.val ⊆ S := by
    intro v hv
    obtain ⟨w,_,rfl⟩ := mem_image.mp hv
    exact w.property
  have hdis : Disjoint A B := by
    apply Finset.disjoint_left.mpr
    intro v hva hvb
    obtain ⟨u,hu,huv⟩ := mem_image.mp hva
    obtain ⟨w,hw,hwv⟩ := mem_image.mp hvb
    have he : u=w := Subtype.val_injective (huv.trans hwv.symm)
    exact (mem_sdiff.mp hw).2 (he ▸ hu)
  have hcount (E : Finset (↑S : Set V)) (v : V) :
      (E ∩ D v).card ≤ ((E.image Subtype.val).filter (G.Adj v)).card := by
    rw [←card_image_of_injective (E ∩ D v) Subtype.val_injective]
    apply card_le_card
    intro w hw
    obtain ⟨u,hu,rfl⟩ := mem_image.mp hw
    exact mem_filter.mpr ⟨mem_image.mpr ⟨u,(mem_inter.mp hu).1,rfl⟩,
      (mem_filter.mp (hDN v (mem_inter.mp hu).2)).2⟩
  refine ⟨A,B,himage_subset _,himage_subset _,hdis,?_,?_⟩
  · intro v
    exact ⟨(hA' v).1.trans (Nat.mul_le_mul_left _ (hcount A' v)),
      (hA' v).2.trans (Nat.mul_le_mul_left _ (hcount (univ\A') v))⟩
  · exact Knitting.kConnected_image G Subtype.val Subtype.val_injective hB'

end LinearListHadwiger.Sampling

end OAI