import OAI.Combinatorics.ContingencyTables.Rooted.ForestCut

namespace OAI

/-!
# Actual bipartite cell forests and their completion intervals

The graph vertices are the original row and column labels. Capacities
are attached to unordered row-column edges. The deletion-component cut
is constructed from the maximizing forest, so the hypotheses of the
physical cut estimate follow from actual graph properties.
-/

namespace ContingencyTables.ForestCapacity

open scoped BigOperators Classical
open SimpleGraph
open MaximumForest ForestCut

variable {I J : Type*} [Fintype I] [Fintype J]

def cellAdj (small : I → J → Bool) : I⊕J → I⊕J → Prop
  | .inl i,.inr j => small i j=false
  | .inr j,.inl i => small i j=false
  | _,_ => False

def cellGraph (small : I → J → Bool) : SimpleGraph (I⊕J) where
  Adj := cellAdj small
  symm := ⟨by intro v w; cases v <;> cases w <;> exact id⟩
  loopless := ⟨by intro v; cases v <;> exact id⟩

def pairCapacity (b : I → J → ℕ) : I⊕J → I⊕J → ℕ
  | .inl i,.inr j => b i j
  | .inr j,.inl i => b i j
  | _,_ => 0

def capacity (b : I → J → ℕ) : Sym2 (I⊕J) → ℕ :=
  Sym2.lift ⟨pairCapacity b,by intro v w; cases v <;> cases w <;> rfl⟩

omit [Fintype I] [Fintype J] in
@[simp] lemma capacity_cell (b : I → J → ℕ) (i : I) (j : J) :
    capacity b s(Sum.inl i,Sum.inr j)=b i j := rfl

omit [Fintype I] [Fintype J] in
lemma cell_edge_injective : Function.Injective
    (fun a : I×J => s(Sum.inl a.1,Sum.inr a.2)) := by
  rintro ⟨i,j⟩ ⟨i',j'⟩ h
  simpa only [Sym2.eq_iff,Prod.mk.injEq,Sum.inl.injEq,Sum.inr.injEq,
    Sum.inl_ne_inr,Sum.inr_ne_inl,false_and,or_false] using h

noncomputable def treeCell (T : SimpleGraph (I⊕J)) (i : I) (j : J) : Bool :=
  decide (T.Adj (.inl i) (.inr j))

/-- The actual maximum-forest cut gives the source's displacement and
interval bounds for every solution of the selected nonroot equations. -/
theorem completion_interval (small : I → J → Bool) (b : I → J → ℕ)
    (T : SimpleGraph (I⊕J)) (hTG : T≤cellGraph small) (hT : T.IsAcyclic)
    (hmax : ∀ F : SimpleGraph (I⊕J), F≤cellGraph small → F.IsAcyclic →
      weight F (capacity b)≤weight T (capacity b))
    (i₀ : I) (j₀ : J) (ht : T.Adj (.inl i₀) (.inr j₀)) (root : I⊕J)
    (hroot : T.Reachable root (.inl i₀))
    (x q z X : I → J → ℝ) (d : ℝ) (W : ℕ)
    (hd : 1≤d) (hcard : (Fintype.card I*Fintype.card J:ℕ)≤d)
    (hlarge : ∀ i j, small i j=false → W≤b i j ∧ 1≤b i j)
    (hsmall : ∀ i j, small i j=true → b i j<W ∧
      (0≤x i j ∧ x i j≤b i j) ∧ (0≤q i j ∧ q i j≤b i j))
    (hX : ∀ i j, 0≤X i j ∧ X i j≤b i j)
    (hfree : ∀ i j, small i j=false → treeCell T i j=false →
      0≤z i j ∧ z i j≤b i j+1)
    (hr : ∀ i, T.Reachable root (.inl i) → Sum.inl i≠root → rowDifference small x z X i=0)
    (hc : ∀ j, T.Reachable root (.inr j) → Sum.inr j≠root → columnDifference small q z X j=0) :
    -10*d*b i₀ j₀≤z i₀ j₀ ∧ z i₀ j₀≤10*d*b i₀ j₀ := by
  let t : Sym2 (I⊕J) := s(Sum.inl i₀,Sum.inr j₀)
  let D := T.deleteEdges {t}
  obtain ⟨r,hrr,hrootSide,hcross⟩ := exists_root_avoiding_side T hT ht root hroot
  let rowU : I → Bool := fun i => side D r (.inl i)
  let colU : J → Bool := fun j => side D r (.inr j)
  have hs₀ : small i₀ j₀=false := hTG ht
  have hB : (1:ℝ)≤b i₀ j₀ := by exact_mod_cast (hlarge i₀ j₀ hs₀).2
  have hdisp : |z i₀ j₀-X i₀ j₀|≤4*d*b i₀ j₀ := by
    apply displacement_bound small (treeCell T) rowU colU x q z X
      (fun i j => (b i j:ℝ)) i₀ j₀ d hcard hB hs₀ hcross
    · intro i hi
      change side D r (.inl i)=true at hi
      apply hr i
      · have hri : D.Reachable r (.inl i) := by
          simpa only [side,decide_eq_true_eq] using hi
        exact hrr.trans (hri.mono
          (T.deleteEdges_le {t}))
      · intro he
        have hbad : side D r root=true := by simpa only [he] using hi
        exact Bool.false_ne_true (hrootSide.symm.trans hbad)
    · intro j hj
      change side D r (.inr j)=true at hj
      apply hc j
      · have hrj : D.Reachable r (.inr j) := by
          simpa only [side,decide_eq_true_eq] using hj
        exact hrr.trans (hrj.mono
          (T.deleteEdges_le {t}))
      · intro he
        have hbad : side D r root=true := by simpa only [he] using hj
        exact Bool.false_ne_true (hrootSide.symm.trans hbad)
    · exact hX
    · intro i j hs
      have hcap : b i j≤b i₀ j₀ := (Nat.le_of_lt (hsmall i j hs).1).trans
        (hlarge i₀ j₀ hs₀).1
      exact ⟨by exact_mod_cast hcap,(hsmall i j hs).2⟩
    · intro i j htree hne
      apply side_eq_of_tree_edge T t r
      · exact of_decide_eq_true htree
      · exact fun he => hne (cell_edge_injective he)
    · intro i j hs htree
      refine ⟨hfree i j hs htree,?_⟩
      intro hcut
      have hgraph : (cellGraph small).Adj (.inl i) (.inr j) := hs
      have hcap := crossing_free_edge_le (cellGraph small) T (capacity b)
        hTG hT hmax t (by simpa [t] using ht) r hgraph
        (by simpa only [treeCell,decide_eq_false_iff_not] using htree) hcut
      exact_mod_cast hcap
  exact physical_interval_of_displacement d (b i₀ j₀) (X i₀ j₀) (z i₀ j₀)
    hd (Nat.cast_nonneg _) (hX i₀ j₀) hdisp

end ContingencyTables.ForestCapacity

end OAI