import Mathlib
import OAI.Combinatorics.MatchingCount.Graphs.ColoredEdge
import OAI.Combinatorics.MatchingCount.Graphs.Related

namespace OAI

namespace MatchingFPRAS.Enlargement

open MatchingFPRAS.Switching MatchingFPRAS.Subdivision MatchingFPRAS.RealGeometry
open MatchingFPRAS.Hierarchy Finset

variable {V : Type*} [Fintype V] [LinearOrder V] [Nontrivial V]

lemma row_nonempty (x : V) : (Finset.univ.erase x : Finset V).Nonempty := by
  obtain ⟨y,hy⟩ := exists_ne x
  exact ⟨y,by simp [hy]⟩

noncomputable def sourceHeight (w : V → V → ℝ) (x : V) : ℝ :=
  (Finset.univ.erase x).sup' (row_nonempty x) (bottleneck w x)

lemma bottleneck_le_sourceHeight (w : V → V → ℝ) {x y : V} (hxy : x ≠ y) :
    bottleneck w x y ≤ sourceHeight w x :=
  Finset.le_sup' (bottleneck w x) (by simp [hxy.symm])

lemma one_le_sourceHeight (w : V → V → ℝ) (x : V) : 1 ≤ sourceHeight w x := by
  obtain ⟨y,hy⟩ := exists_ne x
  exact (one_le_bottleneck w x y).trans (bottleneck_le_sourceHeight w hy.symm)

lemma sourceHeight_nonneg (w : V → V → ℝ) (x : V) : 0 ≤ sourceHeight w x :=
  zero_le_one.trans (one_le_sourceHeight w x)

lemma sourceHeight_bound (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K) (x : V) : sourceHeight w x ≤ 4^K := by
  apply Finset.sup'_le
  intro y hy
  exact bottleneck_le_row_bound w x (4^K) (one_le_pow₀ (by norm_num)) (hw x) y

noncomputable def maxSourceHeight (w : V → V → ℝ) : ℝ :=
  Finset.univ.sup' Finset.univ_nonempty (sourceHeight w)

lemma sourceHeight_le_max (w : V → V → ℝ) (x : V) : sourceHeight w x ≤ maxSourceHeight w :=
  Finset.le_sup' (sourceHeight w) (Finset.mem_univ x)

lemma one_le_maxSourceHeight (w : V → V → ℝ) : 1 ≤ maxSourceHeight w := by
  obtain ⟨x⟩ := (inferInstance : Nonempty V)
  exact (one_le_sourceHeight w x).trans (sourceHeight_le_max w x)

lemma maxSourceHeight_bound (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K) : maxSourceHeight w ≤ 4^K := by
  exact Finset.sup'_le _ _ (fun x _ => sourceHeight_bound w K hw x)

noncomputable def sourceLevels (w : V → V → ℝ) (K : ℕ) : ℕ :=
  (dyadicLevel (2*K) (maxSourceHeight w)).val

lemma sourceLevels_le (w : V → V → ℝ) (K : ℕ) : sourceLevels w K ≤ 2*K := by
  have := (dyadicLevel (2*K) (maxSourceHeight w)).isLt
  dsimp [sourceLevels]; omega

lemma maxSourceHeight_lt (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K) :
    maxSourceHeight w < (2:ℝ)^(sourceLevels w K+1) := by
  apply dyadic_upper
  convert maxSourceHeight_bound w K hw using 1
  rw [pow_mul]; norm_num

abbrev SourceVertex (V : Type*) [LinearOrder V] (K : ℕ) := Vertex V (LogicalEdge V) (4*(2*K+2))

abbrev SourceRealEdge (V : Type*) [LinearOrder V] (K : ℕ) := LogicalEdge V × Fin (4*(2*K+2)+1)

def realLeft (K : ℕ) (e : SourceRealEdge V K) : SourceVertex V K :=
  atVertex source target (4*(2*K+2)) e.1 e.2.castSucc

def realRight (K : ℕ) (e : SourceRealEdge V K) : SourceVertex V K :=
  atVertex source target (4*(2*K+2)) e.1 e.2.succ

noncomputable def sourceRealB (w : V → V → ℝ) (K : ℕ) : SourceVertex V K → SourceVertex V K → ℝ :=
  realBottleneck source target (2*K+2) (fun e => bottleneck w (source e) (target e))
    (fun e => sourceHeight w (source e)) (fun e => sourceHeight w (target e)) (logicalActivity w)

lemma source_profile_strength (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K) (e : SourceRealEdge V K) :
    sourceRealB w K (realLeft K e) (realRight K e) =
      profileActivity (2*K+2) (bottleneck w (source e.1) (target e.1))
        (sourceHeight w (source e.1)) (sourceHeight w (target e.1))
        (bottleneck w (source e.1) (target e.1)) e.2 := by
  apply source_effective_profile
  · omega
  · intro e; exact sourceHeight_nonneg w _
  · intro e; exact sourceHeight_nonneg w _
  · intro f
    rw [show 2*K+2-1=2*K+1 by omega]
    exact profile_innermost K _ _ (one_le_bottleneck _ _ _) (sourceHeight_bound w K hw _)

lemma source_strength_incident_near (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K)
    (x : SourceVertex V K) (e f : SourceRealEdge V K)
    (he : Incident (realLeft K) (realRight K) e x)
    (hf : Incident (realLeft K) (realRight K) f x) :
    sourceRealB w K (realLeft K e) (realRight K e) ≤ 2*sourceRealB w K (realLeft K f) (realRight K f) := by
  simp only [source_profile_strength w K hw]
  apply effective_profile_incident_near source target (2*K+2) (by omega)
    (fun e => bottleneck w (source e) (target e)) (sourceHeight w)
  · intro e; exact zero_le_one.trans (one_le_bottleneck _ _ _)
  · exact sourceHeight_nonneg w
  · intro e
    exact ⟨bottleneck_le_sourceHeight w (source_ne_target e),by
      rw [bottleneck_comm]; exact bottleneck_le_sourceHeight w (source_ne_target e).symm⟩
  · intro e
    rw [show 2*K+2-1=2*K+1 by omega]
    exact profile_innermost K _ _ (one_le_bottleneck _ _ _) (sourceHeight_bound w K hw _)
  · intro e
    rw [show 2*K+2-1=2*K+1 by omega]
    exact profile_innermost K _ _ (one_le_bottleneck _ _ _) (sourceHeight_bound w K hw _)
  · exact he
  · exact hf

lemma profile_upper (p : ℕ) (B HU HV lam T : ℝ) (hB : B ≤ T) (hU : HU ≤ T) (hV : HV ≤ T)
    (hU0 : 0 ≤ HU) (hV0 : 0 ≤ HV) (hlam : lam ≤ T) (i : Fin (4*p+1)) :
    profileActivity p B HU HV lam i ≤ T := by
  rcases lt_trichotomy i.val (2*p) with h | h | h
  · rw [profile_left _ _ _ _ _ _ h]
    exact max_le hB ((div_le_self hU0 (one_le_pow₀ (by norm_num))).trans hU)
  · have hi : i=⟨2*p,by omega⟩ := Fin.ext h
    rw [hi,profile_center]; exact hlam
  · rw [profile_right _ _ _ _ _ _ h]
    exact max_le hB ((div_le_self hV0 (one_le_pow₀ (by norm_num))).trans hV)

lemma source_strength_le_max (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K) (e : SourceRealEdge V K) :
    sourceRealB w K (realLeft K e) (realRight K e) ≤ maxSourceHeight w := by
  rw [source_profile_strength w K hw]
  have hb := (bottleneck_le_sourceHeight w (source_ne_target e.1)).trans (sourceHeight_le_max w _)
  exact profile_upper _ _ _ _ _ _ hb (sourceHeight_le_max w _) (sourceHeight_le_max w _)
    (sourceHeight_nonneg w _) (sourceHeight_nonneg w _) hb _

lemma sourceRealB_comm (w : V → V → ℝ) (K : ℕ) (x y : SourceVertex V K) :
    sourceRealB w K x y = sourceRealB w K y x := bottleneck_comm _ _ _

lemma sourceRealB_tri (w : V → V → ℝ) (K : ℕ) (x y z : SourceVertex V K)
    (hxy : x ≠ y) (hxz : x ≠ z) (hyz : y ≠ z) :
    min (sourceRealB w K x z) (sourceRealB w K z y) ≤ sourceRealB w K x y :=
  bottleneck_ultrametric _ _ _ _ hxy hxz hyz

lemma sourceRealB_floor (w : V → V → ℝ) (K : ℕ) (x y : SourceVertex V K) :
    1 ≤ sourceRealB w K x y := one_le_bottleneck _ _ _

abbrev SourceLabel (w : V → V → ℝ) (K : ℕ) :=
  Label (sourceRealB w K) (sourceRealB_comm w K) (sourceRealB_tri w K) (sourceLevels w K)

noncomputable def sourceBags (w : V → V → ℝ) (K : ℕ) (x : SourceVertex V K) :
    Finset (SourceLabel w K) :=
  memberships (sourceRealB w K) (sourceRealB_comm w K) (sourceRealB_tri w K)
    (realLeft K) (realRight K) (sourceLevels w K) x

noncomputable abbrev sourceTree (w : V → V → ℝ) (K : ℕ) : SimpleGraph (SourceLabel w K) :=
  tree (sourceRealB w K) (sourceRealB_comm w K) (sourceRealB_tri w K)

lemma sourceTree_isTree (w : V → V → ℝ) (K : ℕ) : (sourceTree w K).IsTree := by
  exact ⟨tree_connected _ _ _ (sourceRealB_floor w K) _,tree_acyclic _ _ _ _⟩

lemma sourceBag_card_le_two (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K) (x : SourceVertex V K) :
    (sourceBags w K x).card ≤ 2 := by
  apply membership_count
  · exact sourceRealB_floor w K
  · intro e
    exact (source_strength_le_max w K hw e).trans_lt (maxSourceHeight_lt w K hw)
  · exact source_strength_incident_near w K hw

lemma sourceBag_tree_adjacent (w : V → V → ℝ) (K : ℕ)
    (hw : ∀ x y, x ≠ y → edgeActivity w x y ≤ (4:ℝ)^K)
    (x : SourceVertex V K) (a b : SourceLabel w K)
    (ha : a ∈ sourceBags w K x) (hb : b ∈ sourceBags w K x) :
    a=b ∨ (sourceTree w K).Adj a b := by
  apply memberships_tree_bags _ _ _ (sourceRealB_floor w K) (realLeft K) (realRight K)
    (sourceLevels w K) (fun e => (source_strength_le_max w K hw e).trans_lt
      (maxSourceHeight_lt w K hw)) (source_strength_incident_near w K hw) x a b ha hb

lemma sourceBag_height (w : V → V → ℝ) (K : ℕ) {x y : SourceVertex V K}
    (hxy : x ≠ y) (l : SourceLabel w K) (hx : l ∈ sourceBags w K x)
    (hy : l ∈ sourceBags w K y) : (2:ℝ)^l.1.val ≤ sourceRealB w K x y := by
  exact common_height_le _ _ _ (sourceRealB_floor w K) (realLeft K) (realRight K)
    (sourceLevels w K) hxy hx hy

end MatchingFPRAS.Enlargement

namespace MatchingFPRAS.Transport

section

open Finset

variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]

variable (inc : E → V → Prop)

noncomputable def support (Q : Finset E) : Finset V := by
  classical
  exact Finset.univ.filter fun v => ∃ e ∈ Q, inc e v

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
lemma mem_support (Q : Finset E) (v : V) : v ∈ support inc Q ↔ ∃ e ∈ Q, inc e v := by
  classical
  simp [support]

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
lemma support_eq_of_matching {Q : Finset E} {U : Finset V} (h : MatchingOn inc Q U) :
    support inc Q=U := by
  ext v
  rw [mem_support]
  constructor
  · rintro ⟨e,he,hv⟩; exact h.1 e he v hv
  · intro hv
    obtain ⟨e,he,_⟩ := h.2 v hv
    exact ⟨e,he⟩

abbrev Partial := {Q : Finset E // MatchingOn inc Q (support inc Q)}

abbrev Matchings (U : Finset V) := {M : Finset E // MatchingOn inc M U}

noncomputable instance partialFintype : Fintype (Partial inc) := Fintype.ofFinite _

noncomputable instance matchingsFintype (U : Finset V) : Fintype (Matchings inc U) := Fintype.ofFinite _

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
lemma submatching {M Q : Finset E} {U : Finset V} (hM : MatchingOn inc M U) (hQ : Q⊆M) :
    MatchingOn inc Q (support inc Q) := by
  refine ⟨?_,?_⟩
  · intro e he v hv; exact (mem_support inc Q v).mpr ⟨e,he,hv⟩
  · intro v hv
    obtain ⟨e,he,hev⟩ := (mem_support inc Q v).mp hv
    refine ⟨e,⟨he,hev⟩,?_⟩
    intro f hf
    exact hM.unique (hM.1 e (hQ he) v hev) (hQ hf.1) hf.2 (hQ he) hev

omit [Fintype E] [DecidableEq E] in
lemma support_sdiff_disjoint (Q : Finset E) : Disjoint (support inc Q) (univ \ support inc Q) := by
  exact Finset.disjoint_left.mpr (fun x hx hy => (Finset.mem_sdiff.mp hy).2 hx)

noncomputable def expansionEquiv (hinc : ∀ e, ∃ v, inc e v) :
    (Σ M : Matchings inc univ, {Q : Finset E // Q⊆M.val}) ≃
      Σ Q : Partial inc, Matchings inc (univ \ support inc Q.val) where
  toFun a := ⟨⟨a.2.val,submatching inc a.1.property a.2.property⟩,
    ⟨a.1.val \ a.2.val,a.1.property.sdiff
      (submatching inc a.1.property a.2.property) a.2.property⟩⟩
  invFun a := ⟨⟨a.1.val ∪ a.2.val,by
      have h := a.1.property.union a.2.property (support_sdiff_disjoint inc a.1.val)
      rw [Finset.union_sdiff_of_subset (Finset.subset_univ _)] at h
      exact h⟩,⟨a.1.val,Finset.subset_union_left⟩⟩
  left_inv a := by
    rcases a with ⟨M,Q,hQ⟩
    have h : Q ∪ (M.val \ Q)=M.val := Finset.union_sdiff_of_subset hQ
    apply Sigma.ext (Subtype.ext h)
    change HEq (⟨Q,Finset.subset_union_left⟩ : {R : Finset E // R ⊆ Q ∪ (M.val \ Q)})
      (⟨Q,hQ⟩ : {R : Finset E // R ⊆ M.val})
    exact (Subtype.heq_iff_coe_eq (fun R => by rw [h])).mpr rfl
  right_inv a := by
    rcases a with ⟨Q,M⟩
    have hd : Disjoint Q.val M.val := Q.property.disjoint_edges M.property hinc
      (support_sdiff_disjoint inc Q.val)
    change (⟨Q,⟨(Q.val ∪ M.val) \ Q.val,_⟩⟩ :
      Σ Q : Partial inc, Matchings inc (univ \ support inc Q.val)) = ⟨Q,M⟩
    apply congrArg (fun R : Matchings inc (univ \ support inc Q.val) =>
      (⟨Q,R⟩ : Σ Q : Partial inc, Matchings inc (univ \ support inc Q.val)))
    exact Subtype.ext (Finset.union_sdiff_cancel_left hd)

noncomputable def partitionWeight {R : Type*} [CommSemiring R] (w : E → R) (U : Finset V) : R :=
  ∑ M : Matchings inc U, ∏ e ∈ M.val, w e

theorem partition_add {R : Type*} [CommSemiring R] (r v : E → R)
    (hinc : ∀ e, ∃ x, inc e x) :
    partitionWeight inc (fun e => r e+v e) univ =
      ∑ Q : Partial inc, (∏ e ∈ Q.val, v e) * partitionWeight inc r (univ \ support inc Q.val) := by
  classical
  unfold partitionWeight
  have hex (M : Matchings inc univ) :
      (∏ e ∈ M.val, (r e+v e)) =
        ∑ Q : {Q : Finset E // Q⊆M.val}, (∏ e ∈ Q.val, v e) * ∏ e ∈ M.val \ Q.val, r e := by
    rw [show (∏ e ∈ M.val, (r e+v e))=(∏ e ∈ M.val, (v e+r e)) by
      apply Finset.prod_congr rfl; intro e he; exact add_comm _ _]
    rw [Finset.prod_add]
    exact Finset.sum_subtype _ (fun Q => Finset.mem_powerset)
      (fun Q => (∏ e ∈ Q, v e) * ∏ e ∈ M.val \ Q, r e)
  simp_rw [hex,Finset.mul_sum]
  have h := (expansionEquiv inc hinc).sum_comp
    (fun a => (∏ e ∈ a.1.val, v e) * ∏ e ∈ a.2.val, r e)
  rw [Fintype.sum_sigma,Fintype.sum_sigma] at h
  exact h

end

open Finset

variable {V E : Type*} [Fintype V] [Fintype E] [DecidableEq V] [DecidableEq E]

variable (inc : E → V → Prop)

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
@[simp] lemma support_empty : support inc ∅=∅ := by
  ext x; simp [support]

noncomputable def emptyPartial : Partial inc := ⟨∅,by simp [MatchingOn]⟩

omit [Fintype E] [DecidableEq V] [DecidableEq E] in
lemma partial_eq_empty_iff (Q : Partial inc) : Q=emptyPartial inc ↔ Q.val=∅ := by
  exact Subtype.ext_iff

omit [Fintype V] [DecidableEq V] [DecidableEq E] in
lemma partitionWeight_nonneg (r : E → ℝ) (hr : ∀ e,0≤r e) (U : Finset V) :
    0≤partitionWeight inc r U := Finset.sum_nonneg (fun _ _ => Finset.prod_nonneg (fun e _ => hr e))

omit [Fintype V] [DecidableEq V] [DecidableEq E] in
lemma partitionWeight_mono (r w : E → ℝ) (hr : ∀ e,0≤r e) (hrw : ∀ e,r e≤w e)
    (U : Finset V) : partitionWeight inc r U≤partitionWeight inc w U :=
  Finset.sum_le_sum (fun _ _ => Finset.prod_le_prod₀ (fun e _ => hr e) (fun e _ => hrw e))

lemma pow_mul_linear_le_one (x : ℝ) (hx : 0≤x) (m : ℕ) :
    (1+x)^m * (1-(m:ℝ)*x) ≤ 1 := by
  induction m with
  | zero => simp
  | succ m ih =>
    rw [pow_succ,Nat.cast_succ]
    have hp : 0≤(1+x)^m := pow_nonneg (by linarith) _
    have h : (1+x) * (1-((m:ℝ)+1)*x) ≤ 1-(m:ℝ)*x := by
      have hm : 0≤(m:ℝ) := Nat.cast_nonneg _
      nlinarith [sq_nonneg x,mul_nonneg hm (sq_nonneg x)]
    calc
      _ = (1+x)^m * ((1+x) * (1-((m:ℝ)+1)*x)) := by ring
      _ ≤ (1+x)^m * (1-(m:ℝ)*x) := mul_le_mul_of_nonneg_left h hp
      _ ≤ 1 := ih

lemma pow_small_le (x : ℝ) (hx : 0≤x) (m : ℕ) (hm : (m:ℝ)*x≤1/100) :
    (1+x)^m≤100/99 := by
  have hp : 0≤(1+x)^m := pow_nonneg (by linarith) _
  have h := pow_mul_linear_le_one x hx m
  nlinarith [mul_nonneg hp (show 0≤1/100-(m:ℝ)*x by linarith)]

lemma all_subsets_pow (x : ℝ) :
    (∑ Q : Finset E, x^Q.card)=(1+x)^Fintype.card E := by
  classical
  have h := Finset.prod_add (fun _ : E => x) (fun _ => (1:ℝ)) univ
  simpa [Finset.prod_const,Finset.prod_const_one,add_comm] using h.symm

omit [DecidableEq V] in
lemma partial_pow_sum_le (x : ℝ) (hx : 0≤x) :
    (∑ Q : Partial inc, x^Q.val.card) ≤ (1+x)^Fintype.card E := by
  classical
  rw [←all_subsets_pow]
  calc
    _ = ∑ Q ∈ univ.image (Subtype.val : Partial inc → Finset E), x^Q.card :=
      (Finset.sum_image (fun a _ b _ h => Subtype.ext h)).symm
    _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.subset_univ _)
      (fun Q _ _ => pow_nonneg hx _)

theorem finite_inflation (r v : E → ℝ) (hr : ∀ e,0≤r e) (hv : ∀ e,0≤v e)
    (hinc : ∀ e,∃ x,inc e x) (hz : 0<partitionWeight inc r univ)
    (x : ℝ) (hx : 0≤x) (hm : (Fintype.card E:ℝ)*x≤1/100)
    (hlocal : ∀ Q : Partial inc, Q.val≠∅ →
      (∏ e ∈ Q.val, v e) * partitionWeight inc r (univ \ support inc Q.val) /
        partitionWeight inc r univ ≤ 2*x^Q.val.card) :
    1 ≤ partitionWeight inc (fun e => r e+v e) univ / partitionWeight inc r univ ∧
    partitionWeight inc (fun e => r e+v e) univ / partitionWeight inc r univ ≤ 2 := by
  classical
  constructor
  · apply (le_div_iff₀ hz).mpr
    simpa using partitionWeight_mono inc r (fun e => r e+v e) hr (fun e => le_add_of_nonneg_right (hv e)) univ
  · let mass (Q : Partial inc) := (∏ e ∈ Q.val, v e) *
      partitionWeight inc r (univ \ support inc Q.val) / partitionWeight inc r univ
    have hmass : ∀ Q : Partial inc, mass Q+(if Q=emptyPartial inc then 1 else 0)≤2*x^Q.val.card := by
      intro Q
      by_cases he : Q=emptyPartial inc
      · subst Q
        norm_num [mass,emptyPartial,hz.ne']
      · simpa only [ite_eq_right he,add_zero] using hlocal Q (fun h => he ((partial_eq_empty_iff inc Q).mpr h))
    have hs := Finset.sum_le_sum (s := (univ : Finset (Partial inc))) (fun Q _ => hmass Q)
    simp only [Finset.sum_add_distrib,Finset.sum_ite_eq',Finset.mem_univ,ite_true,
      ←Finset.mul_sum] at hs
    have hsum := partial_pow_sum_le inc x hx
    have hpow := pow_small_le x hx (Fintype.card E) hm
    rw [partition_add inc r v hinc,Finset.sum_div]
    change (∑ Q : Partial inc, mass Q) ≤ 2
    linarith

end MatchingFPRAS.Transport

end OAI