import OAI.Combinatorics.ContingencyTables.Rooted.ForestGreedySemantics
import OAI.Combinatorics.ContingencyTables.Rooted.ForestCapacity

namespace OAI

/-! # The executed maximum-capacity forest on the original cell vertices

The program uses the concrete row-then-column natural indexing. The
returned adjacency list is decoded and transported back to the original
bipartite vertex type. Its catalog and optimality obligations follow
from the stored capacities, rather than supplied correctness predicates.
-/

namespace ContingencyTables.ComputedLargeForest

open SimpleGraph MaximumForest ForestCapacity ForestGreedySemantics
open FiniteGraphRootProgram LargeEdgeCatalogProgram
open scoped BigOperators Classical

variable {m n : ℕ}

abbrev vertexEquiv : (Fin m⊕Fin n) ≃ Fin (m+n) := finSumFinEquiv

def small (b : Fin m→Fin n→ℕ) (W : ℕ) (i : Fin m) (j : Fin n) : Bool :=
  decide (b i j<W)

def graph (b : Fin m→Fin n→ℕ) (W : ℕ) : SimpleGraph (Fin (m+n)) :=
  (cellGraph (small b W)).map vertexEquiv.toEmbedding

def capacities (b : Fin m→Fin n→ℕ) (e : Sym2 (Fin (m+n))) : ℕ :=
  capacity b (Sym2.map vertexEquiv.symm e)

lemma graph_edge (b : Fin m→Fin n→ℕ) (W : ℕ) (i : Fin m) (j : Fin n) :
    (graph b W).Adj (vertexEquiv (.inl i)) (vertexEquiv (.inr j)) ↔ W≤b i j := by
  change ((cellGraph (small b W)).map vertexEquiv.toEmbedding).Adj
    (vertexEquiv.toEmbedding (.inl i)) (vertexEquiv.toEmbedding (.inr j)) ↔ _
  have hm := SimpleGraph.map_adj_apply (G:=cellGraph (small b W))
    (f:=vertexEquiv.toEmbedding) (a:=Sum.inl i) (b:=Sum.inr j)
  exact hm.trans (by simp only [cellGraph,cellAdj,small,decide_eq_false_iff_not,not_lt])

lemma capacities_cell (b : Fin m→Fin n→ℕ) (i : Fin m) (j : Fin n) :
    capacities b s(vertexEquiv (.inl i),vertexEquiv (.inr j))=b i j := by
  simp only [capacities,Sym2.map_mk,Equiv.symm_apply_apply,capacity_cell]

lemma catalog_correct (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) (W : ℕ) :
    Catalog (graph b W) (capacities b) (catalog (NetworkVertexCode.data r c b,W)) := by
  constructor
  · intro e he
    obtain ⟨i,j,hb,rfl⟩ := (mem_catalog_code r c b W e).mp he
    refine ⟨vertexEquiv (.inl i),vertexEquiv (.inr j),(graph_edge b W i j).mpr hb,?_⟩
    rw [capacities_cell]
    simp only [vertexEquiv,finSumFinEquiv_apply_left,finSumFinEquiv_apply_right,
      Fin.val_castAdd,Fin.val_natAdd]
  · intro u v huv
    obtain ⟨a,rfl⟩ := vertexEquiv.surjective u
    obtain ⟨d,rfl⟩ := vertexEquiv.surjective v
    have hm := SimpleGraph.map_adj_apply (G:=cellGraph (small b W))
      (f:=vertexEquiv.toEmbedding) (a:=a) (b:=d)
    have h : (cellGraph (small b W)).Adj a d := hm.mp huv
    cases a with
    | inl i=>
      cases d with
      | inl k=>exact False.elim h
      | inr j=>
        left
        have hb : W≤b i j := by simpa only [cellGraph,cellAdj,small,
          decide_eq_false_iff_not,not_lt] using h
        apply (mem_catalog_code r c b W _).mpr
        refine ⟨i,j,hb,?_⟩
        rw [capacities_cell]
        simp only [vertexEquiv,finSumFinEquiv_apply_left,
          finSumFinEquiv_apply_right,Fin.val_castAdd,Fin.val_natAdd]
    | inr j=>
      cases d with
      | inr k=>exact False.elim h
      | inl i=>
        right
        have hb : W≤b i j := by simpa only [cellGraph,cellAdj,small,
          decide_eq_false_iff_not,not_lt] using h
        apply (mem_catalog_code r c b W _).mpr
        refine ⟨i,j,hb,?_⟩
        rw [show s(vertexEquiv (.inr j),vertexEquiv (.inl i))=
          s(vertexEquiv (.inl i),vertexEquiv (.inr j)) from Sym2.eq_swap]
        rw [capacities_cell]
        simp only [vertexEquiv,finSumFinEquiv_apply_left,
          finSumFinEquiv_apply_right,Fin.val_castAdd,Fin.val_natAdd]

lemma capacity_positive (b : Fin m→Fin n→ℕ) (W : ℕ) (hW : 1≤W) :
    ∀ e∈(graph b W).edgeSet,0<capacities b e := by
  intro e he
  induction e using Sym2.inductionOn with
  | _ u v=>
    obtain ⟨a,rfl⟩ := vertexEquiv.surjective u
    obtain ⟨d,rfl⟩ := vertexEquiv.surjective v
    have hm := SimpleGraph.map_adj_apply (G:=cellGraph (small b W))
      (f:=vertexEquiv.toEmbedding) (a:=a) (b:=d)
    have h : (cellGraph (small b W)).Adj a d := hm.mp he
    cases a with
    | inl i=>
      cases d with
      | inl k=>exact False.elim h
      | inr j=>
        have hb : W≤b i j := by simpa only [cellGraph,cellAdj,small,
          decide_eq_false_iff_not,not_lt] using h
        rw [capacities_cell b i j]
        omega
    | inr j=>
      cases d with
      | inr k=>exact False.elim h
      | inl i=>
        rw [show s(vertexEquiv (.inr j),vertexEquiv (.inl i))=
          s(vertexEquiv (.inl i),vertexEquiv (.inr j)) from Sym2.eq_swap]
        have hb : W≤b i j := by simpa only [cellGraph,cellAdj,small,
          decide_eq_false_iff_not,not_lt] using h
        rw [capacities_cell b i j]
        omega

lemma empty_code (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) (W : ℕ) :
    ForestGreedyProgram.emptyGraph (NetworkVertexCode.data r c b,W)=
      graphCode (⊥ : SimpleGraph (Fin (m+n))) := by
  simp only [ForestGreedyProgram.emptyGraph,vertexCount_code,DirectedBFSCode.range_eq_map,
    ←List.ofFn_eq_map,List.map_ofFn,graphCode]
  apply congrArg List.ofFn
  funext v
  simp [adjacencyRow]

/-- The output list itself determines the forest. -/
noncomputable def computed (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ) (W : ℕ) :
    SimpleGraph (Fin m⊕Fin n) :=
  (decoded (ForestGreedyProgram.forest (NetworkVertexCode.data r c b,W))).comap vertexEquiv

private lemma weight_transport {V U : Type*} [Fintype V] [Fintype U]
    (e : V≃U) (G : SimpleGraph V) (b : Sym2 V→ℕ) :
    weight (G.map e.toEmbedding) (fun a=>b (Sym2.map e.symm a))=weight G b := by
  rw [weight_eq,weight_eq,edgeFinset_map,Finset.sum_map]
  apply Finset.sum_congr rfl
  intro a _
  change b (Sym2.map e.symm (Sym2.map e a))=b a
  congr 1
  induction a using Sym2.inductionOn with
  | _ u v=>simp only [Sym2.map_mk,Equiv.symm_apply_apply]

/-- The executed list program gives a maximum-capacity forest on the
actual row and column vertices. -/
theorem computed_spec (r : Fin m→ℕ) (c : Fin n→ℕ) (b : Fin m→Fin n→ℕ)
    (W : ℕ) (hW : 1≤W) :
    computed r c b W≤cellGraph (small b W) ∧ (computed r c b W).IsAcyclic ∧
    ∀ F : SimpleGraph (Fin m⊕Fin n),F≤cellGraph (small b W) → F.IsAcyclic →
      weight F (capacity b)≤weight (computed r c b W) (capacity b) := by
  have ht := execute_optimal (graph b W) ⊥ (capacities b)
    (catalog (NetworkVertexCode.data r c b,W)) (catalog_correct r c b W)
    (capacity_positive b W hW) (MaximumForestExchange.bottom_extendible _ _)
  have hzero (d : DecidableRel (⊥ : SimpleGraph (Fin (m+n))).Adj) :
      @graphCode (m+n) ⊥ d=ForestGreedyProgram.emptyGraph (NetworkVertexCode.data r c b,W) := by
    symm
    simp only [ForestGreedyProgram.emptyGraph,vertexCount_code,DirectedBFSCode.range_eq_map,
      ←List.ofFn_eq_map,List.map_ofFn,graphCode]
    apply congrArg List.ofFn
    funext v
    simp [adjacencyRow]
  dsimp only at ht
  rw [hzero] at ht
  change let T:=decoded (ForestGreedyProgram.forest (NetworkVertexCode.data r c b,W));
    T≤graph b W ∧ T.IsAcyclic ∧
      ∀ H,H≤graph b W → H.IsAcyclic → weight H (capacities b)≤weight T (capacities b) at ht
  dsimp only at ht
  let T : SimpleGraph (Fin (m+n)) :=
    decoded (ForestGreedyProgram.forest (NetworkVertexCode.data r c b,W))
  have hback : (T.comap vertexEquiv).map vertexEquiv.toEmbedding=T := by
    rw [←SimpleGraph.comap_symm]
    ext u v
    change T.Adj (vertexEquiv (vertexEquiv.symm u))
      (vertexEquiv (vertexEquiv.symm v)) ↔ T.Adj u v
    simp only [Equiv.apply_symm_apply]
  have hT : T.comap vertexEquiv≤cellGraph (small b W) := by
    intro u v huv
    exact (SimpleGraph.map_adj_apply (G:=cellGraph (small b W))
      (f:=vertexEquiv.toEmbedding) (a:=u) (b:=v)).mp (ht.1 huv)
  refine ⟨hT,ht.2.1.of_comap vertexEquiv.toEmbedding,?_⟩
  intro F hF hac
  have hle : F.map vertexEquiv.toEmbedding≤graph b W := map_monotone _ hF
  have ha : (F.map vertexEquiv.toEmbedding).IsAcyclic :=
    (SimpleGraph.Iso.map vertexEquiv F).isAcyclic_iff.mp hac
  have hw := ht.2.2 (F.map vertexEquiv.toEmbedding) hle ha
  have h1 := weight_transport vertexEquiv F (capacity b)
  have h2 := weight_transport vertexEquiv (T.comap vertexEquiv) (capacity b)
  rw [hback] at h2
  exact h1.symm.trans_le (hw.trans_eq h2)

end ContingencyTables.ComputedLargeForest

end OAI