import OAI.Combinatorics.PerfectMatching.AlgorithmPartition

namespace OAI

section

namespace BinaryMatching.Algorithm
noncomputable section
open Finset MatchingEntropy

def edgeWeight (G : Input) (e : Pair G.n) : ℝ := Real.exp (Real.log 2*(beta G e:ℝ))
def matchingWeight (G : Input) (M : (completeGraph G.n).Matching) : ℝ :=
  ∏ e∈M.val,edgeWeight G e

def validMatching (G : Input) (M : (completeGraph G.n).Matching) : Prop :=
  ∀ e∈M.val,0< multiplicity G e

def goodWeight (G : Input) (M : (completeGraph G.n).Matching) : ℝ :=
  @ite ℝ (validMatching G M) (Classical.propDecidable _) (matchingWeight G M) 0

def badWeight (G : Input) (M : (completeGraph G.n).Matching) : ℝ :=
  @ite ℝ (validMatching G M) (Classical.propDecidable _) 0 (matchingWeight G M)

def Zgood (G : Input) : ℝ := ∑ M,goodWeight G M
def Zbad (G : Input) : ℝ := ∑ M,badWeight G M

def multProduct (G : Input) (M : (completeGraph G.n).Matching) : ℕ :=
  ∏ e∈M.val,multiplicity G e

lemma matchingWeight_exp (G : Input) (M : (completeGraph G.n).Matching) :
    matchingWeight G M=Real.exp (Real.log 2*((completeGraph G.n).score (fun e => (beta G e:ℝ)) M)) := by
  rw [LooplessGraph.score,mul_sum,Real.exp_sum]
  rfl

lemma matchingWeight_pos (G : Input) (M : (completeGraph G.n).Matching) : 0< matchingWeight G M := by
  rw [matchingWeight_exp]; exact Real.exp_pos _

lemma Z_decompose (G : Input) : Z G=Zgood G+Zbad G := by
  unfold Z LooplessGraph.weightedZ expSum Zgood Zbad
  rw [←sum_add_distrib]
  apply sum_congr rfl; intro M _
  rw [←matchingWeight_exp]
  unfold goodWeight badWeight
  split_ifs <;> simp

lemma goodWeight_nonneg (G : Input) (M : (completeGraph G.n).Matching) : 0≤ goodWeight G M := by
  unfold goodWeight; split_ifs
  · exact (matchingWeight_pos G M).le
  · rfl

lemma badWeight_nonneg (G : Input) (M : (completeGraph G.n).Matching) : 0≤ badWeight G M := by
  unfold badWeight; split_ifs
  · rfl
  · exact (matchingWeight_pos G M).le

lemma Zgood_nonneg (G : Input) : 0≤ Zgood G := sum_nonneg fun M _ => goodWeight_nonneg G M
lemma Zbad_nonneg (G : Input) : 0≤ Zbad G := sum_nonneg fun M _ => badWeight_nonneg G M

lemma edgeWeight_present (G : Input) (e : Pair G.n) (he : 0< multiplicity G e) :
    edgeWeight G e=(2:ℝ)^Nat.log2 (multiplicity G e) := by
  rw [edgeWeight,beta,ite_eq_right (by omega),Int.cast_natCast,mul_comm,Real.exp_nat_mul]
  rw [Real.exp_log (by norm_num : (0:ℝ)<2)]

lemma edgeWeight_rounding (G : Input) (e : Pair G.n) (he : 0< multiplicity G e) :
    (multiplicity G e:ℝ)/2≤ edgeWeight G e ∧ edgeWeight G e≤(multiplicity G e:ℝ) := by
  rw [edgeWeight_present G e he]
  have hlo := Nat.log2_self_le (show multiplicity G e≠0 by omega)
  have hhi : multiplicity G e<2^(Nat.log2 (multiplicity G e)+1) := Nat.lt_log2_self
  have hlo' : (2:ℝ)^Nat.log2 (multiplicity G e)≤(multiplicity G e:ℝ) := by exact_mod_cast hlo
  have hhi' : (multiplicity G e:ℝ)<(2:ℝ)^(Nat.log2 (multiplicity G e)+1) := by exact_mod_cast hhi
  rw [pow_succ] at hhi'
  constructor <;> linarith

lemma invalid_product_zero (G : Input) (M : (completeGraph G.n).Matching)
    (hM : ¬validMatching G M) : multProduct G M=0 := by
  classical
  unfold validMatching at hM
  push Not at hM
  obtain ⟨e,he,hzero⟩ := hM
  unfold multProduct
  exact prod_eq_zero he (by omega)

lemma goodWeight_le_product (G : Input) (M : (completeGraph G.n).Matching) :
    goodWeight G M≤(multProduct G M:ℝ) := by
  unfold goodWeight
  split_ifs with hM
  · unfold matchingWeight multProduct
    push_cast
    exact prod_le_prod₀ (fun e _ => (Real.exp_pos _).le)
      (fun e he => (edgeWeight_rounding G e (hM e he)).2)
  · positivity

lemma goodWeight_ge_product (G : Input) (M : (completeGraph G.n).Matching) :
    (2:ℝ)⁻¹^M.val.card*(multProduct G M:ℝ)≤ goodWeight G M := by
  unfold goodWeight
  split_ifs with hM
  · calc
      _ = ∏ e∈M.val,((multiplicity G e:ℝ)/2) := by
        simp only [div_eq_mul_inv,prod_mul_distrib,prod_const,multProduct,Nat.cast_prod]
        ring
      _ ≤ _ := prod_le_prod₀ (fun e _ => by positivity)
        (fun e he => (edgeWeight_rounding G e (hM e he)).1)
  · rw [invalid_product_zero G M hM,Nat.cast_zero,mul_zero]

lemma Zgood_bracket (G : Input) {r : ℕ} (hn : G.n=2*r) :
    (2:ℝ)⁻¹^r*(count G:ℝ)≤ Zgood G ∧ Zgood G≤(count G:ℝ) := by
  have hc (M : (completeGraph G.n).Matching) : M.val.card=r :=
    (completeGraph G.n).matching_card (by simpa) M
  have hncast : (count G:ℝ)=∑ M,(multProduct G M:ℝ) := by simp [count,multProduct]
  rw [hncast]
  constructor
  · rw [mul_sum]
    exact sum_le_sum fun M _ => by simpa only [hc M] using goodWeight_ge_product G M
  · exact sum_le_sum fun M _ => goodWeight_le_product G M

lemma positive_count_valid (G : Input) (hN : 0< count G) :
    ∃ M : (completeGraph G.n).Matching, validMatching G M := by
  have hsum : 0<∑ M,multProduct G M := hN
  obtain ⟨M,_hM,hprod⟩ := (sum_pos_iff_of_nonneg (fun M _ => Nat.zero_le (multProduct G M))).mp hsum
  refine ⟨M,?_⟩
  by_contra h
  rw [invalid_product_zero G M h] at hprod
  omega

lemma validWeight_ge_one (G : Input) (M : (completeGraph G.n).Matching)
    (hM : validMatching G M) : 1≤ goodWeight G M := by
  rw [goodWeight,ite_eq_left hM]
  apply one_le_prod₀
  intro e he
  rw [edgeWeight_present G e (hM e he)]
  exact one_le_pow₀ (by norm_num)

lemma Zgood_ge_one (G : Input) (hN : 0< count G) : 1≤ Zgood G := by
  obtain ⟨M,hM⟩ := positive_count_valid G hN
  exact (validWeight_ge_one G M hM).trans
    (single_le_sum (fun N _ => goodWeight_nonneg G N) (mem_univ M))

lemma beta_le_B (G : Input) (e : Pair G.n) : (beta G e:ℝ)≤(B G:ℝ) := by
  unfold beta
  split_ifs
  · simp only [Int.cast_neg,Int.cast_natCast]
    have : (0:ℝ)≤ B G := by positivity
    have : (0:ℝ)≤ L G := by positivity
    linarith
  · exact_mod_cast multiplicity_log_le_B G e

lemma matching_card_bound (n : ℕ) : Fintype.card (completeGraph n).Matching≤2^(q n) := by
  calc
    _ ≤ Fintype.card (Finset (Pair n)) :=
      Fintype.card_le_of_injective (fun M => M.val) Subtype.val_injective
    _ = _ := by rw [Fintype.card_finset]; rfl

lemma badWeight_bound (G : Input) {r : ℕ} (hn : G.n=2*r)
    (M : (completeGraph G.n).Matching) :
    badWeight G M≤ Real.exp (Real.log 2*((B G:ℝ)*r-L G)) := by
  classical
  unfold badWeight
  split_ifs with hM
  · exact (Real.exp_pos _).le
  · have hbad := hM
    unfold validMatching at hbad
    push Not at hbad
    obtain ⟨e,he,hzero⟩ := hbad
    have hz : multiplicity G e=0 := by omega
    have hbe : (beta G e:ℝ)=-(L G:ℝ) := by simp [beta,hz]
    have hc : M.val.card=r := (completeGraph G.n).matching_card (by simpa) M
    have hsingle := single_le_sum (s := M.val) (f := fun e => (B G:ℝ)-(beta G e:ℝ))
      (fun e _ => sub_nonneg.mpr (beta_le_B G e)) he
    rw [hbe,sum_sub_distrib,sum_const,hc,nsmul_eq_mul] at hsingle
    have hB : (0:ℝ)≤ B G := by positivity
    have hsum : (∑ e∈M.val,(beta G e:ℝ))≤(B G:ℝ)*r-L G := by nlinarith
    rw [matchingWeight_exp]
    apply Real.exp_le_exp.mpr
    exact mul_le_mul_of_nonneg_left hsum log_two_pos.le

lemma Zbad_bound (G : Input) {r : ℕ} (hn : G.n=2*r) :
    Zbad G≤ Real.exp (Real.log 2*((q G.n:ℝ)+(B G:ℝ)*r-L G)) := by
  calc
    _ ≤ ∑ _M : (completeGraph G.n).Matching, Real.exp (Real.log 2*((B G:ℝ)*r-L G)) :=
      sum_le_sum fun M _ => badWeight_bound G hn M
    _ = (Fintype.card (completeGraph G.n).Matching:ℝ)*Real.exp (Real.log 2*((B G:ℝ)*r-L G)) := by simp
    _ ≤ (2:ℝ)^(q G.n)*Real.exp (Real.log 2*((B G:ℝ)*r-L G)) := by
      apply mul_le_mul_of_nonneg_right _ (Real.exp_pos _).le
      exact_mod_cast matching_card_bound G.n
    _ = _ := by
      have he : (2:ℝ)^(q G.n)=Real.exp ((q G.n:ℝ)*Real.log 2) := by
        rw [Real.exp_nat_mul,Real.exp_log (by norm_num : (0:ℝ)<2)]
      rw [he,←Real.exp_add]
      congr 1
      ring

lemma completion_parameter_bound (G : Input) {r : ℕ} (hn : G.n=2*r) :
    q G.n+B G*r+20*G.n≤ L G := by
  let t := G.n+B G+1
  have ht1 : 1≤ t := by dsimp [t]; omega
  have hnt : G.n≤ t := by dsimp [t]; omega
  have hBt : B G≤ t := by dsimp [t]; omega
  have hrt : r≤ t := by omega
  have hq : q G.n≤ t^2 := (q_le_square (n := G.n)).trans (Nat.pow_le_pow_left hnt 2)
  have hBr : B G*r≤ t^2 := by simpa only [pow_two] using Nat.mul_le_mul hBt hrt
  have ht13 : t≤ t^3 := Nat.le_self_pow (by omega) t
  have ht23 : t^2≤ t^3 := by
    calc
      t^2=t^2*1 := by ring
      _ ≤ t^2*t := Nat.mul_le_mul_left _ ht1
      _ = _ := by ring
  change _≤100*t^3
  omega

lemma Zbad_small (G : Input) (heven : Even G.n) :
    Zbad G≤ Real.exp (Real.log 2*(-20*(G.n:ℝ))) := by
  obtain ⟨r,hr⟩ := heven
  have hn : G.n=2*r := by omega
  have hh := Zbad_bound G hn
  have hdom : (q G.n:ℝ)+(B G:ℝ)*r+20*(G.n:ℝ)≤ L G := by
    exact_mod_cast completion_parameter_bound G hn
  apply hh.trans
  apply Real.exp_le_exp.mpr
  apply mul_le_mul_of_nonneg_left _ log_two_pos.le
  linarith

theorem completion_bracket (G : Input) (hn : 4≤ G.n) (heven : Even G.n) :
    (count G=0 → logZ G≤-20*(G.n:ℝ)) ∧
    (0< count G → 1≤ Z G ∧ (2:ℝ)⁻¹^(G.n/2)*(count G:ℝ)≤ Z G ∧ Z G≤2*(count G:ℝ)) := by
  have hbad := Zbad_small G heven
  have hNsplit := Z_decompose G
  have hsmall : Zbad G≤1 := by
    apply hbad.trans (Real.exp_le_one_iff.mpr _)
    exact mul_nonpos_of_nonneg_of_nonpos log_two_pos.le (mul_nonpos_of_nonpos_of_nonneg (by norm_num) (Nat.cast_nonneg _))
  have hn2 : G.n=2*(G.n/2) := by
    obtain ⟨r,hr⟩ := heven
    omega
  have hgood := Zgood_bracket G hn2
  constructor
  · intro hN
    have hg : Zgood G=0 := le_antisymm (by simpa only [hN,Nat.cast_zero] using hgood.2) (Zgood_nonneg G)
    have hz : Z G≤ Real.exp (Real.log 2*(-20*(G.n:ℝ))) := by linarith
    have hl := Real.log_le_log (Z_pos G hn heven) hz
    rw [Real.log_exp] at hl
    unfold logZ
    apply (div_le_iff₀ log_two_pos).2
    nlinarith
  · intro hN
    have hng : 1≤ Zgood G := Zgood_ge_one G hN
    have hN' : (1:ℝ)≤ count G := by exact_mod_cast hN
    have hbn := Zbad_nonneg G
    constructor
    · linarith
    constructor
    · linarith [hgood.1]
    · linarith [hgood.2]

end
end BinaryMatching.Algorithm
end

end OAI