import OAI.Combinatorics.Hamiltonian.CutSpaces

namespace OAI

/-! Minimal flow circuits, triangular faces, and simple cycle coordinates. -/

namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V E F : Type*} [Fintype V] [Fintype E] [Fintype F]
  (N : Network V E) (D : Network F E)

structure FlowCircuit (x : E → ℝ) : Prop where
  conserved : N.boundary x = 0
  nonzero : x ≠ 0
  minimal : ∀ y, N.boundary y = 0 → N.flowSupport y ⊆ N.flowSupport x →
    y = 0 ∨ N.flowSupport y = N.flowSupport x

omit [Fintype V] in
lemma flowSupport_eq_empty_iff (x : E → ℝ) : N.flowSupport x = ∅ ↔ x = 0 := by
  simp only [Finset.eq_empty_iff_forall_notMem, mem_flowSupport, not_not,
    funext_iff, Pi.zero_apply]

omit [Fintype V] [Fintype F] in
lemma Duality.dual_conserved_gradient (h : N.Duality D) (f : V → ℝ) :
    D.boundary (N.gradient f) = 0 := by
  have hh : N.gradient f ∈ N.gradient.range := ⟨f,rfl⟩
  rwa [← h.dual_cycles_eq_cuts] at hh

omit [Fintype V] [Fintype F] in
lemma Duality.gradient_of_dual_conserved (h : N.Duality D) {x : E → ℝ}
    (hx : D.boundary x = 0) : ∃ f, N.gradient f = x := by
  have hh : x ∈ D.boundary.ker := hx
  rwa [h.dual_cycles_eq_cuts] at hh

omit [Fintype V] [Fintype F] in

theorem Duality.circuit_two_levels (h : N.Duality D) (x : E → ℝ)
    (hx : D.FlowCircuit x) (f : V → ℝ) (hf : N.gradient f = x)
    {e : E} (he : x e ≠ 0) :
    ∀ v, f v = f (N.tail e) ∨ f v = f (N.head e) := by
  have he' : f (N.head e) ≠ f (N.tail e) := by
    simpa only [← hf, gradient_apply, sub_ne_zero] using he
  intro v
  by_contra hv
  obtain ⟨hvt,hvh⟩ := not_or.mp hv
  let g : V → ℝ := fun w => if f w = f v then 1 else 0
  have hgsub : D.flowSupport (N.gradient g) ⊆ D.flowSupport x := by
    intro k hk
    apply (D.mem_flowSupport x k).mpr
    intro hxk
    have hfk : f (N.head k) = f (N.tail k) := by
      apply sub_eq_zero.mp
      simpa only [← hf, gradient_apply] using hxk
    have hgk : N.gradient g k = 0 := by simp only [gradient_apply, g, hfk, sub_self]
    exact (D.mem_flowSupport _ k).mp hk hgk
  have hg : N.gradient g ≠ 0 := by
    intro hg
    have hh := N.gradient_zero_reachable hg (h.connected v (N.tail e))
    have htv : f (N.tail e) ≠ f v := Ne.symm hvt
    norm_num [g,htv] at hh
  have hgs := (hx.minimal (N.gradient g) (h.dual_conserved_gradient N D g) hgsub).resolve_left hg
  have hek : N.gradient g e ≠ 0 := (D.mem_flowSupport _ e).mp (by
    rw [hgs]; exact (D.mem_flowSupport _ e).mpr he)
  have htv : f (N.tail e) ≠ f v := Ne.symm hvt
  have hhv : f (N.head e) ≠ f v := Ne.symm hvh
  exact hek (by simp [gradient_apply, g, htv, hhv])

omit [Fintype F] in

theorem Duality.circuit_cut (h : N.Duality D) (x : E → ℝ)
    (hx : D.FlowCircuit x) (root : V) :
    ∃ (A : Finset V) (c : ℝ), A.Nonempty ∧ root ∉ A ∧ c ≠ 0 ∧
      x = c • N.gradient (fun v => if v ∈ A then 1 else 0) ∧
      N.cut A = D.flowSupport x := by
  obtain ⟨f,hf⟩ := h.gradient_of_dual_conserved N D hx.conserved
  obtain ⟨e,he⟩ : ∃ e, x e ≠ 0 := by
    by_contra hn
    apply hx.nonzero
    ext e
    exact not_not.mp (fun he => hn ⟨e,he⟩)
  have he' : f (N.head e) ≠ f (N.tail e) := by
    simpa only [← hf, gradient_apply, sub_ne_zero] using he
  have hall := h.circuit_two_levels N D x hx f hf he
  let a := f root
  let b := if a = f (N.tail e) then f (N.head e) else f (N.tail e)
  have hab : b ≠ a := by
    dsimp [b,a]
    split_ifs with ha
    · rw [ha]; exact he'
    · exact Ne.symm ha
  have hlevels (v : V) : f v = a ∨ f v = b := by
    dsimp [b,a] at ⊢
    rcases hall root with ht | hh
    · rw [ite_eq_left ht,ht]; exact hall v
    · have ht : f root ≠ f (N.tail e) := hh ▸ he'
      rw [ite_eq_right ht,hh]
      exact (hall v).symm
  have hb : ∃ v, f v = b := by
    dsimp [b]
    split_ifs
    · exact ⟨N.head e,rfl⟩
    · exact ⟨N.tail e,rfl⟩
  let A := Finset.univ.filter fun v => f v = b
  have fform (v : V) : f v = a + (b-a) * (if v ∈ A then 1 else 0) := by
    rcases hlevels v with hv | hv
    · have hvA : v ∉ A := by simp [A,hv,Ne.symm hab]
      simp [hvA,hv]
    · have hvA : v ∈ A := by simp [A,hv]
      simp [hvA,hv]
  refine ⟨A,b-a,?_,?_,sub_ne_zero.mpr hab,?_,?_⟩
  · obtain ⟨v,hv⟩ := hb; exact ⟨v,by simp [A,hv]⟩
  · simp [A,show f root = a from rfl, Ne.symm hab]
  · rw [← hf]
    ext k
    simp only [gradient_apply, Pi.smul_apply, smul_eq_mul]
    rw [fform (N.head k), fform (N.tail k)]
    ring
  · ext k
    simp only [mem_cut, mem_flowSupport, ← hf, gradient_apply, sub_ne_zero]
    rw [fform (N.head k), fform (N.tail k)]
    by_cases ht : N.tail k ∈ A <;> by_cases hh : N.head k ∈ A <;>
      simp [ht,hh,hab,Ne.symm hab]

end
end Barnette.Network
namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V E F : Type*} [Fintype V] [Fintype E] [Fintype F]
  (N : Network V E) (D : Network F E)

omit [Fintype V] in
def star (v : V) : Finset E := Finset.univ.filter fun e => N.Incident e v

omit [Fintype V] in
@[simp] lemma mem_star (e : E) (v : V) : e ∈ N.star v ↔ N.Incident e v := by
  simp [star]

omit [Fintype V] in
def otherEnd (e : E) (v : V) : V := if N.tail e = v then N.head e else N.tail e

omit [Fintype V] [Fintype E] in
lemma otherEnd_spec (h : N.Simple) {e : E} {v : V} (hi : N.Incident e v) :
    v ≠ N.otherEnd e v ∧ s(N.tail e,N.head e) = s(v,N.otherEnd e v) := by
  rcases hi with ht | hh
  · rw [otherEnd,ite_eq_left ht]
    exact ⟨ht ▸ h.loopless e, by rw [ht]⟩
  · by_cases ht : N.tail e = v
    · exact (h.loopless e (ht.trans hh.symm)).elim
    · rw [otherEnd,ite_eq_right ht]
      exact ⟨hh ▸ (h.loopless e).symm, by rw [hh,Sym2.eq_swap]⟩

omit [Fintype V] [Fintype E] in
lemma otherEnd_adj (h : N.Simple) {e : E} {v : V} (hi : N.Incident e v) :
    N.graph.Adj v (N.otherEnd e v) := by
  obtain ⟨hne,he⟩ := N.otherEnd_spec h hi
  exact ⟨hne,e,Sym2.eq_iff.mp he⟩

lemma card_star (h : N.Simple) (v : V) : (N.star v).card = N.graph.degree v := by
  let f : {e // e ∈ N.star v} → N.graph.neighborSet v := fun e =>
    ⟨N.otherEnd e.val v, N.otherEnd_adj h ((N.mem_star _ _).mp e.property)⟩
  have hf : Function.Bijective f := by
    constructor
    · intro e k hek
      apply Subtype.ext
      apply h.pair_injective
      change s(N.tail e.val, N.head e.val) = s(N.tail k.val, N.head k.val)
      rw [(N.otherEnd_spec h ((N.mem_star _ _).mp e.property)).2,
        (N.otherEnd_spec h ((N.mem_star _ _).mp k.property)).2]
      exact congrArg (fun w => s(v,w)) (congrArg Subtype.val hek)
    · intro w
      obtain ⟨hne,e,he⟩ := w.property
      have hi : N.Incident e v := he.elim (fun h => Or.inl h.1) (fun h => Or.inr h.2)
      refine ⟨⟨e,(N.mem_star _ _).mpr hi⟩,Subtype.ext ?_⟩
      change N.otherEnd e v = w.val
      rcases he with ⟨ht,hh⟩ | ⟨ht,hh⟩
      · simp only [otherEnd,ht,ite_true,hh]
      · have ht' : N.tail e ≠ v := by rw [ht]; exact hne.symm
        rw [otherEnd,ite_eq_right ht',ht]
  have hh := Fintype.card_congr (Equiv.ofBijective f hf)
  simpa only [Fintype.card_coe, SimpleGraph.card_neighborSet_eq_degree] using hh

omit [Fintype V] [Fintype F] in
lemma gradient_indicator_support (h : N.Simple) (v : V) :
    D.flowSupport (N.gradient (fun w => if w = v then 1 else 0)) = N.star v := by
  ext e
  simp only [mem_flowSupport, mem_star, gradient_apply, Incident]
  have hne := h.loopless e
  by_cases ht : N.tail e = v <;> by_cases hh : N.head e = v <;> simp [ht,hh] at *

omit [Fintype F] in

theorem Duality.cubic_face_triangles (h : N.Duality D) (hN : N.Simple)
    (h3 : ThreeVertexConnected N.graph) (hV : 5 ≤ Fintype.card V)
    (hc : N.graph.IsRegularOfDegree 3) : ∀ v, Nonempty (D.Triangle (N.star v)) := by
  intro v
  have hD := h.simple_dual N D h3 hV
  have hx := h.dual_conserved_gradient N D (fun w => if w = v then 1 else 0)
  have hs : (D.flowSupport (N.gradient (fun w => if w = v then 1 else 0))).card = 3 := by
    rw [N.gradient_indicator_support D hN, N.card_star hN, hc v]
  simpa only [N.gradient_indicator_support D hN] using D.triangle_of_flow hD _ hx hs

end
end Barnette.Network
namespace Barnette

open Fin.NatCast

theorem cyclic_propagation {n : ℕ} [NeZero n] (P : Fin n → Prop)
    (hstep : ∀ i, P (i + 1) → P i) {q : Fin n} (hq : P q) : ∀ i, P i := by
  have h : ∀ k : ℕ, P (q - (k : Fin n)) := by
    intro k
    induction k with
    | zero => simpa using hq
    | succ k hk =>
      apply hstep (q - ((k + 1 : ℕ) : Fin n))
      simpa only [Nat.cast_add, Nat.cast_one, sub_add_eq_sub_sub, sub_add_cancel] using hk
  intro i
  simpa only [Fin.cast_val_eq_self, sub_sub_cancel] using h (q - i).val

theorem cyclic_one_ne_zero (n : ℕ) : (1 : Fin (n + 3)) ≠ 0 := by
  intro h
  have := congrArg Fin.val h
  simp at this

theorem cyclic_two_ne_zero (n : ℕ) : (2 : Fin (n + 3)) ≠ 0 := by
  intro h
  have := congrArg Fin.val h
  simp [Nat.mod_eq_of_lt (show 2 < n + 3 by omega)] at this

structure CycleCoordinates {V : Type*} (G : SimpleGraph V) where
  n : ℕ
  vertex : Fin (n + 3) ↪ V
  adjacent : ∀ i, G.Adj (vertex i) (vertex (i + 1))

namespace CycleCoordinates

variable {V : Type*} {G : SimpleGraph V} (C : CycleCoordinates G)

theorem edge_indices_unique (i j : Fin (C.n + 3))
    (h : (C.vertex i = C.vertex j ∧ C.vertex (i + 1) = C.vertex (j + 1)) ∨
      (C.vertex i = C.vertex (j + 1) ∧ C.vertex (i + 1) = C.vertex j)) : i = j := by
  rcases h with h | h
  · exact C.vertex.injective h.1
  · have hi := C.vertex.injective h.1
    have hj := C.vertex.injective h.2
    have hh : (2 : Fin (C.n + 3)) = 0 := by
      have : j + (1 + 1) = j + 0 := by simpa [hi, add_assoc] using hj
      simpa only [show (1 : Fin (C.n + 3)) + 1 = 2 by
        apply Fin.ext
        simp [Fin.val_add, Nat.mod_eq_of_lt (show 2 < C.n + 3 by omega)]] using (add_left_cancel this)
    exact (cyclic_two_ne_zero C.n hh).elim

theorem tail_orientation {A : Type*} (face : Fin (C.n + 3) ↪ A)
    (tail : A → V) (htail : Function.Injective tail)
    (hend : ∀ i, tail (face i) = C.vertex i ∨ tail (face i) = C.vertex (i + 1)) :
    (∀ i, tail (face i) = C.vertex i) ∨
      (∀ i, tail (face i) = C.vertex (i + 1)) := by
  classical
  by_cases h : ∃ q, tail (face q) = C.vertex q
  · obtain ⟨q, hq⟩ := h
    left
    apply cyclic_propagation (fun i => tail (face i) = C.vertex i) _ hq
    intro i hi
    rcases hend i with h | h
    · exact h
    · have heq : face i = face (i + 1) := htail (h.trans hi.symm)
      have hi1 := face.injective heq
      have hbad : (1 : Fin (C.n + 3)) = 0 := by
        exact add_left_cancel (by simpa using hi1.symm : i + 1 = i + 0)
      exact (cyclic_one_ne_zero C.n hbad).elim
  · right
    intro i
    exact (hend i).resolve_left (fun hi => h ⟨i, hi⟩)

end CycleCoordinates
end Barnette

namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V E : Type*} [Fintype V] [Fintype E]
  (N : Network V E) (C : Barnette.CycleCoordinates N.graph)

omit [Fintype V] [Fintype E] in
def cycleEdge (i : Fin (C.n+3)) : E := (C.adjacent i).2.choose

omit [Fintype V] [Fintype E] in
lemma cycleEdge_ends (i : Fin (C.n+3)) :
    s(N.tail (N.cycleEdge C i),N.head (N.cycleEdge C i)) = s(C.vertex i,C.vertex (i+1)) :=
  Sym2.eq_iff.mpr (C.adjacent i).2.choose_spec

omit [Fintype V] [Fintype E] in
lemma cycleEdge_injective : Function.Injective (N.cycleEdge C) := by
  intro i j hij
  apply C.edge_indices_unique i j
  apply Sym2.eq_iff.mp
  rw [← N.cycleEdge_ends C i, ← N.cycleEdge_ends C j, hij]

omit [Fintype V] [Fintype E] in
lemma cycleEdge_incident (i : Fin (C.n+3)) (v : V) :
    N.Incident (N.cycleEdge C i) v ↔ v = C.vertex i ∨ v = C.vertex (i+1) := by
  rw [N.incident_iff_mem_pair, N.cycleEdge_ends]
  exact Sym2.mem_iff

omit [Fintype V] [Fintype E] in
def cycleEdges : Finset E := Finset.univ.image (N.cycleEdge C)

omit [Fintype V] [Fintype E] in
@[simp] lemma mem_cycleEdges (e : E) : e ∈ N.cycleEdges C ↔ ∃ i, N.cycleEdge C i = e := by
  simp [cycleEdges]

omit [Fintype V] in

lemma cycle_support_minimal (hN : N.Simple) (y : E → ℝ) (hy : N.boundary y = 0)
    (hsub : N.flowSupport y ⊆ N.cycleEdges C) (hne : y ≠ 0) :
    N.flowSupport y = N.cycleEdges C := by
  have hs : (N.flowSupport y).Nonempty := Finset.nonempty_iff_ne_empty.mpr (by
    exact fun h => hne ((N.flowSupport_eq_empty_iff y).mp h))
  obtain ⟨e,he⟩ := hs
  obtain ⟨q,hq⟩ := (N.mem_cycleEdges C e).mp (hsub he)
  have hq' : y (N.cycleEdge C q) ≠ 0 := by rw [hq]; exact (N.mem_flowSupport _ _).mp he
  have hall : ∀ i, y (N.cycleEdge C i) ≠ 0 := by
    apply Barnette.cyclic_propagation (fun i => y (N.cycleEdge C i) ≠ 0) _ hq'
    intro i hi
    have hv : N.Incident (N.cycleEdge C (i+1)) (C.vertex (i+1)) :=
      (N.cycleEdge_incident C _ _).mpr (Or.inl rfl)
    obtain ⟨f,hfe,hyf,hfv⟩ := N.flow_no_leaf hN y hy hi hv
    obtain ⟨j,rfl⟩ := (N.mem_cycleEdges C f).mp (hsub ((N.mem_flowSupport y f).mpr hyf))
    rcases (N.cycleEdge_incident C j _).mp hfv with hj | hj
    · have hj' := C.vertex.injective hj
      exact (hfe (congrArg (N.cycleEdge C) hj'.symm)).elim
    · have hj' := add_right_cancel (C.vertex.injective hj)
      simpa only [← hj'] using hyf
  apply Finset.Subset.antisymm hsub
  intro e he
  obtain ⟨i,rfl⟩ := (N.mem_cycleEdges C e).mp he
  exact (N.mem_flowSupport y _).mpr (hall i)

omit [Fintype V] in
lemma flowCircuit_of_cycle (hN : N.Simple) (x : E → ℝ)
    (hx : N.boundary x = 0) (hs : N.flowSupport x = N.cycleEdges C) : N.FlowCircuit x := by
  have hcs : (N.cycleEdges C).Nonempty := ⟨N.cycleEdge C 0, by simp⟩
  refine ⟨hx,?_,?_⟩
  · intro hz; subst x
    have he := (N.flowSupport_eq_empty_iff 0).mpr rfl
    rw [he] at hs
    exact hcs.ne_empty hs.symm
  · intro y hy hsub
    by_cases hzero : y = 0
    · exact Or.inl hzero
    · right
      rw [hs] at hsub ⊢
      exact N.cycle_support_minimal C hN y hy hsub hzero

end
end Barnette.Network

end OAI