import OAI.Computability.LoopMatching.Accumulator
import OAI.Computability.LoopMatching.CountDecomposition
import OAI.Computability.LoopMatching.ExpandInput
import OAI.Computability.MatchingCount.BinarySolve

namespace OAI

/-! Polynomial-time approximation of weighted matchings with singleton loops. -/

namespace LoopMatching
open scoped BigOperators

namespace Approximation

def term (G : Input) (j : ℕ) : ℕ :=
  BinaryMatching.Raw.InputData.sparseEstimate (expand G j)

def output (G : Input) : ℕ × ℕ :=
  (Accumulator.Q (term G) G.n, G.n.factorial)

theorem term_bounds (G : Input) (j : ℕ) :
    term G j ≤ BinaryMatching.count (expand G j) ∧
    BinaryMatching.count (expand G j) ≤ 2 ^ (9 * (G.n + j)) * term G j ∧
    (term G j = 0 ↔ BinaryMatching.count (expand G j) = 0) := by
  simpa only [term, expand_n] using
    BinaryMatching.Raw.InputData.sparseEstimate_correct (expand G j)

theorem output_den_pos (G : Input) : 0 < (output G).2 := Nat.factorial_pos _

theorem output_value (G : Input) :
    outputValue (output G) =
      ∑ j ∈ Finset.range (G.n + 1), (term G j : ℚ) / (j.factorial : ℚ) :=
  Accumulator.quotient_eq_sum (term G) G.n

theorem factorial_profile_bounds (a b : ℕ → ℕ) (C n : ℕ)
    (hlo : ∀ j ≤ n, a j ≤ j.factorial * b j)
    (hhi : ∀ j ≤ n, j.factorial * b j ≤ C * a j) :
    Accumulator.Q a n ≤ n.factorial * (∑ j ∈ Finset.range (n + 1), b j) ∧
    n.factorial * (∑ j ∈ Finset.range (n + 1), b j) ≤ C * Accumulator.Q a n := by
  revert hlo hhi
  induction n with
  | zero =>
      intro hlo hhi
      simpa using And.intro (hlo 0 (by omega)) (hhi 0 (by omega))
  | succ n ih =>
      intro hlo hhi
      obtain ⟨hl, hu⟩ := ih (fun j hj => hlo j (by omega))
        (fun j hj => hhi j (by omega))
      have hlastlo := hlo (n + 1) (by omega)
      have hlasthi := hhi (n + 1) (by omega)
      rw [Accumulator.Q_succ, Finset.sum_range_succ]
      constructor
      · calc
          (n + 1) * Accumulator.Q a n + a (n + 1) ≤
              (n + 1) * (n.factorial * (∑ j ∈ Finset.range (n + 1), b j)) +
                (n + 1).factorial * b (n + 1) :=
            Nat.add_le_add (Nat.mul_le_mul_left _ hl) hlastlo
          _ = (n + 1).factorial *
              ((∑ j ∈ Finset.range (n + 1), b j) + b (n + 1)) := by
            rw [Nat.factorial_succ]; ring
      · calc
          (n + 1).factorial *
              ((∑ j ∈ Finset.range (n + 1), b j) + b (n + 1)) =
              (n + 1) * (n.factorial * (∑ j ∈ Finset.range (n + 1), b j)) +
                (n + 1).factorial * b (n + 1) := by
            rw [Nat.factorial_succ]; ring
          _ ≤ (n + 1) * (C * Accumulator.Q a n) + C * a (n + 1) :=
            Nat.add_le_add (Nat.mul_le_mul_left _ hu) hlasthi
          _ = C * ((n + 1) * Accumulator.Q a n + a (n + 1)) := by ring

theorem output_bounds_of_expanded_count (G : Input)
    (expanded_count : ∀ j ≤ G.n,
      BinaryMatching.count (expand G j) = j.factorial * countWithLoops G j) :
    (output G).1 ≤ (output G).2 * count G ∧
    (output G).2 * count G ≤ 2 ^ (18 * G.n) * (output G).1 ∧
    ((output G).1 = 0 ↔ count G = 0) := by
  have hlo : ∀ j ≤ G.n, term G j ≤ j.factorial * countWithLoops G j := by
    intro j hj
    rw [← expanded_count j hj]
    exact (term_bounds G j).1
  have hhi : ∀ j ≤ G.n,
      j.factorial * countWithLoops G j ≤ 2 ^ (18 * G.n) * term G j := by
    intro j hj
    rw [← expanded_count j hj]
    apply (term_bounds G j).2.1.trans
    apply Nat.mul_le_mul_right
    apply Nat.pow_le_pow_right (by omega : 1 ≤ (2 : ℕ))
    omega
  obtain ⟨hl, hu⟩ := factorial_profile_bounds (term G) (countWithLoops G)
    (2 ^ (18 * G.n)) G.n hlo hhi
  rw [← count_eq_sum_countWithLoops G] at hl hu
  change (output G).1 ≤ (output G).2 * count G at hl
  change (output G).2 * count G ≤ 2 ^ (18 * G.n) * (output G).1 at hu
  refine ⟨hl, hu, ?_⟩
  constructor
  · intro hz
    rw [hz, mul_zero] at hu
    have hprod : (output G).2 * count G = 0 := Nat.eq_zero_of_le_zero hu
    exact (Nat.mul_eq_zero.mp hprod).resolve_left (Nat.ne_of_gt (output_den_pos G))
  · intro hz
    rw [hz, mul_zero] at hl
    exact Nat.eq_zero_of_le_zero hl

theorem output_magnitude (G : Input) (B : ℕ)
    (hB : ∀ j ≤ G.n, term G j ≤ B) :
    (output G).1 ≤ (G.n + 1).factorial * B ∧
    (output G).2 = G.n.factorial :=
  ⟨Accumulator.Q_le_factorial_mul (term G) G.n B hB, rfl⟩

private theorem succ_le_two_pow (n : ℕ) : n + 1 ≤ 2 ^ n := by
  induction n with
  | zero => simp
  | succ n ih =>
      rw [pow_succ]
      have hp : 0 < 2 ^ n := by positivity
      omega

theorem factorial_le_two_pow_square (n : ℕ) : n.factorial ≤ 2 ^ (n * n) := by
  induction n with
  | zero => simp
  | succ n ih =>
      calc
        (n + 1).factorial = (n + 1) * n.factorial := Nat.factorial_succ n
        _ ≤ 2 ^ n * 2 ^ (n * n) := Nat.mul_le_mul (succ_le_two_pow n) ih
        _ = 2 ^ (n + n * n) := (pow_add 2 n (n * n)).symm
        _ ≤ 2 ^ ((n + 1) * (n + 1)) := by
          apply Nat.pow_le_pow_right (by omega : 1 ≤ (2 : ℕ))
          nlinarith

theorem output_exponential_magnitude (G : Input) (B : ℕ)
    (hB : ∀ j ≤ G.n, term G j ≤ 2 ^ B) :
    (output G).1 ≤ 2 ^ ((G.n + 1) * (G.n + 1) + B) ∧
    (output G).2 ≤ 2 ^ (G.n * G.n) := by
  constructor
  · calc
      (output G).1 ≤ (G.n + 1).factorial * 2 ^ B :=
        (output_magnitude G (2 ^ B) hB).1
      _ ≤ 2 ^ ((G.n + 1) * (G.n + 1)) * 2 ^ B :=
        Nat.mul_le_mul_right _ (factorial_le_two_pow_square (G.n + 1))
      _ = 2 ^ ((G.n + 1) * (G.n + 1) + B) := (pow_add _ _ _).symm
  · exact factorial_le_two_pow_square G.n

end Approximation
end LoopMatching

end OAI