import OAI.Combinatorics.Hamiltonian.ForestMatching

namespace OAI

/-! Three-edge cuts, capped graphs, and preservation of graph properties. -/

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

lemma gradient_small_support_edge (h : N.ThreeEdgeConnected) (f : V → ℝ) (s : Finset E) (hs : s.card ≤ 2)
    (hf : ∀ e, e ∉ s → N.gradient f e = 0) : N.gradient f = 0 := by
  ext e
  by_contra he
  have hne : f (N.head e) ≠ f (N.tail e) := by
    simpa only [gradient_apply, Pi.zero_apply, sub_eq_zero] using he
  let A := Finset.univ.filter fun v => f v = f (N.tail e)
  have hin : A.Nonempty := ⟨N.tail e, by simp [A]⟩
  have hout : ∃ w, w ∉ A := ⟨N.head e, by simp [A, hne]⟩
  have hsub : N.cut A ⊆ s := by
    intro k hk
    by_contra hks
    have hg : f (N.head k) = f (N.tail k) := sub_eq_zero.mp (hf k hks)
    rcases (N.mem_cut A k).mp hk with ⟨ht,hh⟩ | ⟨hh,ht⟩
    · apply hh; simp only [A, Finset.mem_filter, Finset.mem_univ, true_and] at ht ⊢
      exact hg.trans ht
    · apply ht; simp only [A, Finset.mem_filter, Finset.mem_univ, true_and] at hh ⊢
      exact hg.symm.trans hh
  have h₁ := h A hin (by obtain ⟨w,hw⟩ := hout; exact ⟨w,Finset.mem_compl.mpr hw⟩)
  have h₂ := Finset.card_le_card hsub
  omega

variable {F : Type*} [Fintype F] (D : Network F E)

omit [Fintype F] in
theorem Duality.simple_dual_edge (h : N.Duality D)
    (h3 : N.ThreeEdgeConnected) : D.Simple := by
  have lift_zero (x : E → ℝ) (hx : D.boundary x = 0)
      (s : Finset E) (hs : s.card ≤ 2) (hxs : ∀ e, e ∉ s → x e = 0) : x = 0 := by
    have hx' : x ∈ N.gradient.range := by rw [← h.dual_cycles_eq_cuts]; exact hx
    obtain ⟨f,hf⟩ := hx'
    rw [← hf]
    exact N.gradient_small_support_edge h3 f s hs (by simpa only [hf] using hxs)
  refine ⟨?_, ?_⟩
  · intro e he
    have hz : D.boundary (basisVec e) = 0 := by
      rw [D.boundary_basis]
      ext v
      simp [incidence, he]
    have hzero := lift_zero (basisVec e) hz {e} (by simp) (by
      intro k hk; simp only [Finset.mem_singleton] at hk; simp [basisVec, hk])
    have hh := congrFun hzero e
    norm_num [basisVec] at hh
  · intro e f hef
    by_contra hne
    rcases Sym2.eq_iff.mp hef with ⟨ht,hh⟩ | ⟨ht,hh⟩
    · have hz : D.boundary (basisVec e - basisVec f) = 0 := by
        rw [map_sub, D.boundary_basis, D.boundary_basis]
        ext v
        simp [incidence, ht, hh]
      have hzero := lift_zero (basisVec e - basisVec f) hz {e,f}
        (by simpa using Finset.card_insert_le e ({f} : Finset E))
        (by intro k hk; simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk
            simp [basisVec, hk.1, hk.2])
      have hv := congrFun hzero e
      norm_num [basisVec, hne] at hv
    · have hz : D.boundary (basisVec e + basisVec f) = 0 := by
        rw [map_add, D.boundary_basis, D.boundary_basis]
        ext v
        dsimp [incidence]
        rw [ht, hh]
        ring
      have hzero := lift_zero (basisVec e + basisVec f) hz {e,f}
        (by simpa using Finset.card_insert_le e ({f} : Finset E))
        (by intro k hk; simp only [Finset.mem_insert, Finset.mem_singleton, not_or] at hk
            simp [basisVec, hk.1, hk.2])
      have hv := congrFun hzero e
      norm_num [basisVec, hne] at hv

omit [Fintype F] in
theorem Duality.cubic_face_triangles_edge (h : N.Duality D) (hN : N.Simple)
    (h3 : N.ThreeEdgeConnected)
    (hc : N.graph.IsRegularOfDegree 3) : ∀ v, Nonempty (D.Triangle (N.star v)) := by
  intro v
  have hD := h.simple_dual_edge N D h3
  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.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 F] in
lemma make_coloredDual (h : N.Duality D) (hN : N.Simple) (h3 : N.ThreeEdgeConnected)
    (hc : N.graph.IsRegularOfDegree 3) (black : V → Prop)
    (hb : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) : Nonempty (N.ColoredDual D) := by
  have hs := h.simple_dual_edge N D h3
  have ht := h.cubic_face_triangles_edge N D hN h3 hc
  choose t ho using fun v => N.oriented_face D h hN hs v (ht v).some
  exact ⟨⟨h,hN,hs,hc,black,hb,t,ho⟩⟩

lemma irreducible_matching (M : N.ColoredDual D)
    (h3 : N.ThreeEdgeConnected) (htr : N.TrivialThreeCuts) (e : E) :
    ∃ P : Finset E, e ∈ P ∧ (∀ v, ((N.star v).filter fun e => e ∈ P).card = 1) ∧
      (N.restrict (Subtype.val : ↥(Pᶜ) → E)).graph.Connected := by
  let root := N.blackEndpoint M.black e
  have hr := (N.blackEndpoint_spec M.black M.coloring e).1
  have he : e ∈ N.star root := (N.mem_star _ _).mpr (N.blackEndpoint_spec M.black M.coloring e).2
  obtain ⟨i,_,hi⟩ := Finset.mem_image.mp ((M.face root).edge_range.symm ▸ he)
  obtain ⟨Q,hQ⟩ := M.forest_pair (M.pair_nonempty h3 htr root hr)
  simpa only [hi] using M.recover_connected_complement Q hr hQ i
end
end Barnette.Network
namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V E : Type*} [Fintype V] [Fintype E] (N : Network V E)

def capMap (_N : Network V E) (A : Finset V) (v : V) : Option A := if h : v ∈ A then some ⟨v,h⟩ else none

omit [Fintype V] [Fintype E] in
@[simp] lemma capMap_some (A : Finset V) (v : A) : N.capMap A v.val = some v := by
  simp [capMap,v.property]
omit [Fintype V] [Fintype E] in
@[simp] lemma capMap_eq_none (A : Finset V) (v : V) : N.capMap A v = none ↔ v ∉ A := by
  simp [capMap]
omit [Fintype V] [Fintype E] in
@[simp] lemma capMap_eq_some (A : Finset V) (v : V) (w : A) :
    N.capMap A v = some w ↔ v = w.val := by
  by_cases h : v ∈ A
  · simp [capMap,h,Subtype.ext_iff]
  · simp only [capMap,dite_eq_right h,reduceCtorEq,false_iff]
    exact fun he => h (he ▸ w.property)

omit [Fintype E] in
lemma capMap_surjective (A : Finset V) (hA : Aᶜ.Nonempty) : Function.Surjective (N.capMap A) := by
  rintro (_|v)
  · obtain ⟨v,hv⟩ := hA
    exact ⟨v,(N.capMap_eq_none A v).mpr (Finset.mem_compl.mp hv)⟩
  · exact ⟨v.val,N.capMap_some A v⟩

abbrev cap (A : Finset V) : Network (Option A) (N.regionEdges A) :=
  (N.mapVertices (N.capMap A)).restrict Subtype.val

omit [Fintype V] in
lemma cap_loopless (hN : N.Simple) (A : Finset V) (e : N.regionEdges A) :
    (N.cap A).tail e ≠ (N.cap A).head e := by
  change N.capMap A (N.tail e.val) ≠ N.capMap A (N.head e.val)
  intro he
  rcases (N.mem_regionEdges A e.val).mp e.property with ht|hh
  · have ht' := N.capMap_some A ⟨N.tail e.val,ht⟩
    rw [ht'] at he
    exact hN.loopless e.val (((N.capMap_eq_some A _ _).mp he.symm).symm)
  · have hh' := N.capMap_some A ⟨N.head e.val,hh⟩
    rw [hh'] at he
    exact hN.loopless e.val ((N.capMap_eq_some A _ _).mp he)

omit [Fintype V] in
lemma cap_star_some (A : Finset V) (v : A) :
    ((N.cap A).star (some v)).image Subtype.val = N.star v.val := by
  ext e
  simp only [Finset.mem_image,mem_star,Incident]
  constructor
  · rintro ⟨k,hk,rfl⟩
    exact hk.elim (fun h => Or.inl ((N.capMap_eq_some A _ v).mp h))
      (fun h => Or.inr ((N.capMap_eq_some A _ v).mp h))
  · intro he
    have hm : e ∈ N.regionEdges A := (N.mem_regionEdges A e).mpr
      (he.elim (fun h => Or.inl (h ▸ v.property)) (fun h => Or.inr (h ▸ v.property)))
    refine ⟨⟨e,hm⟩,?_,rfl⟩
    exact he.elim (fun h => Or.inl ((N.capMap_eq_some A _ v).mpr h))
      (fun h => Or.inr ((N.capMap_eq_some A _ v).mpr h))

omit [Fintype V] in
lemma cap_star_none (A : Finset V) :
    ((N.cap A).star none).image Subtype.val = N.cut A := by
  ext e
  simp only [Finset.mem_image,mem_star,Incident,mem_cut]
  constructor
  · rintro ⟨k,hk,rfl⟩
    have hm := (N.mem_regionEdges A k.val).mp k.property
    change N.capMap A (N.tail k.val) = none ∨ N.capMap A (N.head k.val) = none at hk
    simp only [capMap_eq_none] at hk
    tauto
  · intro he
    have hm : e ∈ N.regionEdges A := (N.mem_regionEdges A e).mpr (he.elim (Or.inl ∘ And.left) (Or.inr ∘ And.left))
    refine ⟨⟨e,hm⟩,?_,rfl⟩
    change N.capMap A (N.tail e) = none ∨ N.capMap A (N.head e) = none
    simp only [capMap_eq_none]
    tauto

lemma cap_star_card (hN : N.Simple) (hc : N.graph.IsRegularOfDegree 3)
    (A : Finset V) (hA : (N.cut A).card = 3) (v : Option A) : ((N.cap A).star v).card = 3 := by
  rw [← Finset.card_image_of_injective _ Subtype.val_injective]
  cases v with
  | none => rw [N.cap_star_none,hA]
  | some v => rw [N.cap_star_some,N.card_star hN,hc v.val]

def capPreimage (A : Finset V) (B : Finset (Option A)) : Finset V :=
  Finset.univ.filter fun v => N.capMap A v ∈ B

omit [Fintype E] in
@[simp] lemma mem_capPreimage (A : Finset V) (B : Finset (Option A)) (v : V) :
    v ∈ N.capPreimage A B ↔ N.capMap A v ∈ B := by simp [capPreimage]

lemma cap_cut (A : Finset V) (B : Finset (Option A)) :
    ((N.cap A).cut B).image Subtype.val = N.cut (N.capPreimage A B) := by
  ext e
  simp only [Finset.mem_image,mem_cut,mem_capPreimage]
  constructor
  · rintro ⟨k,hk,rfl⟩
    exact hk
  · intro he
    have hm : e ∈ N.regionEdges A := by
      apply (N.mem_regionEdges A e).mpr
      by_contra hn
      have ht := (N.capMap_eq_none A (N.tail e)).mpr (not_or.mp hn).1
      have hh := (N.capMap_eq_none A (N.head e)).mpr (not_or.mp hn).2
      rw [ht,hh] at he
      tauto
    exact ⟨⟨e,hm⟩,he,rfl⟩

lemma cap_threeConnected (hN : N.ThreeEdgeConnected) (A : Finset V) (hA : Aᶜ.Nonempty) :
    (N.cap A).ThreeEdgeConnected := by
  intro B hB hBc
  rw [← Finset.card_image_of_injective _ Subtype.val_injective,N.cap_cut]
  apply hN
  · obtain ⟨v,hv⟩ := hB
    obtain ⟨w,rfl⟩ := N.capMap_surjective A hA v
    exact ⟨w,(N.mem_capPreimage A B w).mpr hv⟩
  · obtain ⟨v,hv⟩ := hBc
    obtain ⟨w,rfl⟩ := N.capMap_surjective A hA v
    exact ⟨w,by simpa only [Finset.mem_compl,mem_capPreimage] using hv⟩

lemma ThreeEdgeConnected.connected [Nonempty V] (h : N.ThreeEdgeConnected) : N.graph.Connected := by
  apply N.connected_of_kernel_constants
  intro f hf v w
  by_contra hn
  let A := Finset.univ.filter fun z => f z = f v
  have hA : (N.cut A).card = 0 := by
    apply Finset.card_eq_zero.mpr
    apply Finset.eq_empty_iff_forall_notMem.mpr
    intro e he
    have hh := (N.gradient_eq_zero_iff f).mp hf e
    have hc := (N.mem_cut A e).mp he
    simp only [A,Finset.mem_filter,Finset.mem_univ,true_and,hh] at hc
    tauto
  have hc := h A ⟨v,by simp [A]⟩ ⟨w,by simp [A,Ne.symm hn]⟩
  omega

lemma threeCut_bond (h : N.ThreeEdgeConnected) (A : Finset V) (hA : (N.cut A).card = 3) : N.Bond A := by
  refine ⟨Finset.card_pos.mp (by omega),?_⟩
  intro B hB
  by_cases hn : (N.cut B).Nonempty
  · right
    obtain ⟨e,he⟩ := hn
    have hc := (N.mem_cut B e).mp he
    have hi : B.Nonempty := hc.elim (fun h => ⟨_,h.1⟩) (fun h => ⟨_,h.1⟩)
    have ho : Bᶜ.Nonempty := hc.elim (fun h => ⟨_,Finset.mem_compl.mpr h.2⟩) (fun h => ⟨_,Finset.mem_compl.mpr h.2⟩)
    exact Finset.eq_of_subset_of_card_le hB (by have hh := h B hi ho; omega)
  · exact Or.inl (Finset.not_nonempty_iff_eq_empty.mp hn)

omit [Fintype V] [Fintype E] in
lemma cap_connectedFibers (A : Finset V)
    (hc : (N.graph.induce {v | v ∉ A}).Connected) : N.ConnectedFibers (N.capMap A) := by
  intro v w he
  by_cases hv : v ∈ A
  · have hv' := N.capMap_some A ⟨v,hv⟩
    rw [hv'] at he
    have hh : w = v := (N.capMap_eq_some A _ _).mp he.symm
    subst w
    exact SimpleGraph.Reachable.refl v
  · have hw : w ∉ A := (N.capMap_eq_none A w).mp (he.symm.trans ((N.capMap_eq_none A v).mpr hv))
    let f : (N.graph.induce {v | v ∉ A}) →g (N.restrict (Subtype.val : N.internal (N.capMap A) → E)).graph := {
      toFun := Subtype.val
      map_rel' := by
        intro x y hxy
        obtain ⟨hne,e,hee⟩ := hxy
        change (N.tail e = x.val ∧ N.head e = y.val) ∨ (N.tail e = y.val ∧ N.head e = x.val) at hee
        have hm : e ∈ N.internal (N.capMap A) := by
          rcases hee with ⟨ht,hh⟩|⟨ht,hh⟩ <;>
            change N.capMap A (N.tail e) = N.capMap A (N.head e) <;>
            rw [ht,hh,(N.capMap_eq_none A _).mpr x.property,(N.capMap_eq_none A _).mpr y.property]
        exact ⟨hne,⟨e,hm⟩,hee⟩ }
    exact (hc ⟨v,hv⟩ ⟨w,hw⟩).map f
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 simple_of_cubic_stars (hl : ∀ e, N.tail e ≠ N.head e)
    (hc : ∀ v, (N.star v).card = 3) (h3 : N.ThreeEdgeConnected)
    (hV : 3 ≤ Fintype.card V) : N.Simple := by
  refine ⟨hl,?_⟩
  intro e f hef
  by_contra hne
  dsimp only at hef
  let a := N.tail e
  let b := N.head e
  have hab : a ≠ b := hl e
  have hfa : N.Incident f a := (N.incident_iff_mem_pair f a).mpr (by rw [← hef]; simp [a])
  have hfb : N.Incident f b := (N.incident_iff_mem_pair f b).mpr (by rw [← hef]; simp [b])
  have hsa : ({e,f} : Finset E) ⊆ N.star a := by
    intro k hk
    rcases Finset.mem_insert.mp hk with rfl|hk
    · exact (N.mem_star _ _).mpr (Or.inl rfl)
    · have hk' := Finset.mem_singleton.mp hk
      subst k
      exact (N.mem_star _ _).mpr hfa
  have hsb : ({e,f} : Finset E) ⊆ N.star b := by
    intro k hk
    rcases Finset.mem_insert.mp hk with rfl|hk
    · exact (N.mem_star _ _).mpr (Or.inr rfl)
    · have hk' := Finset.mem_singleton.mp hk
      subst k
      exact (N.mem_star _ _).mpr hfb
  have hein : e ∉ N.cut {a,b} := by simp [mem_cut,a,b]
  have hfin : f ∉ N.cut {a,b} := by
    have hh := Sym2.eq_iff.mp hef
    rcases hh with ⟨ht,hh⟩|⟨ht,hh⟩ <;> simp [mem_cut,← ht,← hh,a,b]
  have hsub : N.cut {a,b} ⊆ (N.star a \ {e,f}) ∪ (N.star b \ {e,f}) := by
    intro k hk
    have hke : k ∉ ({e,f} : Finset E) := by
      simp only [Finset.mem_insert,Finset.mem_singleton,not_or]
      exact ⟨fun hh => hein (hh ▸ hk),fun hh => hfin (hh ▸ hk)⟩
    have hi : N.Incident k a ∨ N.Incident k b := by
      have hh := (N.mem_cut {a,b} k).mp hk
      simp only [Finset.mem_insert,Finset.mem_singleton] at hh
      simp only [Incident]
      tauto
    exact hi.elim (fun hi => Finset.mem_union_left _ (Finset.mem_sdiff.mpr ⟨(N.mem_star _ _).mpr hi,hke⟩))
      (fun hi => Finset.mem_union_right _ (Finset.mem_sdiff.mpr ⟨(N.mem_star _ _).mpr hi,hke⟩))
  have hcard := (Finset.card_le_card hsub).trans (Finset.card_union_le _ _)
  rw [Finset.card_sdiff_of_subset hsa,Finset.card_sdiff_of_subset hsb,hc,hc] at hcard
  simp only [Finset.card_pair hne] at hcard
  have hout : ({a,b} : Finset V)ᶜ.Nonempty := by
    apply Finset.card_pos.mp
    rw [Finset.card_compl,Finset.card_pair hab]
    omega
  have hh := h3 {a,b} (by simp) hout
  omega

lemma cap_simple (hN : N.Simple) (hc : N.graph.IsRegularOfDegree 3) (h3 : N.ThreeEdgeConnected)
    (A : Finset V) (hcut : (N.cut A).card = 3) (hA : 2 ≤ A.card) (ho : Aᶜ.Nonempty) :
    (N.cap A).Simple := by
  apply (N.cap A).simple_of_cubic_stars (N.cap_loopless hN A)
    (N.cap_star_card hN hc A hcut) (N.cap_threeConnected h3 A ho)
  simp only [Fintype.card_option,Fintype.card_coe]
  omega

lemma cap_cubic (hN : N.Simple) (hc : N.graph.IsRegularOfDegree 3) (h3 : N.ThreeEdgeConnected)
    (A : Finset V) (hcut : (N.cut A).card = 3) (hA : 2 ≤ A.card) (ho : Aᶜ.Nonempty) :
    (N.cap A).graph.IsRegularOfDegree 3 := by
  intro v
  rw [← (N.cap A).card_star (N.cap_simple hN hc h3 A hcut hA ho)]
  exact N.cap_star_card hN hc A hcut v

lemma threeCut_black_card (hN : N.Simple) (hc : N.graph.IsRegularOfDegree 3)
    (black : V → Prop) (hb : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (A : Finset V) (hA : (N.cut A).card = 3) :
    (N.blackCut black A).card = 0 ∨ (N.blackCut black A).card = 3 := by
  have h₁ := N.cubic_region_count hN hc A
  have h₂ := N.cubic_black_region_count hN hc black hb A
  have h₃ := Finset.card_le_card (Finset.filter_subset (fun e => N.blackEndpoint black e ∈ A) (N.cut A))
  change (N.blackCut black A).card ≤ (N.cut A).card at h₃
  omega

def capBlack (black : V → Prop) (A : Finset V) : Option A → Prop
  | none => (N.blackCut black A).card = 0
  | some v => black v.val

lemma cap_coloring (hN : N.Simple) (hc : N.graph.IsRegularOfDegree 3)
    (black : V → Prop) (hb : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (A : Finset V) (hA : (N.cut A).card = 3) :
    ∀ e, N.capBlack black A ((N.cap A).tail e) ↔ ¬N.capBlack black A ((N.cap A).head e) := by
  intro e
  have hm := (N.mem_regionEdges A e.val).mp e.property
  have hcol := hb e.val
  have hboundary : e.val ∈ N.cut A →
      ((N.blackCut black A).card = 0 ↔ N.blackEndpoint black e.val ∉ A) := by
    intro he
    rcases N.threeCut_black_card hN hc black hb A hA with hz|hf
    · have hn : N.blackEndpoint black e.val ∉ A := by
        intro hh
        have hh' : e.val ∈ N.blackCut black A := Finset.mem_filter.mpr ⟨he,hh⟩
        rw [Finset.card_eq_zero.mp hz] at hh'
        exact Finset.notMem_empty _ hh'
      simp [hz,hn]
    · have heq : N.blackCut black A = N.cut A :=
        Finset.eq_of_subset_of_card_le (Finset.filter_subset _ _) (by omega)
      have hh := (Finset.mem_filter.mp (show e.val ∈ N.blackCut black A by rw [heq]; exact he)).2
      simp [hf,hh]
  change N.capBlack black A (N.capMap A (N.tail e.val)) ↔ ¬N.capBlack black A (N.capMap A (N.head e.val))
  by_cases ht : N.tail e.val ∈ A <;> by_cases hh : N.head e.val ∈ A
  · simpa only [capMap,dite_eq_left ht,dite_eq_left hh,capBlack] using hcol
  · have he : e.val ∈ N.cut A := (N.mem_cut A e.val).mpr (Or.inl ⟨ht,hh⟩)
    simp only [capMap,dite_eq_left ht,dite_eq_right hh,capBlack,hboundary he]
    by_cases hb' : black (N.tail e.val) <;> simp [blackEndpoint,hb',ht,hh]
  · have he : e.val ∈ N.cut A := (N.mem_cut A e.val).mpr (Or.inr ⟨hh,ht⟩)
    simp only [capMap,dite_eq_right ht,dite_eq_left hh,capBlack,hboundary he]
    by_cases hb' : black (N.tail e.val) <;> simp [blackEndpoint,hb',ht,hh] at hcol ⊢ <;> tauto
  · exact (hm.elim ht hh).elim
end
end Barnette.Network
namespace Barnette.Network
noncomputable section
open scoped Classical
variable {V E : Type*} [Fintype V] [Fintype E] (N : Network V E)

omit [Fintype V] in
lemma boundary_range_restrict (s : Set E) :
    (N.restrict (Subtype.val : s → E)).boundary.range =
      Submodule.span ℝ (N.incidence.col '' s) := by
  let : DecidableEq s := Classical.decEq _
  rw [boundary, Matrix.range_toLin']
  congr 1
  ext x
  constructor
  · rintro ⟨e, rfl⟩
    exact ⟨e.val, e.property, rfl⟩
  · rintro ⟨e, he, rfl⟩
    exact ⟨⟨e, he⟩, rfl⟩

omit [Fintype V] in

lemma exists_independent_restriction (s : Set E) :
    ∃ r ⊆ s,
      Function.Injective (N.restrict (Subtype.val : r → E)).boundary ∧
      (N.restrict (Subtype.val : r → E)).boundary.range =
        (N.restrict (Subtype.val : s → E)).boundary.range := by
  obtain ⟨r, hrs, _, hspan, hi⟩ := exists_linearIndepOn_extension
    (v := N.incidence.col) (linearIndepOn_empty ℝ _) (Set.empty_subset s)
  refine ⟨r, hrs, ?_, ?_⟩
  · exact Matrix.mulVec_injective_iff.mpr hi
  · rw [N.boundary_range_restrict, N.boundary_range_restrict]
    apply le_antisymm
    · exact Submodule.span_mono (Set.image_mono hrs)
    · exact Submodule.span_le.mpr hspan

variable {F : Type*} [Fintype F] (D : Network F E)

lemma duality_of_first_exact (hN : N.graph.Connected) (hD : D.graph.Connected)
    (he : N.boundary.ker = D.gradient.range) : N.Duality D := by
  have ho : ∀ f, N.boundary (D.gradient f) = 0 := by
    intro f
    change D.gradient f ∈ N.boundary.ker
    rw [he]
    exact ⟨f, rfl⟩
  have h₁ := N.dim_cycles hN
  rw [he] at h₁
  have h₂ := D.rank_gradient hD
  exact N.duality_of_orth_card D hN hD (by omega) ho

end
end Barnette.Network

end OAI