import OAI.Combinatorics.PerfectMatching.ElementaryCount

namespace OAI

section

namespace BinaryMatching.Algorithm
noncomputable section
open Finset

def inputLength (G : Input) : ℕ := (encodeInput G).length

lemma encodeNat_length (n : ℕ) : (encodeNat n).length=2*n.bits.length+1 := by
  simp [encodeNat]; omega

lemma encodeRecord_length (r : Record) :
    (encodeRecord r).length=2*(r.left.bits.length+r.right.bits.length+r.multiplicity.bits.length)+3 := by
  simp only [encodeRecord,List.length_append,encodeNat_length]
  omega

lemma records_length_le_input (G : Input) : G.records.length≤ inputLength G := by
  have hh (rs : List Record) : rs.length≤(rs.flatMap encodeRecord).length := by
    induction rs with
    | nil => simp
    | cons r rs ih =>
      simp only [List.length_cons,List.flatMap_cons,List.length_append,encodeRecord_length]
      omega
  have := hh G.records
  simp only [inputLength,encodeInput,List.length_append]
  omega

lemma record_bits_le_input (G : Input) (r : Record) (hr : r∈G.records) :
    r.multiplicity.bits.length≤ inputLength G := by
  have hh : (encodeRecord r).length≤(G.records.flatMap encodeRecord).length := by
    rw [List.length_flatMap]
    exact List.le_sum_of_mem (List.mem_map.mpr ⟨r,hr,rfl⟩)
  rw [encodeRecord_length] at hh
  unfold inputLength encodeInput
  simp only [List.length_append]
  omega

lemma log2_le_bits (m : ℕ) : Nat.log2 m≤ m.bits.length := by
  by_cases hm : m=0
  · subst m; simp
  · rw [Nat.size_eq_bits_len]
    exact (Nat.lt_size.mpr (Nat.log2_self_le hm)).le

lemma B_le_input (G : Input) : B G≤ inputLength G := by
  apply foldl_max_le _ _ _ (Nat.zero_le _)
  intro b hb
  obtain ⟨r,hr,rfl⟩ := List.mem_map.mp hb
  exact (log2_le_bits r.multiplicity).trans (record_bits_le_input G r hr)

lemma covered_card_le_records (G : Input) : (covered G).card≤2*G.records.length := by
  have hh := List.toFinset_card_le
    ((G.records.filter (fun e => 0< e.multiplicity)).flatMap (fun e => [e.left,e.right]))
  have hlen : ((G.records.filter (fun e => 0< e.multiplicity)).flatMap (fun e => [e.left,e.right])).length=
      2*(G.records.filter (fun e => 0< e.multiplicity)).length := by
    rw [List.length_flatMap]
    simp
    omega
  rw [hlen] at hh
  exact hh.trans (Nat.mul_le_mul_left 2 (List.length_filter_le _ _))

lemma positive_count_order_bound (G : Input) (hN : 0< count G) : G.n≤2*inputLength G := by
  exact (positive_count_covered G hN).trans
    ((covered_card_le_records G).trans (Nat.mul_le_mul_left _ (records_length_le_input G)))

lemma multiplicity_pow_bound (G : Input) (e : Pair G.n) : multiplicity G e≤2^(B G+1) := by
  apply (Nat.lt_log2_self (n := multiplicity G e)).le.trans
  exact Nat.pow_le_pow_right (by norm_num) (by have := multiplicity_log_le_B G e; omega)

lemma count_pow_bound (G : Input) : count G≤2^((B G+2)*q G.n) := by
  have hM (M : (completeGraph G.n).Matching) : multProduct G M≤2^((B G+1)*q G.n) := by
    calc
      _ ≤ ∏ _e∈M.val,2^(B G+1) := prod_le_prod (fun e _ => multiplicity_pow_bound G e)
      _ = (2^(B G+1))^M.val.card := by simp
      _ ≤ (2^(B G+1))^(q G.n) :=
        Nat.pow_le_pow_right (by positivity) (card_le_univ M.val)
      _ = _ := by rw [pow_mul]
  calc
    _ ≤ ∑ _M : (completeGraph G.n).Matching,2^((B G+1)*q G.n) := sum_le_sum fun M _ => hM M
    _ = Fintype.card (completeGraph G.n).Matching*2^((B G+1)*q G.n) := by simp
    _ ≤ 2^(q G.n)*2^((B G+1)*q G.n) := Nat.mul_le_mul_right _ (matching_card_bound G.n)
    _ = _ := by rw [←pow_add]; congr 1; ring

lemma approximate_bits_bound (G : Input) :
    (approximate G).bits.length≤4*(inputLength G)^2*(inputLength G+2)+1 := by
  by_cases hN : count G=0
  · have ha := (approximate_correct G).2.2.mpr hN
    simp [ha]
  · have hNpos : 0< count G := Nat.pos_of_ne_zero hN
    have hn := positive_count_order_bound G hNpos
    have hb := B_le_input G
    have hq : q G.n≤4*(inputLength G)^2 := by
      apply (q_le_square (n := G.n)).trans
      calc
        G.n^2≤(2*inputLength G)^2 := Nat.pow_le_pow_left hn 2
        _ = _ := by ring
    have hExp : (B G+2)*q G.n≤4*(inputLength G)^2*(inputLength G+2) := by
      have := Nat.mul_le_mul (Nat.add_le_add_right hb 2) hq
      nlinarith
    rw [Nat.size_eq_bits_len]
    apply (Nat.size_le_size (approximate_correct G).1).trans
    apply (Nat.size_le_size (count_pow_bound G)).trans
    rw [Nat.size_pow]
    omega

theorem approximate_polynomial_output :
    ∃ P : Polynomial ℕ,∀ G,(approximate G).bits.length≤ P.eval (encodeInput G).length := by
  refine ⟨Polynomial.C 4*Polynomial.X^2*(Polynomial.X+Polynomial.C 2)+Polynomial.C 1,?_⟩
  intro G
  simpa only [Polynomial.eval_add,Polynomial.eval_mul,Polynomial.eval_pow,Polynomial.eval_X,
    Polynomial.eval_C,inputLength] using approximate_bits_bound G

end
end BinaryMatching.Algorithm
end

end OAI