import OAI.Combinatorics.Hamiltonian.StateDisk

namespace OAI

/-! Oriented triangular faces and positive white-face charges. -/

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

lemma FlowCircuit.proportional (x : E → ℝ) (hx : N.FlowCircuit x)
    (y : E → ℝ) (hy : N.boundary y = 0)
    (hs : N.flowSupport y ⊆ N.flowSupport x) : ∃ c : ℝ, y = c • x := by
  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⟩)
  let c := y e / x e
  let z := y - c • x
  have hz : N.boundary z = 0 := by simp [z,map_sub,map_smul,hy,hx.conserved]
  have hzs : N.flowSupport z ⊆ N.flowSupport x := by
    intro k hk
    by_contra hn
    have hxk : x k = 0 := not_not.mp (by simpa only [mem_flowSupport] using hn)
    have hyk : y k = 0 := by
      by_contra hyk
      exact hn (hs ((N.mem_flowSupport y k).mpr hyk))
    exact (N.mem_flowSupport z k).mp hk (by simp [z,hxk,hyk])
  have hze : z e = 0 := by simp [z,c,div_mul_cancel₀ _ he]
  have hz0 : z = 0 := (hx.minimal z hz hzs).resolve_right (by
    intro hh
    have hem : e ∈ N.flowSupport z := hh ▸ (N.mem_flowSupport x e).mpr he
    exact (N.mem_flowSupport z e).mp hem hze)
  exact ⟨c,sub_eq_zero.mp hz0⟩

omit [Fintype V] [Fintype E] [Fintype F] in
def Triangle.coordinates {s : Finset E} (t : D.Triangle s) : Barnette.CycleCoordinates D.graph where
  n := 0
  vertex := ⟨t.corner,t.corner_injective⟩
  adjacent i := t.clique D (by
    intro hh
    have h1 : (1 : Fin 3) = 0 := add_left_cancel (by simpa using hh.symm : i+1=i+0)
    norm_num at h1)

omit [Fintype V] [Fintype E] [Fintype F] in
lemma Triangle.coordinates_edge (sD : D.Simple) {s : Finset E} (t : D.Triangle s) (i : Fin 3) :
    D.cycleEdge (t.coordinates D) i = t.edge i := by
  apply sD.pair_injective
  exact (D.cycleEdge_ends (t.coordinates D) i).trans (t.edge_ends i).symm

omit [Fintype V] [Fintype E] [Fintype F] in
lemma Triangle.coordinates_edges (sD : D.Simple) {s : Finset E} (t : D.Triangle s) :
    D.cycleEdges (t.coordinates D) = s := by
  have hf : D.cycleEdge (t.coordinates D) = t.edge := funext (t.coordinates_edge D sD)
  change Finset.univ.image (D.cycleEdge (t.coordinates D)) = s
  rw [hf]
  exact t.edge_range

omit [Fintype V] [Fintype E] [Fintype F] in
def Triangle.reverse {s : Finset E} (t : D.Triangle s) : D.Triangle s where
  corner i := t.corner (-i)
  corner_injective := t.corner_injective.comp neg_injective
  edge i := t.edge (-i-1)
  edge_injective := t.edge_injective.comp (by
    intro i j hh
    apply neg_injective
    simpa only [sub_add_cancel] using congrArg (fun k : Fin 3 => k+1) hh)
  edge_range := by
    have hh : Finset.univ.image (fun i : Fin 3 => t.edge (-i-1)) = Finset.univ.image t.edge := by
      ext e
      simp only [Finset.mem_image,Finset.mem_univ,true_and]
      constructor
      · rintro ⟨i,rfl⟩; exact ⟨-i-1,rfl⟩
      · rintro ⟨i,rfl⟩
        refine ⟨-i-1,?_⟩
        congr 1
        abel
    exact hh.trans t.edge_range
  edge_ends i := by
    rw [t.edge_ends]
    have h1 : -i-1+1 = -i := sub_add_cancel _ _
    have h2 : -(i+1) = -i-1 := by abel
    rw [h1,h2,Sym2.eq_swap]

omit [Fintype V] [Fintype E] [Fintype F] in
lemma arcSign_opposite {e : E} {v w : F}
    (hne : v ≠ w) (he : s(D.tail e,D.head e) = s(v,w)) :
    D.arcSign e w = - D.arcSign e v := by
  rcases Sym2.eq_iff.mp he with ⟨ht,hh⟩ | ⟨ht,hh⟩
  · simp [arcSign,ht,hne]
  · simp [arcSign,ht,hne.symm]

omit [Fintype V] [Fintype F] in

theorem oriented_face (h : N.Duality D) (sN : N.Simple) (sD : D.Simple)
    (v : V) (t : D.Triangle (N.star v)) :
    ∃ u : D.Triangle (N.star v), ∀ i,
      N.gradient (fun w => if w = v then 1 else 0) (u.edge i) =
        D.arcSign (u.edge i) (u.corner i) := by
  let x := D.cycleFlow (t.coordinates D)
  let y := N.gradient (fun w => if w = v then 1 else 0)
  have hx := D.cycleFlow_circuit (t.coordinates D) sD
  have hy := h.dual_conserved_gradient N D (fun w => if w = v then 1 else 0)
  have hs : D.flowSupport y = D.flowSupport x := by
    rw [D.cycleFlow_support,t.coordinates_edges D sD]
    exact N.gradient_indicator_support D sN v
  obtain ⟨c,hc⟩ := hx.proportional D x y hy hs.subset
  have hxi (i : Fin 3) : x (t.edge i) = D.arcSign (t.edge i) (t.corner i) := by
    have hh := D.cycleFlow_apply_edge (t.coordinates D) i
    change x (D.cycleEdge (t.coordinates D) i) = D.arcSign (D.cycleEdge (t.coordinates D) i) (t.corner i) at hh
    rw [t.coordinates_edge D sD i] at hh
    exact hh
  have hci (i : Fin 3) : y (t.edge i) = c * D.arcSign (t.edge i) (t.corner i) := by
    rw [hc,Pi.smul_apply,smul_eq_mul,hxi]
  have he : t.edge 0 ∈ N.star v := by
    have hh : t.edge 0 ∈ Finset.univ.image t.edge := Finset.mem_image.mpr ⟨0,Finset.mem_univ _,rfl⟩
    rwa [t.edge_range] at hh
  have hcv : c = 1 ∨ c = -1 := by
    have hh := hci 0
    have hne := sN.loopless (t.edge 0)
    rcases (N.mem_star _ _).mp he with ht | hh'
    · have hhead : N.head (t.edge 0) ≠ v := fun h => hne (ht.trans h.symm)
      simp only [y,gradient_apply,ht,hhead,ite_true,ite_false,zero_sub] at hh
      by_cases hd : D.tail (t.edge 0) = t.corner 0 <;> simp [arcSign,hd] at hh <;> first | exact Or.inl (by linarith) | exact Or.inr (by linarith)
    · have htail : N.tail (t.edge 0) ≠ v := fun h => hne (h.trans hh'.symm)
      simp only [y,gradient_apply,hh',htail,ite_true,ite_false,sub_zero] at hh
      by_cases hd : D.tail (t.edge 0) = t.corner 0 <;> simp [arcSign,hd] at hh <;> first | exact Or.inl (by linarith) | exact Or.inr (by linarith)
  rcases hcv with rfl | rfl
  · exact ⟨t,fun i => by simpa only [one_mul] using hci i⟩
  · refine ⟨t.reverse D,?_⟩
    intro i
    change y (t.edge (-i-1)) = D.arcSign (t.edge (-i-1)) (t.corner (-i))
    have hh := hci (-i-1)
    have ha := D.arcSign_opposite ((t.coordinates D).adjacent (-i-1 : Fin 3)).ne (t.edge_ends (-i-1))
    change D.arcSign (t.edge (-i-1)) (t.corner (-i-1+1)) =
      - D.arcSign (t.edge (-i-1)) (t.corner (-i-1)) at ha
    rw [sub_add_cancel] at ha
    rw [ha]
    simpa only [neg_one_mul] using hh

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)

lemma boundary_of_sum_zero (h : N.graph.Connected) (b : V → ℝ)
    (hb : ∑ v, b v = 0) : ∃ x, N.boundary x = b := by
  let q : V → Unit := fun _ => ()
  have hq : Function.Surjective q := by
    obtain ⟨v⟩ := h.nonempty
    intro u
    exact ⟨v,Subsingleton.elim _ _⟩
  have hg : (N.restrict (Subtype.val : N.internal q → E)).graph = N.graph := by
    ext v w
    constructor
    · rintro ⟨hne,e,he⟩
      exact ⟨hne,e.val,he⟩
    · rintro ⟨hne,e,he⟩
      exact ⟨hne,⟨e,rfl⟩,he⟩
  have hc : N.ConnectedFibers q := by
    intro v w _
    rw [hg]
    exact h v w
  have hz : push q b = 0 := by
    ext u
    cases u
    simpa [push,q] using hb
  have hm : b ∈ (N.restrict (Subtype.val : N.internal q → E)).boundary.range := by
    rw [N.range_internal_boundary hq hc]
    exact hz
  obtain ⟨x,hx⟩ := hm
  refine ⟨push (Subtype.val : N.internal q → E) x,?_⟩
  rw [← boundary_restrict,hx]

def whiteCharge (black : V → Prop) (root : V) : V → ℝ := fun v =>
  (if black v then 0 else 1) -
    (if v = root then ((Finset.univ.filter fun w => ¬black w).card : ℝ) else 0)

lemma whiteCharge_sum (black : V → Prop) (root : V) :
    ∑ v, whiteCharge black root v = 0 := by
  simp only [whiteCharge,Finset.sum_sub_distrib,Finset.sum_ite_eq',Finset.mem_univ,ite_true]
  rw [show (fun v => if black v then (0:ℝ) else 1) =
    (fun v => if ¬black v then 1 else 0) by ext v; by_cases hv : black v <;> simp [hv]]
  rw [Finset.sum_boole,sub_self]

lemma whiteCharge_black (black : V → Prop) (root v : V)
    (hv : black v) (hvr : v ≠ root) : whiteCharge black root v = 0 := by
  simp [whiteCharge,hv,hvr]

lemma whiteCharge_inside (black : V → Prop) (root : V) (A : Finset V)
    (hr : root ∉ A) :
    ∑ v ∈ A, whiteCharge black root v = ((A.filter fun v => ¬black v).card : ℝ) := by
  trans ∑ v ∈ A, if ¬black v then (1:ℝ) else 0
  · apply Finset.sum_congr rfl
    intro v hv
    have hvr : v ≠ root := fun hh => hr (hh ▸ hv)
    by_cases hb : black v <;> simp [whiteCharge,hb,hvr]
  · exact Finset.sum_boole _ _

lemma whiteCharge_cut_integral (black : V → Prop) (root : V) (A : Finset V)
    (hr : root ∉ A) (α : E → ℝ) (hα : N.boundary α = whiteCharge black root)
    (c : ℝ) (x : E → ℝ)
    (hx : x = c • N.gradient (fun v => if v ∈ A then 1 else 0)) :
    ∑ e, α e * x e = c * ((A.filter fun v => ¬black v).card : ℝ) := by
  simp only [hx,Pi.smul_apply,smul_eq_mul]
  have hh : ∑ e, α e * (c * N.gradient (fun v => if v ∈ A then 1 else 0) e) =
      c * ∑ e, α e * N.gradient (fun v => if v ∈ A then 1 else 0) e := by
    rw [Finset.mul_sum]
    apply Finset.sum_congr rfl
    intro e _
    ring
  rw [hh,← N.boundary_adjoint,hα]
  congr 1
  simp only [mul_ite,mul_one,mul_zero]
  rw [← Finset.sum_filter]
  simpa only [Finset.filter_mem_eq_inter,Finset.univ_inter] using whiteCharge_inside black root A hr

omit [Fintype V] [Fintype F] in
lemma white_positive_of_boundary (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) (A : Finset V)
    (hcount : (N.cut A).card = 2 * (N.blackCut black A).card + 3) :
    0 < (A.filter fun v => ¬black v).card := by
  by_contra hn
  have hz : (A.filter fun v => ¬black v) = ∅ := Finset.card_eq_zero.mp (by omega)
  have hb : ∀ v ∈ A, black v := by
    intro v hv
    by_contra hnv
    have hh : v ∈ A.filter (fun v => ¬black v) := Finset.mem_filter.mpr ⟨hv,hnv⟩
    rw [hz] at hh
    exact Finset.notMem_empty _ hh
  have hEq : N.blackCut black A = N.cut A := by
    apply Finset.filter_eq_self.mpr
    intro e he
    rcases (N.mem_cut A e).mp he with ht | hh
    · rw [N.blackEndpoint_eq black hc (hb _ ht.1) (Or.inl rfl)]
      exact ht.1
    · rw [N.blackEndpoint_eq black hc (hb _ hh.1) (Or.inr rfl)]
      exact hh.1
  rw [hEq] at hcount
  omega

end
end Barnette.Network

end OAI