import OAI.Combinatorics.PerfectMatching.CountCorrect

namespace OAI

section

namespace BinaryMatching.Algorithm
noncomputable section
open Finset MatchingEntropy

lemma count_zero_vertices (G : Input) (hn : G.n=0) : count G=1 := by
  classical
  let M : (completeGraph G.n).Matching := ⟨∅,fun v => by have := v.isLt; omega⟩
  have hM (N : (completeGraph G.n).Matching) : N=M := by
    apply Subtype.ext
    apply Finset.eq_empty_of_forall_notMem
    intro e _
    have := e.val.1.isLt
    omega
  unfold count
  rw [sum_eq_single M]
  · simp [M]
  · intro N _ hne
    exact (hne (hM N)).elim
  · simp

lemma count_odd_vertices (G : Input) (hn : Odd G.n) : count G=0 := by
  classical
  have hempty : IsEmpty (completeGraph G.n).Matching := ⟨fun M => by
    have hh := (completeGraph G.n).matching_card_twice M
    simp only [Fintype.card_fin] at hh
    obtain ⟨r,hr⟩ := hn
    omega⟩
  simp [count]

lemma count_two_vertices (G : Input) (hn : G.n=2) : count G=rawMultiplicity G 0 1 := by
  classical
  let e : Pair G.n := ⟨(⟨0,by omega⟩,⟨1,by omega⟩),by simp⟩
  have heq (f : Pair G.n) : f=e := by
    apply Subtype.ext
    apply Prod.ext <;> apply Fin.ext
    · have hh := f.property; have h1 := f.val.1.isLt; have h2 := f.val.2.isLt
      dsimp [e] at hh ⊢; omega
    · have hh := f.property; have h1 := f.val.1.isLt; have h2 := f.val.2.isLt
      dsimp [e] at hh ⊢; omega
  have heinc (v : Fin G.n) : (completeGraph G.n).Incident v e := by
    have hv := v.isLt
    change e.val.1=v ∨ e.val.2=v
    by_cases hz : v.val=0
    · left; apply Fin.ext; exact hz.symm
    · right; apply Fin.ext; dsimp [e]; omega
  let M : (completeGraph G.n).Matching := ⟨{e},fun v => ⟨e,⟨by simp,heinc v⟩,
    fun _ h => by simpa only [mem_singleton] using h.1⟩⟩
  have hM (N : (completeGraph G.n).Matching) : N=M := by
    apply Subtype.ext
    apply Finset.ext
    intro f
    have hfn := heq f
    obtain ⟨g,hg,_⟩ := N.property e.val.1
    have hgn := heq g
    have hmem : e∈N.val := hgn ▸ hg.1
    simp only [M,mem_singleton,hfn]
    exact iff_true_intro hmem
  unfold count
  rw [sum_eq_single M]
  · simp only [M,prod_singleton]
    unfold multiplicity rawMultiplicity
    dsimp [e]
    cases G.records.find? (fun r => r.left=0 && r.right=1) <;> rfl
  · intro N _ hne
    exact (hne (hM N)).elim
  · simp

lemma present_endpoints_covered (G : Input) (e : Pair G.n) (he : 0 < multiplicity G e) :
    e.val.1.val∈covered G ∧ e.val.2.val∈covered G := by
  unfold multiplicity at he
  cases hf : G.records.find? (fun r => r.left=e.val.1.val && r.right=e.val.2.val) with
  | none => simp only [hf] at he; omega
  | some r =>
    have hr := List.mem_of_find?_eq_some hf
    have hp := List.find?_some hf
    simp only [Bool.and_eq_true,decide_eq_true_eq] at hp
    simp only [hf] at he
    have hr' : r∈G.records.filter (fun r => 0 < r.multiplicity) := by simp [hr,he]
    constructor
    · simp only [covered,List.mem_toFinset,List.mem_flatMap]
      refine ⟨r,hr',?_⟩
      simp [hp.1]
    · simp only [covered,List.mem_toFinset,List.mem_flatMap]
      refine ⟨r,hr',?_⟩
      simp [hp.2]

lemma positive_count_covered (G : Input) (hN : 0 < count G) : G.n ≤ (covered G).card := by
  obtain ⟨M,hM⟩ := positive_count_valid G hN
  have hsub : range G.n ⊆ covered G := by
    intro v hv
    let w : Fin G.n := ⟨v,mem_range.mp hv⟩
    obtain ⟨e,⟨he,hinc⟩,_⟩ := M.property w
    have hep := present_endpoints_covered G e (hM e he)
    rcases hinc with h|h
    · have hh : e.val.1.val=v := congrArg Fin.val h
      simpa only [hh] using hep.1
    · have hh : e.val.2.val=v := congrArg Fin.val h
      simpa only [hh] using hep.2
  simpa only [card_range] using card_le_card hsub

lemma count_zero_of_uncovered (G : Input) (hu : (covered G).card < G.n) : count G=0 := by
  by_contra hN
  have := positive_count_covered G (Nat.pos_of_ne_zero hN)
  omega

theorem approximate_correct (G : Input) :
    approximate G ≤ count G ∧ count G ≤ 2^(9*G.n)*approximate G ∧
      (approximate G=0 ↔ count G=0) := by
  unfold approximate
  split_ifs with hn0 hodd hn2 hcover
  · rw [count_zero_vertices G hn0,hn0]
    norm_num
  · rw [count_odd_vertices G hodd]
    simp
  · rw [count_two_vertices G hn2]
    refine ⟨le_rfl,?_,Iff.rfl⟩
    exact Nat.le_mul_of_pos_left _ (by positivity)
  · rw [count_zero_of_uncovered G hcover]
    simp
  · have heven : Even G.n := Nat.not_odd_iff_even.mp hodd
    have hn : 4 ≤ G.n := by
      obtain ⟨r,hr⟩ := heven
      omega
    exact estimate_correct G hn heven

end
end BinaryMatching.Algorithm
end

end OAI