import OAI.Combinatorics.Hamiltonian.DiskRegions

namespace OAI

/-! Minimal links, incidence states, and the signed disk identity. -/

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] [Fintype F] in
lemma Duality.symm (h : N.Duality D) : D.Duality N :=
  ⟨h.dual_connected,h.connected,h.dual_cycles_eq_cuts,h.cycles_eq_cuts⟩

omit [Fintype V] [Fintype F] in

lemma Duality.vertex_flow_circuit (h : N.Duality D) (z : F)
    (hz : (D.graph.induce {v | v ≠ z}).Connected) :
    N.FlowCircuit (D.gradient (fun w => if w = z then 1 else 0)) := by
  obtain ⟨r⟩ := hz.nonempty
  let x := D.gradient (fun w => if w = z then (1:ℝ) else 0)
  have hx : N.boundary x = 0 := (h.symm N D).dual_conserved_gradient D N _
  have hn : x ≠ 0 := by
    intro he
    have hh := D.gradient_zero_reachable he (h.dual_connected z r.val)
    norm_num at hh
    exact r.property hh
  refine ⟨hx,hn,?_⟩
  intro y hy hs
  by_cases hy0 : y = 0
  · exact Or.inl hy0
  right
  obtain ⟨f,hf⟩ := (h.symm N D).gradient_of_dual_conserved D N hy
  have fstep {v w : {v // v ≠ z}}
      (hvw : (D.graph.induce {v | v ≠ z}).Adj v w) : f v.val = f w.val := by
    obtain ⟨_,e,he⟩ := hvw
    have hxe : x e = 0 := by
      dsimp only [x,gradient_apply]
      rcases he with he | he <;> rw [he.1,he.2] <;> simp [v.property,w.property]
    have hye : y e = 0 := by
      by_contra he
      exact (N.mem_flowSupport x e).mp (hs ((N.mem_flowSupport y e).mpr he)) hxe
    have heq := congrFun hf e
    rw [hye,gradient_apply,sub_eq_zero] at heq
    exact he.elim (fun he => by rw [he.1,he.2] at heq; exact heq.symm)
      (fun he => by rwa [he.1,he.2] at heq)
  have fconstant (v : {v // v ≠ z}) : f v.val = f r.val := by
    obtain ⟨p⟩ := hz v r
    induction p with
    | nil => rfl
    | cons h p ih => exact (fstep h).trans ih
  have hne : f z ≠ f r.val := by
    intro he
    apply hy0
    rw [← hf]
    apply (D.gradient_eq_zero_iff f).mpr
    have hall (v : F) : f v = f r.val := by
      by_cases hv : v = z
      · rwa [hv]
      · exact fconstant ⟨v,hv⟩
    intro e
    exact (hall _).trans (hall _).symm
  apply Finset.Subset.antisymm hs
  intro e he
  apply (N.mem_flowSupport y e).mpr
  rw [← hf,gradient_apply]
  have hxe := (N.mem_flowSupport x e).mp he
  dsimp only [x,gradient_apply] at hxe
  by_cases ht : D.tail e = z <;> by_cases hh : D.head e = z
  · simp [ht,hh] at hxe
  · rw [ht,fconstant ⟨D.head e,hh⟩]
    exact sub_ne_zero.mpr hne.symm
  · rw [hh,fconstant ⟨D.tail e,ht⟩]
    exact sub_ne_zero.mpr hne
  · simp [ht,hh] at hxe

omit [Fintype V] in

lemma cut_restrict_conserved (x : E → ℝ) (hx : N.boundary x = 0) (A : Finset V)
    (hcut : ∀ e ∈ N.cut A, x e = 0) :
    N.boundary (fun e => if N.tail e ∈ A then x e else 0) = 0 := by
  ext v
  have hb : N.boundary (fun e => if N.tail e ∈ A then x e else 0) v =
      if v ∈ A then N.boundary x v else 0 := by
    simp only [boundary_apply]
    trans ∑ e, if v ∈ A then
      ((if N.head e = v then x e else 0) - (if N.tail e = v then x e else 0)) else 0
    swap
    · by_cases hv : v ∈ A <;> simp [hv]
    apply Finset.sum_congr rfl
    intro e _
    have hcross : N.tail e ∈ A ∨ N.head e ∈ A →
        ¬(N.tail e ∈ A ∧ N.head e ∈ A) → x e = 0 := by
      intro h1 h2
      apply hcut e
      rw [N.mem_cut]
      tauto
    by_cases ht : N.tail e = v <;> by_cases hh : N.head e = v <;>
      by_cases ha : N.tail e ∈ A <;> by_cases hb : N.head e ∈ A <;>
      by_cases hv : v ∈ A <;> simp_all
  rw [hb,hx]
  simp

omit [Fintype V] in

lemma FlowCircuit.no_split (x : E → ℝ) (hx : N.FlowCircuit x) (A : Finset V)
    (hcut : ∀ e ∈ N.cut A, x e = 0)
    {e : E} (he : x e ≠ 0) (heA : N.tail e ∈ A) :
    ∀ k, x k ≠ 0 → N.tail k ∈ A := by
  let y : E → ℝ := fun k => if N.tail k ∈ A then x k else 0
  have hy := N.cut_restrict_conserved x hx.conserved A hcut
  have hs : N.flowSupport y ⊆ N.flowSupport x := by
    intro k hk
    simp only [mem_flowSupport,y] at hk ⊢
    split_ifs at hk <;> tauto
  have hyn : y ≠ 0 := by
    intro hy0
    have hh := congrFun hy0 e
    apply he
    simpa [y,heA] using hh
  have hEq := (hx.minimal y hy hs).resolve_left hyn
  intro k hk
  have hyk := (N.mem_flowSupport y k).mp (by rw [hEq]; exact (N.mem_flowSupport x k).mpr hk)
  by_contra hn
  exact hyk (by simp [y,hn])

theorem mixed_corner_on_boundary (h : N.Duality D) (sD : D.Simple)
    (face : ∀ v, D.Triangle (N.star v)) (A : Finset V) {z : F}
    (hzin : z ∈ N.regionVertices D A) (hzout : z ∈ N.regionVertices D Aᶜ) :
    ∃ e ∈ N.cut A, D.Incident e z := by
  by_contra hn
  have hc := h.vertex_flow_circuit N D z
    (faces_vertex_deleted_connected N D h.connected h.dual_connected sD face z)
  let x := D.gradient (fun w => if w = z then (1:ℝ) else 0)
  have hs : N.flowSupport x = D.star z := D.gradient_indicator_support N sD z
  have hcut : ∀ e ∈ N.cut A, x e = 0 := by
    intro e he
    by_contra hx
    have hh : D.Incident e z := (D.mem_star e z).mp (by
      rw [← hs]; exact (N.mem_flowSupport x e).mpr hx)
    exact hn ⟨e,he,hh⟩
  obtain ⟨e,he,hez⟩ := (N.mem_regionVertices D A z).mp hzin
  have hex : x e ≠ 0 := (N.mem_flowSupport x e).mp (by rw [hs]; exact (D.mem_star e z).mpr hez)
  have heA : N.tail e ∈ A := by
    rcases (N.mem_regionEdges A e).mp he with ht | hh
    · exact ht
    · by_contra ht
      exact hex (hcut e ((N.mem_cut A e).mpr (Or.inr ⟨hh,ht⟩)))
  have hall := hc.no_split N x A hcut hex heA
  obtain ⟨k,hk,hkz⟩ := (N.mem_regionVertices D Aᶜ z).mp hzout
  have hkx : x k ≠ 0 := (N.mem_flowSupport x k).mp (by rw [hs]; exact (D.mem_star k z).mpr hkz)
  have hkA := hall k hkx
  rcases (N.mem_regionEdges Aᶜ k).mp hk with ht | hh
  · exact (Finset.mem_compl.mp ht) hkA
  · exact hkx (hcut k ((N.mem_cut A k).mpr (Or.inl ⟨hkA,Finset.mem_compl.mp 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)

omit [Fintype V] [Fintype E] in
def cycleVertices (C : Barnette.CycleCoordinates D.graph) : Finset F :=
  Finset.univ.image C.vertex

omit [Fintype V] [Fintype E] [Fintype F] in
lemma mem_cycleVertices (C : Barnette.CycleCoordinates D.graph) (z : F) :
    z ∈ D.cycleVertices C ↔ ∃ i, C.vertex i = z := by
  simp [cycleVertices]

omit [Fintype V] [Fintype E] [Fintype F] in
lemma incident_cycle_iff (C : Barnette.CycleCoordinates D.graph) (z : F) :
    (∃ e ∈ D.cycleEdges C, D.Incident e z) ↔ z ∈ D.cycleVertices C := by
  constructor
  · rintro ⟨e,he,hz⟩
    obtain ⟨i,rfl⟩ := (D.mem_cycleEdges C e).mp he
    rw [D.incident_iff_mem_pair,D.cycleEdge_ends,Sym2.mem_iff] at hz
    rcases hz with rfl | rfl
    · exact (D.mem_cycleVertices C _).mpr ⟨i,rfl⟩
    · exact (D.mem_cycleVertices C _).mpr ⟨i+1,rfl⟩
  · intro hz
    obtain ⟨i,rfl⟩ := (D.mem_cycleVertices C z).mp hz
    refine ⟨D.cycleEdge C i,(D.mem_cycleEdges C _).mpr ⟨i,rfl⟩,?_⟩
    rw [D.incident_iff_mem_pair,D.cycleEdge_ends]; simp

omit [Fintype V] in
lemma regionVertices_iff_face (face : ∀ v, D.Triangle (N.star v))
    (A : Finset V) (z : F) :
    z ∈ N.regionVertices D A ↔ ∃ v ∈ A, z ∈ Set.range (face v).corner := by
  constructor
  · intro hz
    obtain ⟨e,he,hez⟩ := (N.mem_regionVertices D A z).mp hz
    rcases (N.mem_regionEdges A e).mp he with ht | hh
    · exact ⟨N.tail e,ht,((face _).corner_iff_incident D z).mpr
        ⟨e,(N.mem_star e _).mpr (Or.inl rfl),hez⟩⟩
    · exact ⟨N.head e,hh,((face _).corner_iff_incident D z).mpr
        ⟨e,(N.mem_star e _).mpr (Or.inr rfl),hez⟩⟩
  · rintro ⟨v,hv,hz⟩
    obtain ⟨e,he,hez⟩ := ((face v).corner_iff_incident D z).mp hz
    refine (N.mem_regionVertices D A z).mpr ⟨e,?_,hez⟩
    rcases (N.mem_star e v).mp he with ht | hh
    · exact (N.mem_regionEdges A e).mpr (Or.inl (ht ▸ hv))
    · exact (N.mem_regionEdges A e).mpr (Or.inr (hh ▸ hv))

omit [Fintype V] [Fintype E] [Fintype F] in
def blackEndpoint (black : V → Prop) (e : E) : V :=
  if black (N.tail e) then N.tail e else N.head e

omit [Fintype V] [Fintype E] [Fintype F] in
lemma blackEndpoint_spec (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) (e : E) :
    black (N.blackEndpoint black e) ∧ N.Incident e (N.blackEndpoint black e) := by
  by_cases ht : black (N.tail e)
  · simp only [blackEndpoint,ite_eq_left ht]; exact ⟨ht,Or.inl rfl⟩
  · simp only [blackEndpoint,ite_eq_right ht]
    exact ⟨not_not.mp (fun hh => ht ((hc e).mpr hh)),Or.inr rfl⟩

omit [Fintype V] [Fintype E] [Fintype F] in
lemma blackEndpoint_eq (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    {e : E} {v : V} (hv : black v) (he : N.Incident e v) :
    N.blackEndpoint black e = v := by
  rcases he with ht | hh
  · simp [blackEndpoint,ht,hv]
  · have hnt : ¬black (N.tail e) := fun ht => (hc e).mp ht (hh ▸ hv)
    simp [blackEndpoint,hnt,hh]

omit [Fintype V] [Fintype F] in
def blackCut (black : V → Prop) (A : Finset V) : Finset E :=
  (N.cut A).filter fun e => N.blackEndpoint black e ∈ A

omit [Fintype F] in
lemma cubic_black_region_count (sN : N.Simple) (hdeg : N.graph.IsRegularOfDegree 3)
    (black : V → Prop) (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (A : Finset V) :
    3 * (A.filter black).card + (N.cut A).card =
      (N.regionEdges A).card + (N.blackCut black A).card := by
  have hs := N.sum_stars sN (A.filter black)
  have hd : ∀ v, N.graph.degree v = 3 := hdeg
  have hh : (∑ v ∈ A.filter black, (N.star v).card) = 3 * (A.filter black).card := by
    simp only [N.card_star sN,hd]
    simp [Nat.mul_comm]
  rw [hh] at hs
  rw [hs]
  simp only [cut,regionEdges,blackCut,Finset.card_filter,Finset.mem_filter,
    Finset.sum_filter,← Finset.sum_add_distrib]
  apply Finset.sum_congr rfl
  intro e _
  have hcol := hc e
  by_cases ht : N.tail e ∈ A <;> by_cases hh : N.head e ∈ A <;>
    by_cases hb : black (N.tail e) <;> by_cases hw : black (N.head e) <;>
    simp_all [blackEndpoint]

theorem state_disk_count (h : N.Duality D) (sD : D.Simple)
    (face : ∀ v, D.Triangle (N.star v)) (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) (root : V)
    (m : V → F)
    (hm_inj : Set.InjOn m {v | black v ∧ v ≠ root})
    (hm_face : ∀ v, black v → v ≠ root → m v ∈ Set.range (face v).corner)
    (hm_range : ∀ z, z ∉ Set.range (face root).corner ↔
      ∃ v, black v ∧ v ≠ root ∧ m v = z)
    (C : Barnette.CycleCoordinates D.graph)
    (hchoice : ∀ i, N.blackEndpoint black (D.cycleEdge C i) ≠ root ∧
      m (N.blackEndpoint black (D.cycleEdge C i)) = C.vertex i)
    (A : Finset V) (hroot : root ∉ A) (hcut : N.cut A = D.cycleEdges C) :
    (A.filter black).card + (N.cut A).card =
      (N.regionVertices D A).card + (N.blackCut black A).card := by
  let U := N.regionVertices D A
  let Z := D.cycleVertices C
  let B := A.filter black
  let M := B.image m
  let J := Finset.univ.filter fun i : Fin (C.n+3) =>
    N.blackEndpoint black (D.cycleEdge C i) ∈ A
  have face_region {v : V} (hv : v ∈ A) {z : F}
      (hz : z ∈ Set.range (face v).corner) : z ∈ U :=
    (N.regionVertices_iff_face D face A z).mpr ⟨v,hv,hz⟩
  have hZroot : ∀ z ∈ Z, z ∉ Set.range (face root).corner := by
    intro z hz
    obtain ⟨i,rfl⟩ := (D.mem_cycleVertices C z).mp hz
    apply (hm_range _).mpr
    exact ⟨_,(N.blackEndpoint_spec black hc _).1,(hchoice i).1,(hchoice i).2⟩
  have hZU : Z ⊆ U := by
    intro z hz
    obtain ⟨e,he,hez⟩ := (D.incident_cycle_iff C z).mpr hz
    rw [← hcut] at he
    refine (N.mem_regionVertices D A z).mpr ⟨e,?_,hez⟩
    rcases (N.mem_cut A e).mp he with ht | hh
    · exact (N.mem_regionEdges A e).mpr (Or.inl ht.1)
    · exact (N.mem_regionEdges A e).mpr (Or.inr hh.1)
  have hUroot : ∀ z ∈ U, z ∉ Set.range (face root).corner := by
    intro z hz hr
    have hzout : z ∈ N.regionVertices D Aᶜ :=
      (N.regionVertices_iff_face D face Aᶜ z).mpr ⟨root,Finset.mem_compl.mpr hroot,hr⟩
    have hh := N.mixed_corner_on_boundary D h sD face A hz hzout
    rw [hcut] at hh
    exact hZroot z ((D.incident_cycle_iff C z).mp hh) hr
  have hMU : M ⊆ U := by
    intro z hz
    obtain ⟨v,hv,rfl⟩ := Finset.mem_image.mp hz
    obtain ⟨hvA,hvb⟩ := Finset.mem_filter.mp hv
    exact face_region hvA (hm_face v hvb (fun he => hroot (he ▸ hvA)))
  have h_union : M ∪ Z = U := by
    apply Finset.Subset.antisymm
    · exact Finset.union_subset hMU hZU
    · intro z hz
      by_cases hzZ : z ∈ Z
      · exact Finset.mem_union_right _ hzZ
      obtain ⟨v,hvb,hvr,hvz⟩ := (hm_range z).mp (hUroot z hz)
      have hvA : v ∈ A := by
        by_contra hvA
        have hzout : z ∈ N.regionVertices D Aᶜ :=
          (N.regionVertices_iff_face D face Aᶜ z).mpr
            ⟨v,Finset.mem_compl.mpr hvA,hvz ▸ hm_face v hvb hvr⟩
        have hh := N.mixed_corner_on_boundary D h sD face A hz hzout
        rw [hcut] at hh
        exact hzZ ((D.incident_cycle_iff C z).mp hh)
      exact Finset.mem_union_left _ (Finset.mem_image.mpr
        ⟨v,Finset.mem_filter.mpr ⟨hvA,hvb⟩,hvz⟩)
  have h_inter : M ∩ Z = J.image C.vertex := by
    ext z
    constructor
    · rintro hz
      obtain ⟨hzM,hzZ⟩ := Finset.mem_inter.mp hz
      obtain ⟨v,hv,hvz⟩ := Finset.mem_image.mp hzM
      obtain ⟨hvA,hvb⟩ := Finset.mem_filter.mp hv
      obtain ⟨i,hi⟩ := (D.mem_cycleVertices C z).mp hzZ
      have heq : v = N.blackEndpoint black (D.cycleEdge C i) :=
        hm_inj ⟨hvb,fun he => hroot (he ▸ hvA)⟩
          ⟨(N.blackEndpoint_spec black hc _).1,(hchoice i).1⟩
          (hvz.trans (hi.symm.trans (hchoice i).2.symm))
      exact Finset.mem_image.mpr ⟨i,Finset.mem_filter.mpr ⟨Finset.mem_univ _,heq ▸ hvA⟩,hi⟩
    · rintro hz
      obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp hz
      have hiA := (Finset.mem_filter.mp hi).2
      refine Finset.mem_inter.mpr ⟨?_,(D.mem_cycleVertices C _).mpr ⟨i,rfl⟩⟩
      exact Finset.mem_image.mpr ⟨_,Finset.mem_filter.mpr
        ⟨hiA,(N.blackEndpoint_spec black hc _).1⟩,(hchoice i).2⟩
  have hCJ : J.image (D.cycleEdge C) = N.blackCut black A := by
    ext e
    simp only [blackCut,Finset.mem_filter]
    constructor
    · intro he
      obtain ⟨i,hi,rfl⟩ := Finset.mem_image.mp he
      refine ⟨?_,(Finset.mem_filter.mp hi).2⟩
      rw [hcut]
      exact (D.mem_cycleEdges C _).mpr ⟨i,rfl⟩
    · rintro ⟨he,hb⟩
      rw [hcut] at he
      obtain ⟨i,rfl⟩ := (D.mem_cycleEdges C e).mp he
      exact Finset.mem_image.mpr ⟨i,Finset.mem_filter.mpr ⟨Finset.mem_univ _,hb⟩,rfl⟩
  have hMcard : M.card = B.card := Finset.card_image_iff.mpr (by
    intro v hv w hw he
    obtain ⟨hvA,hvb⟩ := Finset.mem_filter.mp hv
    obtain ⟨hwA,hwb⟩ := Finset.mem_filter.mp hw
    exact hm_inj ⟨hvb,fun he => hroot (he ▸ hvA)⟩
      ⟨hwb,fun he => hroot (he ▸ hwA)⟩ he)
  have hZcard : Z.card = (N.cut A).card := by
    rw [hcut]
    simp only [Z,cycleVertices,cycleEdges,Finset.card_image_of_injective _ C.vertex.injective,
      Finset.card_image_of_injective _ (D.cycleEdge_injective C)]
  have hIcard : (M ∩ Z).card = (N.blackCut black A).card := by
    rw [h_inter,← hCJ]
    rw [Finset.card_image_of_injective _ C.vertex.injective,
      Finset.card_image_of_injective _ (D.cycleEdge_injective C)]
  have hh := Finset.card_union_add_card_inter M Z
  rw [h_union,hMcard,hZcard,hIcard] at hh
  exact hh.symm

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] [Fintype E] [Fintype F] in
def blackDelta (black : V → Prop) (C : Barnette.CycleCoordinates D.graph) : ℝ :=
  ∑ i, N.gradient (fun v => if black v then 1 else 0) (D.cycleEdge C i) *
    D.arcSign (D.cycleEdge C i) (C.vertex i)

omit [Fintype V] [Fintype F] in
lemma blackDelta_cut (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (C : Barnette.CycleCoordinates D.graph) (A : Finset V) (c : ℝ)
    (hx : D.cycleFlow C = c • N.gradient (fun v => if v ∈ A then 1 else 0))
    (hcut : N.cut A = D.cycleEdges C) :
    N.blackDelta D black C = c * (2 * (N.blackCut black A).card - (N.cut A).card) := by
  have hsum : N.blackDelta D black C = ∑ e ∈ N.cut A,
      N.gradient (fun v => if black v then 1 else 0) e * D.cycleFlow C e := by
    rw [hcut,cycleEdges,Finset.sum_image (D.cycleEdge_injective C).injOn]
    simp only [blackDelta,D.cycleFlow_apply_edge]
  rw [hsum]
  simp only [hx,Pi.smul_apply,smul_eq_mul]
  have heq (e : E) (he : e ∈ N.cut A) :
      N.gradient (fun v => if black v then (1:ℝ) else 0) e *
        (c * N.gradient (fun v => if v ∈ A then 1 else 0) e) =
      c * (2 * (if N.blackEndpoint black e ∈ A then 1 else 0) - 1) := by
    have hcol := hc e
    have he' := (N.mem_cut A e).mp he
    by_cases ht : N.tail e ∈ A <;> by_cases hh : N.head e ∈ A <;>
      by_cases hb : black (N.tail e) <;> by_cases hw : black (N.head e) <;>
      simp_all [gradient_apply,blackEndpoint] <;> ring
  rw [Finset.sum_congr rfl heq,← Finset.mul_sum,Finset.sum_sub_distrib,
    ← Finset.mul_sum,Finset.sum_boole]
  simp [blackCut]

omit [Fintype V] [Fintype E] [Fintype F] in
lemma cycle_cut_scalar (C : Barnette.CycleCoordinates D.graph) (A : Finset V) (c : ℝ)
    (hx : D.cycleFlow C = c • N.gradient (fun v => if v ∈ A then 1 else 0)) :
    c = 1 ∨ c = -1 := by
  have hh := congrFun hx (D.cycleEdge C 0)
  rw [D.cycleFlow_apply_edge] at hh
  simp only [Pi.smul_apply,smul_eq_mul,gradient_apply] at hh
  by_cases ht : N.tail (D.cycleEdge C 0) ∈ A <;>
    by_cases hh' : N.head (D.cycleEdge C 0) ∈ A <;>
    by_cases hd : D.tail (D.cycleEdge C 0) = C.vertex 0 <;>
    simp [arcSign,ht,hh',hd] at hh <;>
    first | exact Or.inl (by linarith) | exact Or.inr (by linarith)

lemma disk_boundary_imbalance (h : N.Duality D) (sN : N.Simple)
    (hdeg : N.graph.IsRegularOfDegree 3) (sD : D.Simple)
    (face : ∀ v, D.Triangle (N.star v))
    (black : V → Prop) (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (A : Finset V) (hA : (N.graph.induce {v | v ∈ A}).Connected)
    (hAc : (N.graph.induce {v | v ∉ A}).Connected)
    (hm : (A.filter black).card + (N.cut A).card =
      (N.regionVertices D A).card + (N.blackCut black A).card) :
    (N.cut A).card = 2 * (N.blackCut black A).card + 3 := by
  have he := N.region_euler D h A hA hAc sD face
  have ht := N.cubic_region_count sN hdeg A
  have hb := N.cubic_black_region_count sN hdeg black hc A
  omega

theorem state_disk_delta (h : N.Duality D) (sN : N.Simple)
    (hdeg : N.graph.IsRegularOfDegree 3) (sD : D.Simple)
    (face : ∀ v, D.Triangle (N.star v)) (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) (root : V)
    (m : V → F)
    (hm_inj : Set.InjOn m {v | black v ∧ v ≠ root})
    (hm_face : ∀ v, black v → v ≠ root → m v ∈ Set.range (face v).corner)
    (hm_range : ∀ z, z ∉ Set.range (face root).corner ↔
      ∃ v, black v ∧ v ≠ root ∧ m v = z)
    (C : Barnette.CycleCoordinates D.graph)
    (hchoice : ∀ i, N.blackEndpoint black (D.cycleEdge C i) ≠ root ∧
      m (N.blackEndpoint black (D.cycleEdge C i)) = C.vertex i) :
    ∃ (A : Finset V) (c : ℝ), A.Nonempty ∧ root ∉ A ∧ (c = 1 ∨ c = -1) ∧
      D.cycleFlow C = c • N.gradient (fun v => if v ∈ A then 1 else 0) ∧
      N.cut A = D.cycleEdges C ∧
      (N.cut A).card = 2 * (N.blackCut black A).card + 3 ∧
      N.blackDelta D black C = -3*c := by
  have hx := D.cycleFlow_circuit C sD
  obtain ⟨A,c,ha,hr,_hc0,he,hcut⟩ := h.circuit_cut N D (D.cycleFlow C) hx root
  rw [D.cycleFlow_support] at hcut
  have hb : N.Bond A := h.bond_of_circuit N D (D.cycleFlow C) hx A (by
    rw [D.cycleFlow_support]; exact hcut)
  have hA := hb.connected_shore N h.connected ha ⟨root,hr⟩
  have hAc := hb.compl.connected_shore N h.connected
    (Finset.mem_compl.mpr hr |> fun hh => ⟨root,hh⟩) (by
      obtain ⟨v,hv⟩ := ha
      exact ⟨v,by simpa using hv⟩)
  have hsides : {v : V | v ∈ Aᶜ} = {v : V | v ∉ A} := by
    ext v
    exact Finset.mem_compl
  rw [hsides] at hAc
  have hm := N.state_disk_count D h sD face black hc root m hm_inj hm_face hm_range C hchoice A hr hcut
  have hcount := N.disk_boundary_imbalance D h sN hdeg sD face black hc A hA hAc hm
  refine ⟨A,c,ha,hr,N.cycle_cut_scalar D C A c he,he,hcut,hcount,?_⟩
  rw [N.blackDelta_cut D black hc C A c he hcut,hcount]
  push_cast
  ring

end
end Barnette.Network

end OAI