import OAI.Combinatorics.ContingencyTables.Dense.GridMinCut
import OAI.Combinatorics.ContingencyTables.Dense.GridCutFlow
import OAI.Combinatorics.ContingencyTables.Dense.GridMetropolis

namespace OAI

/-!
# Conditional Poincaré bound for the actual dense bin chain

Both published inputs are explicit: finite-box Prékopa interpolation and
finite-chain Cheeger. All margin, penalty, cut, and proposal obligations
for this chain follow from the dense completion geometry.
-/

namespace ContingencyTables.GridBoundary

open CommonBasesFPRAS
open scoped BigOperators Classical

noncomputable section

variable {I J : Type*} [Fintype I] [Fintype J] [DecidableEq I] [DecidableEq J]
variable {q K : ℕ}

def denseBinWeight (R : Option I → ℕ) (P : Option J → ℕ) (d : ℕ)
    (e : I × J ≃ Fin q) (a : Grid (I := Fin q) K) : ℝ :=
  DenseWeights.binWeight ((d : ℝ) ^ 4) (denseGridPenalty R P d e) (realCorner a)

def denseBinChain (R : Option I → ℕ) (P : Option J → ℕ)
    (d : ℕ) (hd : 14 ≤ d) (hfree : Fintype.card (I × J) ≤ d)
    (e : I × J ≃ Fin q) (hK : 1 ≤ K) : FiniteChain (Grid (I := Fin q) K) := by
  have hq : q ≤ d := by
    have hc := Fintype.card_congr e
    rw [Fintype.card_fin] at hc
    omega
  exact gridChain d hd hq hK (denseBinWeight R P d e) (fun a => DenseWeights.binWeight_pos _ _ _)

def denseCutConstant (d K : ℕ) : ℝ := binProposal d / (128 * (d : ℝ) * K)

private theorem corner_injective : Function.Injective (corner (I := Fin q) (K := K)) := by
  intro a b h
  funext j
  apply Subtype.ext
  exact congrFun h j

theorem denseBinChain_poincare (R : Option I → ℕ) (P : Option J → ℕ)
    (d : ℕ) (hd : 14 ≤ d) (hR : ∀ i, d ^ 12 ≤ R i) (hP : ∀ j, d ^ 12 ≤ P j)
    (hRmax : ∀ i, R (some i) ≤ R none) (hPmax : ∀ j, P (some j) ≤ P none)
    (hfree : Fintype.card (I × J) ≤ d) (e : I × J ≃ Fin q) (hK : 1 ≤ K)
    (hPL : PublishedInputs.FiniteBoxPrekopaLeindler q)
    (hCheeger : PublishedInputs.FiniteCheeger (Grid (I := Fin q) K)) :
    ∀ f : Grid (I := Fin q) K → ℝ,
      (denseBinChain R P d hd hfree e hK).variance f ≤
        (2 / (denseCutConstant d K) ^ 2) * (denseBinChain R P d hd hfree e hK).energy f := by
  classical
  let : DecidableEq (Grid (I := Fin q) K) := Classical.decEq _
  let : Nonempty (Grid (I := Fin q) K) := ⟨fun _ => ⟨0, by constructor <;> omega⟩⟩
  let w := denseBinWeight R P d e (K := K)
  have hw : ∀ a, 0 < w a := fun a => DenseWeights.binWeight_pos _ _ _
  have hq : q ≤ d := by
    have hc := Fintype.card_congr e
    rw [Fintype.card_fin] at hc
    omega
  have hd₀ : (0 : ℝ) < d := by exact_mod_cast (show 0 < d by omega)
  have hK₀ : (0 : ℝ) < K := by exact_mod_cast (show 0 < K by omega)
  have hβ := (binProposal_bounds d hd).1
  have hκ : 0 < denseCutConstant d K := by unfold denseCutConstant; positivity
  apply MetropolisChain.poincare_of_weighted_cut w hw Neighbor neighbor_symm (binProposal d) hβ.le
    (2 * q) (fun a => by simpa using neighbor_degree a)
    ((binProposal_degree q d hd hq).trans (by norm_num)) hCheeger (denseCutConstant d K) hκ
  intro S
  change denseCutConstant d K * min (∑ a ∈ S, w a) (∑ a ∈ Sᶜ, w a) ≤
    binProposal d * (∑ a ∈ S, ∑ b ∈ Sᶜ, if Neighbor a b then min (w a) (w b) else 0)
  have hSw : 0 ≤ ∑ a ∈ S, w a := Finset.sum_nonneg (fun a _ => (hw a).le)
  have hScw : 0 ≤ ∑ a ∈ Sᶜ, w a := Finset.sum_nonneg (fun a _ => (hw a).le)
  by_cases hs : S.Nonempty
  · by_cases hsc : Sᶜ.Nonempty
    · let Q : (Fin q → ℤ) → Prop := fun z => ∃ a ∈ S, corner a = z
      have hQ (a : Grid (I := Fin q) K) : Q (corner a) ↔ a ∈ S := by
        constructor
        · rintro ⟨b, hb, he⟩
          exact corner_injective he ▸ hb
        · intro ha
          exact ⟨a, ha, rfl⟩
      have hne : Nonempty (Selected K Q) := by
        obtain ⟨a, ha⟩ := hs
        exact ⟨⟨a, (hQ a).mpr ha⟩⟩
      have hne' : Nonempty (Selected K (fun a => ¬ Q a)) := by
        obtain ⟨a, ha⟩ := hsc
        exact ⟨⟨a, fun h => (Finset.mem_compl.mp ha) ((hQ a).mp h)⟩⟩
      have hdense := denseGrid_min_cut R P d hd hR hP hRmax hPmax hfree e hPL hK Q hne hne'
      change (1 / (128 * (d : ℝ) * K)) *
        min (∑ a : Selected K Q, w a.val) (∑ a : Selected K (fun a => ¬ Q a), w a.val) ≤
          ∑ edge : CutEdge K Q, min (w edge.val.1) (w edge.val.2.1) at hdense
      have hsum : (∑ a : Selected K Q, w a.val) = ∑ a ∈ S, w a := by
        rw [selected_sum_eq_filter Q w]
        apply Finset.sum_congr ?_ (fun _ _ => rfl)
        ext a
        simp only [Finset.mem_filter, Finset.mem_univ, true_and, hQ]
      have hsum' : (∑ a : Selected K (fun a => ¬ Q a), w a.val) = ∑ a ∈ Sᶜ, w a := by
        rw [selected_sum_eq_filter (fun a => ¬ Q a) w]
        apply Finset.sum_congr ?_ (fun _ _ => rfl)
        ext a
        simp only [Finset.mem_filter, Finset.mem_univ, true_and, hQ, Finset.mem_compl]
      rw [hsum, hsum'] at hdense
      have hflow := cut_faces_le_neighbor_flow Q w (fun a => (hw a).le)
      have hflow' : (∑ edge : CutEdge K Q, min (w edge.val.1) (w edge.val.2.1)) ≤
          ∑ a ∈ S, ∑ b ∈ Sᶜ, if Neighbor a b then min (w a) (w b) else 0 := by
        convert hflow using 1
        apply Finset.sum_congr ?_ ?_
        · ext a
          simp only [Finset.mem_filter, Finset.mem_univ, true_and, hQ]
        · intro a _
          apply Finset.sum_congr ?_ (fun _ _ => rfl)
          ext b
          simp only [Finset.mem_filter, Finset.mem_univ, true_and, hQ, Finset.mem_compl]
      have hbound := hdense.trans hflow'
      calc
        _ = binProposal d * ((1 / (128 * (d : ℝ) * K)) *
            min (∑ a ∈ S, w a) (∑ a ∈ Sᶜ, w a)) := by unfold denseCutConstant; ring
        _ ≤ _ := mul_le_mul_of_nonneg_left hbound hβ.le
    · have he : Sᶜ = ∅ := Finset.not_nonempty_iff_eq_empty.mp hsc
      rw [he]
      simp only [Finset.sum_empty, min_eq_right hSw, mul_zero, Finset.sum_const_zero]
      exact le_rfl
  · have he : S = ∅ := Finset.not_nonempty_iff_eq_empty.mp hs
    rw [he] at hScw ⊢
    simp only [Finset.sum_empty, min_eq_left hScw, mul_zero]
    exact le_rfl

end

end ContingencyTables.GridBoundary

end OAI