import OAI.Combinatorics.Hamiltonian.BMatching

namespace OAI

/-! Disk and spoke signs and matching complements. -/

namespace Barnette.CycleCoordinates
variable {V : Type*} {G : SimpleGraph V} (C : Barnette.CycleCoordinates G)
include C in
lemma not_acyclic : ¬ G.IsAcyclic := by
  intro ha
  apply (SimpleGraph.isAcyclic_iff_free_cycleGraph.mp ha) (C.n+3) (by omega)
  refine ⟨⟨⟨C.vertex,?_⟩,C.vertex.injective⟩⟩
  intro i j hij
  rcases SimpleGraph.cycleGraph_adj.mp hij with hij | hij
  · have hi : i = j+1 := (sub_eq_iff_eq_add.mp hij).trans (add_comm _ _)
    rw [hi]; exact (C.adjacent j).symm
  · have hj : j = i+1 := (sub_eq_iff_eq_add.mp hij).trans (add_comm _ _)
    rw [hj]; exact C.adjacent i
end Barnette.CycleCoordinates

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

lemma acyclic_conserved_zero (hN : N.Simple) (ha : N.graph.IsAcyclic)
    (x : E → ℝ) (hx : N.boundary x = 0) : x = 0 := by
  ext e
  let K := N.graph.deleteEdges {s(N.tail e,N.head e)}
  have he : N.graph.Adj (N.tail e) (N.head e) := ⟨hN.loopless e,e,Or.inl ⟨rfl,rfl⟩⟩
  have hb : ¬K.Reachable (N.tail e) (N.head e) :=
    (SimpleGraph.isAcyclic_iff_forall_adj_isBridge.mp ha he)
  let f : V → ℝ := fun v => if K.Reachable (N.tail e) v then 1 else 0
  have hg : N.gradient f e = -1 := by simp [gradient_apply,f,hb]
  have hk : ∀ k, k ≠ e → N.gradient f k = 0 := by
    intro k hke
    have hp : s(N.tail k,N.head k) ≠ s(N.tail e,N.head e) :=
      fun h => hke (hN.pair_injective h)
    have hadj : K.Adj (N.tail k) (N.head k) := by
      apply SimpleGraph.deleteEdges_adj.mpr
      exact ⟨⟨hN.loopless k,k,Or.inl ⟨rfl,rfl⟩⟩,by simpa only [Set.mem_singleton_iff] using hp⟩
    have hh : K.Reachable (N.tail e) (N.head k) ↔ K.Reachable (N.tail e) (N.tail k) :=
      ⟨fun h => h.trans hadj.reachable.symm,fun h => h.trans hadj.reachable⟩
    simp [gradient_apply,f,hh]
  have hi := N.boundary_adjoint x f
  rw [hx] at hi
  simp only [Pi.zero_apply,zero_mul,Finset.sum_const_zero] at hi
  rw [Finset.sum_eq_single e] at hi
  · simpa [hg] using hi.symm
  · intro k _ hke; rw [hk k hke,mul_zero]
  · simp

omit [Fintype V] [Fintype E] in
lemma Simple.restrict (hN : N.Simple) {K : Type*} (j : K → E) (hj : Function.Injective j) :
    (N.restrict j).Simple where
  loopless k := hN.loopless (j k)
  pair_injective _ _ h := hj (hN.pair_injective h)

omit [Fintype E] in
lemma extend_restriction (S : Finset E) (x : E → ℝ) (hx : ∀ e, e ∉ S → x e = 0) :
    push (Subtype.val : S → E) (fun e => x e.val) = x := by
  ext e
  by_cases he : e ∈ S
  · exact push_subtype_apply S (fun e => x e.val) ⟨e,he⟩
  · rw [push_subtype_outside S _ he,hx e he]

lemma conserved_supported_acyclic (hN : N.Simple) (S : Finset E)
    (ha : (N.restrict (Subtype.val : S → E)).graph.IsAcyclic)
    (x : E → ℝ) (hx : N.boundary x = 0) (hs : ∀ e, e ∉ S → x e = 0) : x = 0 := by
  have hz : (N.restrict (Subtype.val : S → E)).boundary (fun e => x e.val) = 0 := by
    rw [boundary_restrict,extend_restriction S x hs,hx]
  have hh := (N.restrict (Subtype.val : S → E)).acyclic_conserved_zero
    (hN.restrict N _ Subtype.val_injective) ha _ hz
  rw [← extend_restriction S x hs,hh,map_zero]

variable {F : Type*} [Fintype F] (D : Network F E)
omit [Fintype V] in
lemma Duality.complement_connected (h : N.Duality D) (hD : D.Simple) (S : Finset E)
    (ha : (D.restrict (Subtype.val : S → E)).graph.IsAcyclic) :
    (N.restrict (Subtype.val : ↥(Sᶜ) → E)).graph.Connected := by
  have : Nonempty V := h.connected.nonempty
  apply (N.restrict (Subtype.val : ↥(Sᶜ) → E)).connected_of_kernel_constants
  intro f hf v w
  have hz : D.boundary (N.gradient f) = 0 := by
    rw [← LinearMap.mem_ker,h.dual_cycles_eq_cuts]
    exact ⟨f,rfl⟩
  have hs : ∀ e, e ∉ S → N.gradient f e = 0 := by
    intro e he
    exact congrFun hf ⟨e,Finset.mem_compl.mpr he⟩
  exact N.gradient_zero_reachable (D.conserved_supported_acyclic hD S ha _ hz hs) (h.connected v w)

end
end Barnette.Network

namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V A : Type*} (Q : Network V A)

def addSink (r : Fin 2 → V) (z : V) : Network V (A ⊕ Fin 2) where
  tail := Sum.elim Q.tail r
  head := Sum.elim Q.head (fun _ => z)

lemma addSink_tail_injective (ht : Function.Injective Q.tail) (r : Fin 2 → V)
    (hr : Function.Injective r) (hd : ∀ a i, Q.tail a ≠ r i) (z : V) :
    Function.Injective (Q.addSink r z).tail := by
  rintro (a|i) (b|j) h
  · exact congrArg Sum.inl (ht h)
  · exact (hd a j h).elim
  · exact (hd b i h.symm).elim
  · exact congrArg Sum.inr (hr h)

lemma addSink_acyclic (ha : Q.graph.IsAcyclic) (ht : Function.Injective Q.tail)
    (r : Fin 2 → V) (hr : Function.Injective r) (hd : ∀ a i, Q.tail a ≠ r i)
    (z : V) (hz : z ∉ Set.range (Q.addSink r z).tail) : (Q.addSink r z).graph.IsAcyclic := by
  classical
  by_contra hnot
  obtain ⟨C⟩ := Barnette.cycleCoordinates_of_not_acyclic hnot
  let L := Q.addSink r z
  let edge : Fin (C.n+3) ↪ A ⊕ Fin 2 := ⟨L.cycleEdge C,L.cycleEdge_injective C⟩
  have hend (i) : L.tail (edge i) = C.vertex i ∨ L.tail (edge i) = C.vertex (i+1) := by
    rcases Sym2.eq_iff.mp (L.cycleEdge_ends C i) with h|h
    · exact Or.inl h.1
    · exact Or.inr h.1
  have hor := C.tail_orientation edge L.tail (Q.addSink_tail_injective ht r hr hd z) hend
  have hrange (i) : C.vertex i ∈ Set.range L.tail := by
    rcases hor with hf|hb
    · exact ⟨edge i,hf i⟩
    · refine ⟨edge (i-1),?_⟩
      simpa using hb (i-1)
  have hbase (i) : ∃ a, edge i = Sum.inl a := by
    cases he : edge i with
    | inl a => exact ⟨a,rfl⟩
    | inr j =>
      have hh : L.head (edge i) = z := by rw [he]; rfl
      rcases Sym2.eq_iff.mp (L.cycleEdge_ends C i) with h|h
      · exact (hz (hh ▸ (h.2 ▸ hrange (i+1)))).elim
      · exact (hz (hh ▸ (h.2 ▸ hrange i))).elim
  have hc : Nonempty (Barnette.CycleCoordinates Q.graph) := by
    refine ⟨⟨C.n,C.vertex,?_⟩⟩
    intro i
    obtain ⟨a,hea⟩ := hbase i
    refine ⟨(C.adjacent i).1,a,?_⟩
    have he := L.cycleEdge_ends C i
    change s(L.tail (edge i),L.head (edge i)) = _ at he
    rw [hea] at he
    exact Sym2.eq_iff.mp he
  exact hc.elim (fun C' => C'.not_acyclic ha)

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

lemma boundary_injective_of_tree_card (hc : N.graph.Connected)
    (he : Fintype.card E + 1 = Fintype.card V) : Function.Injective N.boundary := by
  have hh := N.dim_cycles hc
  have hz : Module.finrank ℝ N.boundary.ker = 0 := by omega
  exact LinearMap.ker_eq_bot.mp (Submodule.finrank_eq_zero.mp hz)

lemma boundary_restrict_injective (hi : Function.Injective N.boundary)
    {K : Type*} [Fintype K] (j : K → E) (hj : Function.Injective j) :
    Function.Injective (N.restrict j).boundary := by
  intro x y h
  rw [boundary_restrict,boundary_restrict] at h
  have hh := congrArg (pull j) (hi h)
  simpa only [pull_push_injective hj] using hh

omit [Fintype V] [Fintype E] in
lemma boundary_supported_vertices {K : Type*} [Fintype K] (j : K → E)
    (U : Finset V) (hU : ∀ k, N.tail (j k) ∈ U ∧ N.head (j k) ∈ U)
    (x : K → ℝ) {v : V} (hv : v ∉ U) : (N.restrict j).boundary x v = 0 := by
  rw [boundary_apply]
  apply Finset.sum_eq_zero
  intro k _
  have ht : (N.restrict j).tail k ≠ v := fun hh => hv (hh ▸ (hU k).1)
  have hh : (N.restrict j).head k ≠ v := fun hh => hv (hh ▸ (hU k).2)
  simp [ht,hh]

lemma independent_edges_bound (hi : Function.Injective N.boundary)
    (S : Finset E) (U : Finset V) (hne : U.Nonempty)
    (hU : ∀ e ∈ S, N.tail e ∈ U ∧ N.head e ∈ U) : S.card + 1 ≤ U.card := by
  obtain ⟨v,hv⟩ := hne
  let H := N.restrict (Subtype.val : S → E)
  let L : (S → ℝ) →ₗ[ℝ] (U.erase v → ℝ) := (pull Subtype.val).comp H.boundary
  have hL : Function.Injective L := by
    intro x y hxy
    apply N.boundary_restrict_injective hi Subtype.val Subtype.val_injective
    have hrow : ∀ w, w ≠ v → H.boundary x w = H.boundary y w := by
      intro w hw
      by_cases hwU : w ∈ U
      · exact congrFun hxy ⟨w,Finset.mem_erase.mpr ⟨hw,hwU⟩⟩
      · rw [N.boundary_supported_vertices Subtype.val U (fun e => hU e.val e.property) x hwU,
          N.boundary_supported_vertices Subtype.val U (fun e => hU e.val e.property) y hwU]
    ext w
    by_cases hw : w = v
    · subst w
      have hsx := H.sum_boundary x
      have hsy := H.sum_boundary y
      rw [← Finset.sum_erase_add _ _ (Finset.mem_univ v)] at hsx hsy
      have hh : (∑ w ∈ Finset.univ.erase v, H.boundary x w) =
          ∑ w ∈ Finset.univ.erase v, H.boundary y w := by
        apply Finset.sum_congr rfl
        intro w hw; exact hrow w (Finset.mem_erase.mp hw).1
      linarith
    · exact hrow w hw
  have hc := LinearMap.finrank_le_finrank_of_injective hL
  simp only [Module.finrank_pi,Fintype.card_coe] at hc
  rw [Finset.card_erase_of_mem hv] at hc
  have hvp : 0 < U.card := Finset.card_pos.mpr ⟨v,hv⟩
  omega

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

abbrev QNet (P : (M.system root).Pair (M.nonroots root)) : Network F (M.Black root) where
  tail t := P.left.value t
  head t := (M.face t.val).corner (thirdIndex (P.left.val t) (P.right.val t))

omit [Fintype F] in
lemma pair_val_ne (P : (M.system root).Pair (M.nonroots root)) (t : M.Black root) :
    P.left.val t ≠ P.right.val t := fun h => P.partner t ((State.value_eq_iff _ _ _).mpr h)

omit [Fintype F] in
lemma q_graph (P : (M.system root).Pair (M.nonroots root)) :
    (M.QNet P).graph = (M.system root).oppositeGraph P.right := by
  ext v w
  rw [(M.system root).oppositeGraph_adj_iff P.partner]
  constructor
  · rintro ⟨_,t,h|h⟩
    · exact ⟨t,Or.inl ⟨h.1.symm,h.2.symm⟩⟩
    · exact ⟨t,Or.inr ⟨h.1.symm,h.2.symm⟩⟩
  · rintro ⟨t,h|h⟩
    all_goals have hn := (thirdIndex_distinct _ _ (M.pair_val_ne P t)).1
    · exact ⟨fun he => hn ((M.face t.val).corner_injective (h.2.symm.trans (he.symm.trans h.1))),
        t,Or.inl ⟨h.1.symm,h.2.symm⟩⟩
    · exact ⟨fun he => hn ((M.face t.val).corner_injective (h.2.symm.trans (he.trans h.1))),
        t,Or.inr ⟨h.1.symm,h.2.symm⟩⟩

def qLabel (P : (M.system root).Pair (M.nonroots root)) (t : M.Black root) : E :=
  (M.face t.val).side D (P.left.val t) (thirdIndex (P.left.val t) (P.right.val t))

omit [Fintype F] in
lemma qLabel_ends (P : (M.system root).Pair (M.nonroots root)) (t : M.Black root) :
    s(D.tail (M.qLabel P t),D.head (M.qLabel P t)) =
      s((M.QNet P).tail t,(M.QNet P).head t) :=
  (M.face t.val).side_ends D (thirdIndex_distinct _ _ (M.pair_val_ne P t)).1.symm

omit [Fintype F] in
lemma qLabel_black (P : (M.system root).Pair (M.nonroots root)) (t : M.Black root) :
    N.blackEndpoint M.black (M.qLabel P t) = t.val :=
  N.blackEndpoint_eq M.black M.coloring t.property.1
    ((N.mem_star _ _).mp ((M.face t.val).side_mem D _ _))

omit [Fintype F] in
lemma qLabel_inj (P : (M.system root).Pair (M.nonroots root)) :
    Function.Injective (M.qLabel P) := by
  intro t u h
  apply Subtype.ext
  exact (M.qLabel_black P t).symm.trans ((congrArg (N.blackEndpoint M.black) h).trans (M.qLabel_black P u))

def rootStart (i : Fin 3) (j : Fin 2) : Fin 3 := i + j.castLE (by decide)

lemma rootStart_inj (i : Fin 3) : Function.Injective (rootStart i) := by revert i; decide
lemma rootStart_ne (i : Fin 3) (j : Fin 2) : rootStart i j ≠ i+2 := by revert i j; decide

abbrev augQ (P : (M.system root).Pair (M.nonroots root)) (i : Fin 3) :
    Network F (M.Black root ⊕ Fin 2) :=
  (M.QNet P).addSink (fun j => (M.face root).corner (rootStart i j)) ((M.face root).corner (i+2))

omit [Fintype F] in
lemma augQ_acyclic (P : (M.system root).Pair (M.nonroots root))
    (ha : ((M.system root).oppositeGraph P.right).IsAcyclic) (i : Fin 3) :
    (M.augQ P i).graph.IsAcyclic := by
  apply (M.QNet P).addSink_acyclic (M.q_graph P ▸ ha) P.left.value_injective _
    ((M.face root).corner_injective.comp (rootStart_inj i))
  · intro t j h
    exact P.left.value_mem t ⟨rootStart i j,h.symm⟩
  · rintro ⟨t|j,h⟩
    · exact P.left.value_mem t ⟨i+2,h.symm⟩
    · exact rootStart_ne i j ((M.face root).corner_injective h)

def augLabel (P : (M.system root).Pair (M.nonroots root)) (i : Fin 3) :
    M.Black root ⊕ Fin 2 → E :=
  Sum.elim (M.qLabel P) (fun j => (M.face root).side D (rootStart i j) (i+2))

omit [Fintype F] in
lemma augLabel_ends (P : (M.system root).Pair (M.nonroots root)) (i : Fin 3)
    (t : M.Black root ⊕ Fin 2) :
    s(D.tail (M.augLabel P i t),D.head (M.augLabel P i t)) =
      s((M.augQ P i).tail t,(M.augQ P i).head t) := by
  cases t with
  | inl t => exact M.qLabel_ends P t
  | inr j => exact (M.face root).side_ends D (rootStart_ne i j)

omit [Fintype F] in
lemma augLabel_inj (P : (M.system root).Pair (M.nonroots root)) (hr : M.black root)
    (i : Fin 3) : Function.Injective (M.augLabel P i) := by
  have hb (j : Fin 2) : N.blackEndpoint M.black (M.augLabel P i (.inr j)) = root :=
    N.blackEndpoint_eq M.black M.coloring hr ((N.mem_star _ _).mp ((M.face root).side_mem D _ _))
  rintro (t|j) (u|k) he
  · exact congrArg Sum.inl (M.qLabel_inj P he)
  · have hh := congrArg (N.blackEndpoint M.black) he
    change N.blackEndpoint M.black (M.qLabel P t) = _ at hh
    rw [M.qLabel_black P t,hb] at hh
    exact (t.property.2 hh).elim
  · have hh := congrArg (N.blackEndpoint M.black) he
    change _ = N.blackEndpoint M.black (M.qLabel P u) at hh
    rw [hb,M.qLabel_black P u] at hh
    exact (u.property.2 hh.symm).elim
  · have hh := (M.augLabel_ends P i (.inr j)).symm.trans
      ((congrArg (fun e => s(D.tail e,D.head e)) he).trans (M.augLabel_ends P i (.inr k)))
    rcases Sym2.eq_iff.mp hh with h|h
    · exact congrArg Sum.inr (rootStart_inj i ((M.face root).corner_injective h.1))
    · exact (rootStart_ne i j ((M.face root).corner_injective h.1)).elim

def removed (P : (M.system root).Pair (M.nonroots root)) (i : Fin 3) : Finset E :=
  Finset.univ.image (M.augLabel P i)

omit [Fintype F] in
lemma removed_acyclic (P : (M.system root).Pair (M.nonroots root))
    (ha : ((M.system root).oppositeGraph P.right).IsAcyclic) (i : Fin 3) :
    (D.restrict (Subtype.val : M.removed P i → E)).graph.IsAcyclic := by
  apply SimpleGraph.IsAcyclic.anti ?_ (M.augQ_acyclic P ha i)
  rintro v w ⟨hv,e,he⟩
  obtain ⟨k,_,hk⟩ := Finset.mem_image.mp e.property
  refine ⟨hv,k,?_⟩
  apply Sym2.eq_iff.mp
  have hh : s(D.tail e.val,D.head e.val) = s(v,w) := Sym2.eq_iff.mpr he
  rw [← hk,M.augLabel_ends] at hh
  exact hh

lemma remainder_connected (P : (M.system root).Pair (M.nonroots root))
    (ha : ((M.system root).oppositeGraph P.right).IsAcyclic) (i : Fin 3) :
    (N.restrict (Subtype.val : ↥((M.removed P i)ᶜ) → E)).graph.Connected :=
  M.duality.complement_connected N D M.dual_simple _ (M.removed_acyclic P ha i)

omit [Fintype F] in
lemma removed_card (P : (M.system root).Pair (M.nonroots root)) (hr : M.black root) (i : Fin 3) :
    (M.removed P i).card = (Finset.univ.filter M.black).card + 1 := by
  rw [removed,Finset.card_image_of_injective _ (M.augLabel_inj P hr i),Finset.card_univ,Fintype.card_sum]
  have hb : Fintype.card (M.Black root) + 1 = (Finset.univ.filter M.black).card := by
    rw [Fintype.card_subtype]
    have he : (Finset.univ.filter fun v => M.black v ∧ v ≠ root) =
        (Finset.univ.filter M.black).erase root := by ext; simp [and_comm]
    rw [he,Finset.card_erase_add_one (by simp [hr])]
  change Fintype.card (M.Black root) + 2 = _
  omega
end
end Barnette.Network.ColoredDual
namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V E : Type*} (D : Network V E)

lemma Triangle.edge_incident {S : Finset E} (t : D.Triangle S) (i j : Fin 3) :
    D.Incident (t.edge i) (t.corner j) ↔ j = i ∨ j = i+1 := by
  rw [D.incident_iff_mem_pair,t.edge_ends,Sym2.mem_iff]
  exact or_congr t.corner_injective.eq_iff t.corner_injective.eq_iff

lemma Triangle.other_root_sides {S : Finset E} (t : D.Triangle S) (i : Fin 3) {e : E}
    (he : e ∈ S) :
    (∃ j : Fin 2, t.side D (ColoredDual.rootStart i j) (i+2) = e) ↔ e ≠ t.edge i := by
  have he' := he
  rw [← t.edge_range] at he'
  obtain ⟨k,_,rfl⟩ := Finset.mem_image.mp he'
  have hh : ∀ i k : Fin 3,
      (∃ j : Fin 2, (if i+2 = ColoredDual.rootStart i j+1 then ColoredDual.rootStart i j else i+2) = k) ↔ k ≠ i := by decide
  have hs (a b : Fin 3) : t.side D a b = t.edge (if b = a+1 then a else b) := by
    unfold Triangle.side; split_ifs <;> rfl
  simp only [hs, ne_eq, t.edge_injective.eq_iff]
  exact hh i k

lemma Triangle.opposite_characteristic {S : Finset E} (t : D.Triangle S)
    {a b : Fin 3} (hab : a ≠ b) {e : E} (he : e ∈ S) :
    e ≠ t.side D a (Barnette.TriangleSystem.thirdIndex a b) ↔ D.Incident e (t.corner b) := by
  have he' := he
  rw [← t.edge_range] at he'
  obtain ⟨k,_,rfl⟩ := Finset.mem_image.mp he'
  rw [t.edge_incident]
  have hh : ∀ a b k : Fin 3, a ≠ b →
      (k ≠ (if Barnette.TriangleSystem.thirdIndex a b = a+1 then a else Barnette.TriangleSystem.thirdIndex a b) ↔
        b = k ∨ b = k+1) := by decide
  have hs (a b : Fin 3) : t.side D a b = t.edge (if b = a+1 then a else b) := by
    unfold Triangle.side; split_ifs <;> rfl
  simp only [hs, ne_eq, t.edge_injective.eq_iff]
  exact hh a b k hab

end
end Barnette.Network

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

omit [Fintype F] in
lemma removed_at_black (P : (M.system root).Pair (M.nonroots root)) (hr : M.black root)
    (i : Fin 3) (v : V) (hv : M.black v) {e : E} (he : e ∈ N.star v) :
    (e ∈ M.removed P i ↔
      if h : v = root then e ≠ (M.face root).edge i else e = M.qLabel P ⟨v,hv,h⟩) := by
  have hb : N.blackEndpoint M.black e = v := N.blackEndpoint_eq M.black M.coloring hv ((N.mem_star _ _).mp he)
  by_cases hh : v = root
  · clear hb
    subst v
    simp only
    have hb : N.blackEndpoint M.black e = root := N.blackEndpoint_eq M.black M.coloring hr ((N.mem_star _ _).mp he)
    constructor
    · intro hmem
      obtain ⟨t|j,_,ht⟩ := Finset.mem_image.mp hmem
      · have hbr : (t : V) = root := (M.qLabel_black P t).symm.trans ((congrArg (N.blackEndpoint M.black) ht).trans hb)
        exact (t.property.2 hbr).elim
      · exact ((M.face root).other_root_sides D i he).mp ⟨j,ht⟩
    · intro hne
      obtain ⟨j,hj⟩ := ((M.face root).other_root_sides D i he).mpr hne
      exact Finset.mem_image.mpr ⟨Sum.inr j,Finset.mem_univ _,hj⟩
  · simp only [dite_eq_right hh]
    constructor
    · intro hmem
      obtain ⟨t|j,_,ht⟩ := Finset.mem_image.mp hmem
      · have htv : t.val = v := (M.qLabel_black P t).symm.trans ((congrArg (N.blackEndpoint M.black) ht).trans hb)
        have ht' : t = ⟨v,hv,hh⟩ := Subtype.ext htv
        change M.qLabel P t = e at ht
        rw [ht'] at ht
        exact ht.symm
      · have hbr : N.blackEndpoint M.black (M.augLabel P i (.inr j)) = root :=
          N.blackEndpoint_eq M.black M.coloring hr ((N.mem_star _ _).mp ((M.face root).side_mem D _ _))
        exact (hh (hb.symm.trans ((congrArg (N.blackEndpoint M.black) ht).symm.trans hbr))).elim
    · intro heq
      exact Finset.mem_image.mpr ⟨Sum.inl ⟨v,hv,hh⟩,Finset.mem_univ _,heq.symm⟩

omit [Fintype F] in
lemma remainder_black_degree (P : (M.system root).Pair (M.nonroots root)) (hr : M.black root)
    (i : Fin 3) (v : V) (hv : M.black v) :
    ((N.star v).filter fun e => e ∈ (M.removed P i)ᶜ).card = if v = root then 1 else 2 := by
  by_cases hh : v = root
  · subst v
    rw [ite_eq_left rfl]
    have he : (N.star root).filter (fun e => e ∈ (M.removed P i)ᶜ) = {(M.face root).edge i} := by
      ext e
      simp only [Finset.mem_filter,Finset.mem_compl,Finset.mem_singleton]
      constructor
      · rintro ⟨he,hn⟩
        have hm := M.removed_at_black P hr i root hr he
        simpa using (not_congr hm).mp hn
      · intro heq; subst e
        have hm : (M.face root).edge i ∈ N.star root := by
          have hx : (M.face root).edge i ∈ Finset.univ.image (M.face root).edge := Finset.mem_image.mpr ⟨i,Finset.mem_univ _,rfl⟩
          simpa only [(M.face root).edge_range] using hx
        exact ⟨hm,by rw [M.removed_at_black P hr i root hr hm]; simp⟩
    rw [he,Finset.card_singleton]
  · rw [ite_eq_right hh]
    have he : (N.star v).filter (fun e => e ∈ (M.removed P i)ᶜ) =
        (N.star v).erase (M.qLabel P ⟨v,hv,hh⟩) := by
      ext e
      simp only [Finset.mem_filter,Finset.mem_compl,Finset.mem_erase]
      constructor
      · rintro ⟨he,hn⟩
        have hm := M.removed_at_black P hr i v hv he
        simp only [dite_eq_right hh] at hm
        exact ⟨(not_congr hm).mp hn,he⟩
      · rintro ⟨hn,he⟩
        exact ⟨he,by rw [M.removed_at_black P hr i v hv he]; simpa [hh]⟩
    rw [he,Finset.card_erase_of_mem (show M.qLabel P ⟨v,hv,hh⟩ ∈ N.star v from (M.face v).side_mem D _ _),N.card_star M.simple,M.cubic v]

lemma cubic_cards : Fintype.card E = 3*(Finset.univ.filter M.black).card ∧
    Fintype.card V = 2*(Finset.univ.filter M.black).card := by
  have hdeg : ∀ v, N.graph.degree v = 3 := M.cubic
  have he := N.black_edge_partition M.black M.coloring Finset.univ
  simp only [Finset.filter_true_of_mem (fun _ _ => Finset.mem_univ _),N.card_star M.simple,
    hdeg,Finset.sum_const,smul_eq_mul,Finset.card_univ] at he
  have hf := N.black_dual_card D M.duality M.simple M.cubic M.black M.coloring
  have heu := M.duality.euler N D
  constructor <;> omega

lemma remainder_independent (P : (M.system root).Pair (M.nonroots root)) (hr : M.black root)
    (ha : ((M.system root).oppositeGraph P.right).IsAcyclic) (i : Fin 3) :
    Function.Injective (N.restrict (Subtype.val : ↥((M.removed P i)ᶜ) → E)).boundary := by
  apply boundary_injective_of_tree_card _ (M.remainder_connected P ha i)
  rw [Fintype.card_coe]
  have hc := Finset.card_add_card_compl (M.removed P i)
  rw [M.removed_card P hr i] at hc
  have hE := M.cubic_cards.1
  have hV := M.cubic_cards.2
  omega

omit [Fintype F] in
lemma remainder_incident (P : (M.system root).Pair (M.nonroots root)) (hr : M.black root)
    (i : Fin 3) (t : M.Black root) {e : E} (he : e ∈ N.star t.val)
    (hm : e ∈ (M.removed P i)ᶜ) : D.Incident e (P.right.value t) := by
  have hn := (not_congr (M.removed_at_black P hr i t.val t.property.1 he)).mp (Finset.mem_compl.mp hm)
  simp only [dite_eq_right t.property.2] at hn
  exact ((M.face t.val).opposite_characteristic D (M.pair_val_ne P t) he).mp hn

end
end Barnette.Network.ColoredDual

end OAI