import OAI.Combinatorics.Hamiltonian.Forest

namespace OAI

/-! Contraction and deletion of finite oriented dual networks. -/

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)

def inducedEdges (U : Finset F) : Finset E :=
  Finset.univ.filter fun e => D.tail e ∈ U ∧ D.head e ∈ U

omit [Fintype F] in
@[simp] lemma mem_inducedEdges (U : Finset F) (e : E) :
    e ∈ D.inducedEdges U ↔ D.tail e ∈ U ∧ D.head e ∈ U := by
  simp [inducedEdges]

def inducedNetwork (U : Finset F) : Network U (D.inducedEdges U) where
  tail e := ⟨D.tail e.val,((D.mem_inducedEdges U e.val).mp e.property).1⟩
  head e := ⟨D.head e.val,((D.mem_inducedEdges U e.val).mp e.property).2⟩

omit [Fintype F] in
lemma inducedNetwork_map (U : Finset F) :
    (D.inducedNetwork U).mapVertices Subtype.val =
      D.restrict (Subtype.val : D.inducedEdges U → E) := rfl

lemma inducedNetwork_boundary (U : Finset F) (x : D.inducedEdges U → ℝ) :
    push (Subtype.val : U → F) ((D.inducedNetwork U).boundary x) =
      D.boundary (push Subtype.val x) := by
  rw [← boundary_mapVertices,D.inducedNetwork_map,boundary_restrict]

def regions (U : Finset F) : Network V {e // e ∉ D.inducedEdges U} :=
  N.restrict Subtype.val

abbrev Regions (U : Finset F) := (N.regions D U).Components

def regionQuotient (U : Finset F) : Network (N.Regions D U) (D.inducedEdges U) :=
  (N.mapVertices (N.regions D U).componentMap).restrict Subtype.val

omit [Fintype V] [Fintype F] in
lemma regionQuotient_connected (hN : N.graph.Connected) (U : Finset F) :
    (N.regionQuotient D U).graph.Connected := by
  let H := N.regions D U
  let q := H.componentMap
  let L := N.regionQuotient D U
  have : Nonempty V := hN.nonempty
  have : Nonempty H.Components := Nonempty.map q inferInstance
  apply L.connected_of_kernel_constants
  intro f hf a b
  obtain ⟨a',rfl⟩ := H.componentMap_surjective a
  obtain ⟨b',rfl⟩ := H.componentMap_surjective b
  apply N.gradient_zero_reachable (f := pull q f) _ (hN a' b')
  ext e
  by_cases he : e ∈ D.inducedEdges U
  · exact congrFun hf ⟨e,he⟩
  · exact congrFun (H.gradient_componentMap f) ⟨e,he⟩

omit [Fintype V] in

lemma induced_cycles_eq_regions (h : N.Duality D) (U : Finset F) :
    (D.inducedNetwork U).boundary.ker = (N.regionQuotient D U).gradient.range := by
  let H := N.regions D U
  let q := H.componentMap
  ext x
  constructor
  · intro hx
    have hx' : (D.inducedNetwork U).boundary x = 0 := hx
    have hz : D.boundary (push (Subtype.val : D.inducedEdges U → E) x) = 0 := by
      rw [← D.inducedNetwork_boundary,hx',map_zero]
    obtain ⟨g,hg⟩ : ∃ g, N.gradient g = push (Subtype.val : D.inducedEdges U → E) x := by
      have hh : push (Subtype.val : D.inducedEdges U → E) x ∈ D.boundary.ker := hz
      rw [h.dual_cycles_eq_cuts] at hh
      exact hh
    have hgH : H.gradient g = 0 := by
      ext e
      change N.gradient g e.val = 0
      rw [hg]
      exact push_eq_zero_outside x (by simpa using e.property)
    obtain ⟨f,hf⟩ := H.descends_components g hgH
    refine ⟨f,?_⟩
    change pull (Subtype.val : D.inducedEdges U → E) (N.gradient (pull q f)) = x
    rw [hf,hg,pull_push_injective Subtype.val_injective]
  · rintro ⟨f,rfl⟩
    have hext : push (Subtype.val : D.inducedEdges U → E)
        ((N.regionQuotient D U).gradient f) = N.gradient (pull q f) := by
      ext e
      by_cases he : e ∈ D.inducedEdges U
      · exact push_subtype_apply (D.inducedEdges U) _ ⟨e,he⟩
      · rw [push_eq_zero_outside _ (by simpa using he)]
        exact (congrFun (H.gradient_componentMap f) ⟨e,he⟩).symm
    have hz : push (Subtype.val : U → F)
        ((D.inducedNetwork U).boundary ((N.regionQuotient D U).gradient f)) = 0 := by
      rw [D.inducedNetwork_boundary,hext]
      exact h.dual_conserved_gradient N D _
    have hz' := congrArg (pull (Subtype.val : U → F)) hz
    rw [pull_push_injective Subtype.val_injective,map_zero] at hz'
    exact hz'

omit [Fintype F] in
lemma rank_boundary_le [Nonempty V] :
    Module.finrank ℝ N.boundary.range + 1 ≤ Fintype.card V := by
  have hle : (constant (V := V)).range ≤ N.gradient.ker := by
    rintro _ ⟨c,rfl⟩
    exact N.gradient_const c
  have hi : Function.Injective (constant (V := V)) := by
    intro a b hh
    exact congrFun hh (Classical.choice inferInstance)
  have hk : 1 ≤ Module.finrank ℝ N.gradient.ker := by
    have hh := Submodule.finrank_mono hle
    rwa [LinearMap.finrank_range_of_inj hi,Module.finrank_self] at hh
  have hr : Module.finrank ℝ N.boundary.range = Module.finrank ℝ N.gradient.range := by
    rw [N.gradient_matrix,boundary,Matrix.toLin'_apply',Matrix.toLin'_apply',
      ← Matrix.rank,← Matrix.rank,Matrix.rank_transpose]
  have hh := N.gradient.finrank_range_add_finrank_ker
  rw [Module.finrank_pi] at hh
  omega

lemma induced_euler_bound (h : N.Duality D) (U : Finset F) (hU : U.Nonempty) :
    (D.inducedEdges U).card + 2 ≤ U.card + Fintype.card (N.Regions D U) := by
  have : Nonempty U := by obtain ⟨u,hu⟩ := hU; exact ⟨⟨u,hu⟩⟩
  have hr := (D.inducedNetwork U).rank_boundary_le
  have hk := (D.inducedNetwork U).boundary.finrank_range_add_finrank_ker
  rw [Module.finrank_pi,Fintype.card_coe] at hk
  rw [N.induced_cycles_eq_regions D h U] at hk
  have ho := (N.regionQuotient D U).rank_gradient (N.regionQuotient_connected D h.connected U)
  simp only [Fintype.card_coe] at hr
  omega

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
lemma star_count (hN : N.Simple) (v : V) :
    (N.star v).card = ∑ e, ((if N.tail e = v then 1 else 0) +
      (if N.head e = v then 1 else 0)) := by
  rw [star,Finset.card_filter]
  apply Finset.sum_congr rfl
  intro e _
  have hne := hN.loopless e
  by_cases ht : N.tail e = v <;> by_cases hh : N.head e = v <;> simp_all [Incident]

lemma weighted_stars (hN : N.Simple) (f : V → ℤ) :
    ∑ v, f v * (N.star v).card = ∑ e, (f (N.tail e) + f (N.head e)) := by
  simp only [N.star_count hN,Nat.cast_sum,Nat.cast_add,Nat.cast_ite,Nat.cast_one,
    Nat.cast_zero,Finset.mul_sum,mul_add,mul_ite,mul_one,mul_zero]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro e _
  simp [Finset.sum_add_distrib,eq_comm]

def colorSign (black : V → Prop) (v : V) : ℤ := if black v then 1 else -1

omit [Fintype V] [Fintype E] in
lemma colorSign_add (black : V → Prop)
    (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) (e : E) :
    colorSign black (N.tail e) + colorSign black (N.head e) = 0 := by
  have he := hc e
  by_cases ht : black (N.tail e) <;> by_cases hh : black (N.head e) <;>
    simp_all [colorSign]

lemma colorSign_sum (hN : N.Simple) (h3 : N.graph.IsRegularOfDegree 3)
    (black : V → Prop) (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e)) :
    ∑ v, colorSign black v = 0 := by
  have hs := N.weighted_stars hN (colorSign black)
  have hv : ∀ v, (N.star v).card = 3 := fun v => (N.card_star hN v).trans (h3 v)
  simp only [hv,N.colorSign_add black hc,Finset.sum_const_zero,Nat.cast_ofNat,
    ← Finset.sum_mul] at hs
  omega

def regionShore (U : Finset F) (q : N.Regions D U) : Finset V :=
  Finset.univ.filter fun v => (N.regions D U).componentMap v = q

omit [Fintype F] in
@[simp] lemma mem_regionShore (U : Finset F) (q : N.Regions D U) (v : V) :
    v ∈ N.regionShore D U q ↔ (N.regions D U).componentMap v = q := by
  simp [regionShore]

omit [Fintype F] in
lemma regionShore_nonempty (U : Finset F) (q : N.Regions D U) :
    (N.regionShore D U q).Nonempty := by
  obtain ⟨v,hv⟩ := (N.regions D U).componentMap_surjective q
  exact ⟨v,(N.mem_regionShore D U q v).mpr hv⟩

omit [Fintype F] in
lemma regionShore_off_edge (U : Finset F) (q : N.Regions D U) {e : E}
    (he : e ∉ D.inducedEdges U) :
    N.tail e ∈ N.regionShore D U q ↔ N.head e ∈ N.regionShore D U q := by
  simp only [N.mem_regionShore]
  have hh : (N.regions D U).componentMap (N.tail e) =
      (N.regions D U).componentMap (N.head e) :=
    SimpleGraph.ConnectedComponent.sound ((N.regions D U).edge_reachable ⟨e,he⟩)
  rw [hh]

def rim (U : Finset F) (q : N.Regions D U) : ℕ :=
  ∑ e ∈ D.inducedEdges U, ((if N.tail e ∈ N.regionShore D U q then 1 else 0) +
    (if N.head e ∈ N.regionShore D U q then 1 else 0))

def blackRim (black : V → Prop) (U : Finset F) (q : N.Regions D U) : ℕ :=
  ∑ e ∈ D.inducedEdges U, ((if N.tail e ∈ N.regionShore D U q ∧ black (N.tail e) then 1 else 0) +
    (if N.head e ∈ N.regionShore D U q ∧ black (N.head e) then 1 else 0))

def regionBalance (black : V → Prop) (U : Finset F) (q : N.Regions D U) : ℤ :=
  ∑ v ∈ N.regionShore D U q, colorSign black v

omit [Fintype F] in
lemma blackRim_le (black : V → Prop) (U : Finset F) (q : N.Regions D U) :
    N.blackRim D black U q ≤ N.rim D U q := by
  apply Finset.sum_le_sum
  intro e _
  by_cases ht : N.tail e ∈ N.regionShore D U q <;>
    by_cases hh : N.head e ∈ N.regionShore D U q <;>
    by_cases bt : black (N.tail e) <;> by_cases bh : black (N.head e) <;> simp [ht,hh,bt,bh]

omit [Fintype F] in
lemma region_balance_rim (hN : N.Simple) (h3 : N.graph.IsRegularOfDegree 3)
    (black : V → Prop) (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (U : Finset F) (q : N.Regions D U) :
    3 * N.regionBalance D black U q = 2 * (N.blackRim D black U q : ℤ) - N.rim D U q := by
  let A := N.regionShore D U q
  let f : V → ℤ := fun v => if v ∈ A then colorSign black v else 0
  have hs := N.weighted_stars hN f
  have hv : ∀ v, (N.star v).card = 3 := fun v => (N.card_star hN v).trans (h3 v)
  have hleft : (∑ v, f v * (N.star v).card) = 3 * N.regionBalance D black U q := by
    simp only [hv,Nat.cast_ofNat,← Finset.sum_mul,f]
    rw [← Finset.sum_filter]
    simp only [Finset.filter_mem_eq_inter,Finset.univ_inter,regionBalance,A,mul_comm]
  rw [hleft] at hs
  have hreduce : (∑ e, (f (N.tail e) + f (N.head e))) =
      ∑ e ∈ D.inducedEdges U, (f (N.tail e) + f (N.head e)) := by
    symm
    apply Finset.sum_subset (Finset.subset_univ _)
    intro e _ he
    have heq := N.regionShore_off_edge D U q he
    simp only [f,A,heq]
    split_ifs
    · exact N.colorSign_add black hc e
    · rfl
  rw [hreduce] at hs
  rw [hs]
  simp only [blackRim,rim,Nat.cast_sum,Nat.cast_add,Nat.cast_ite,Nat.cast_one,
    Nat.cast_zero,Finset.mul_sum,← Finset.sum_sub_distrib]
  apply Finset.sum_congr rfl
  intro e _
  simp only [f,A,colorSign]
  by_cases ht : N.tail e ∈ N.regionShore D U q <;>
    by_cases hh : N.head e ∈ N.regionShore D U q <;>
    by_cases bt : black (N.tail e) <;> by_cases bh : black (N.head e) <;> norm_num [ht,hh,bt,bh]

omit [Fintype F] in
lemma sum_rim (U : Finset F) :
    ∑ q : N.Regions D U, N.rim D U q = 2 * (D.inducedEdges U).card := by
  simp only [rim]
  rw [Finset.sum_comm]
  simp [N.mem_regionShore,Finset.sum_add_distrib,Nat.mul_comm]

omit [Fintype F] in
lemma sum_regionBalance (hN : N.Simple) (h3 : N.graph.IsRegularOfDegree 3)
    (black : V → Prop) (hc : ∀ e, black (N.tail e) ↔ ¬black (N.head e))
    (U : Finset F) : ∑ q : N.Regions D U, N.regionBalance D black U q = 0 := by
  simp only [regionBalance,regionShore,Finset.sum_filter]
  rw [Finset.sum_comm]
  simp only [Finset.sum_ite_eq,Finset.mem_univ,ite_true]
  exact N.colorSign_sum hN h3 black hc

lemma rim_defect (b d : ℕ) (β : ℤ) (hb : b ≤ d) (hd : 4 ≤ d)
    (hβ : 3*β = 2*(b:ℤ) - d) : β ≤ (d:ℤ)-4 := by
  by_cases h4 : d = 4
  · subst d; omega
  by_cases h5 : d = 5
  · subst d; omega
  have h6 : (6:ℤ) ≤ d := by omega
  have hbd : (b:ℤ) ≤ d := by exact_mod_cast hb
  omega

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)

def ThreeEdgeConnected : Prop := ∀ A : Finset V, A.Nonempty → Aᶜ.Nonempty → 3 ≤ (N.cut A).card

def TrivialThreeCuts : Prop := ∀ A : Finset V, (N.cut A).card = 3 → A.card = 1 ∨ Aᶜ.card = 1

omit [Fintype F] in
lemma region_cut_subset (U : Finset F) (q : N.Regions D U) :
    N.cut (N.regionShore D U q) ⊆ D.inducedEdges U := by
  intro e he
  by_contra hn
  have hh := N.regionShore_off_edge D U q hn
  have hc := (N.mem_cut _ _).mp he
  exact hc.elim (fun h => h.2 (hh.mp h.1)) (fun h => h.2 (hh.mpr h.1))

omit [Fintype F] in
lemma rim_cut_count (U : Finset F) (q : N.Regions D U) :
    N.rim D U q = (N.cut (N.regionShore D U q)).card +
      2 * ((D.inducedEdges U).filter fun e =>
        N.tail e ∈ N.regionShore D U q ∧ N.head e ∈ N.regionShore D U q).card := by
  have hcut : N.cut (N.regionShore D U q) =
      (D.inducedEdges U).filter fun e => e ∈ N.cut (N.regionShore D U q) := by
    ext e
    simp only [Finset.mem_filter]
    exact ⟨fun he => ⟨N.region_cut_subset D U q he,he⟩,And.right⟩
  rw [hcut]
  simp only [rim,Finset.card_filter,Finset.mul_sum,← Finset.sum_add_distrib,N.mem_cut]
  apply Finset.sum_congr rfl
  intro e _
  by_cases ht : N.tail e ∈ N.regionShore D U q <;>
    by_cases hh : N.head e ∈ N.regionShore D U q <;> simp [ht,hh]

omit [Fintype F] in
lemma cut_le_rim (U : Finset F) (q : N.Regions D U) :
    (N.cut (N.regionShore D U q)).card ≤ N.rim D U q := by
  rw [N.rim_cut_count]
  omega

omit [Fintype F] in
lemma rim_of_shore_univ (U : Finset F) (q : N.Regions D U)
    (hq : N.regionShore D U q = Finset.univ) :
    N.rim D U q = 2 * (D.inducedEdges U).card := by
  simp [rim,hq,Nat.mul_comm]

omit [Fintype F] in
lemma rim_ge_three (hN : N.ThreeEdgeConnected) (U : Finset F)
    (hm : 3 ≤ (D.inducedEdges U).card) (q : N.Regions D U) : 3 ≤ N.rim D U q := by
  by_cases hq : N.regionShore D U q = Finset.univ
  · rw [N.rim_of_shore_univ D U q hq]; omega
  · have hA := N.regionShore_nonempty D U q
    have hAc : (N.regionShore D U q)ᶜ.Nonempty := by
      apply Finset.nonempty_iff_ne_empty.mpr
      intro he
      exact hq ((Finset.compl_eq_empty_iff _).mp he)
    exact (hN _ hA hAc).trans (N.cut_le_rim D U q)

omit [Fintype F] in
lemma rim_three_cut (hN : N.ThreeEdgeConnected) (U : Finset F)
    (_hm : 3 ≤ (D.inducedEdges U).card) (q : N.Regions D U) (hq : N.rim D U q = 3) :
    (N.cut (N.regionShore D U q)).card = 3 := by
  have hproper : N.regionShore D U q ≠ Finset.univ := by
    intro he
    have hh := N.rim_of_shore_univ D U q he
    omega
  have hAc : (N.regionShore D U q)ᶜ.Nonempty := by
    apply Finset.nonempty_iff_ne_empty.mpr
    intro he
    exact hproper ((Finset.compl_eq_empty_iff _).mp he)
  have hl := hN _ (N.regionShore_nonempty D U q) hAc
  have hu := N.cut_le_rim D U q
  omega

omit [Fintype F] in
lemma rim_three_no_internal (hN : N.ThreeEdgeConnected) (U : Finset F)
    (_hm : 3 ≤ (D.inducedEdges U).card) (q : N.Regions D U) (hq : N.rim D U q = 3)
    {e : E} (he : e ∈ D.inducedEdges U) :
    ¬(N.tail e ∈ N.regionShore D U q ∧ N.head e ∈ N.regionShore D U q) := by
  have hc := N.rim_three_cut D hN U _hm q hq
  have hh := N.rim_cut_count D U q
  have hz : ((D.inducedEdges U).filter fun e =>
      N.tail e ∈ N.regionShore D U q ∧ N.head e ∈ N.regionShore D U q) = ∅ :=
    Finset.card_eq_zero.mp (by omega)
  intro hi
  have hhmem : e ∈ (D.inducedEdges U).filter (fun e =>
      N.tail e ∈ N.regionShore D U q ∧ N.head e ∈ N.regionShore D U q) :=
    Finset.mem_filter.mpr ⟨he,hi⟩
  rw [hz] at hhmem
  exact Finset.notMem_empty _ hhmem

omit [Fintype F] in
lemma singleton_region_star (hN : N.Simple) (U : Finset F) (q : N.Regions D U)
    {v : V} (hq : N.regionShore D U q = {v}) : N.star v ⊆ D.inducedEdges U := by
  intro e he
  by_contra hn
  have hi := (N.mem_star e v).mp he
  have hh := N.regionShore_off_edge D U q hn
  rw [hq] at hh
  simp only [Finset.mem_singleton] at hh
  exact hN.loopless e (hi.elim (fun hv => hv.trans ((hh.mp hv).symm))
    (fun hv => (hh.mpr hv).trans hv.symm))

lemma star_subset_eq (hN : N.Simple) (h3 : N.graph.IsRegularOfDegree 3)
    {v w : V} (hvw : N.star v ⊆ N.star w) : v = w := by
  by_contra hne
  have hc : 1 < (N.star v).card := by rw [N.card_star hN,h3 v]; decide
  obtain ⟨e,he,f,hf,hef⟩ := Finset.one_lt_card.mp hc
  have ends {e : E} (he : e ∈ N.star v) : s(N.tail e,N.head e) = s(v,w) := by
    have hv := (N.mem_star e v).mp he
    have hw := (N.mem_star e w).mp (hvw he)
    apply Sym2.eq_iff.mpr
    rcases hv with hv | hv <;> rcases hw with hw | hw
    · exact (hne (hv.symm.trans hw)).elim
    · exact Or.inl ⟨hv,hw⟩
    · exact Or.inr ⟨hw,hv⟩
    · exact (hne (hv.symm.trans hw)).elim
  exact hef (hN.pair_injective ((ends he).trans (ends hf).symm))

omit [Fintype F] in
lemma complement_singleton_root (hN : N.Simple) (h3 : N.graph.IsRegularOfDegree 3)
    (hcut : N.ThreeEdgeConnected) (U : Finset F) (root : V)
    (hr : N.star root ⊆ D.inducedEdges U) (q : N.Regions D U)
    (hq : N.rim D U q = 3) {v : V} (hv : (N.regionShore D U q)ᶜ = {v}) : v = root := by
  have hm : 3 ≤ (D.inducedEdges U).card := by
    have hh := Finset.card_le_card hr
    rwa [N.card_star hN,h3 root] at hh
  apply (N.star_subset_eq hN h3 (v := root) (w := v) ?_).symm
  intro e he
  have hn := N.rim_three_no_internal D hcut U hm q hq (hr he)
  rw [N.mem_star]
  have ht : N.tail e ∉ N.regionShore D U q ↔ N.tail e = v := by
    rw [← Finset.mem_compl,hv,Finset.mem_singleton]
  have hh : N.head e ∉ N.regionShore D U q ↔ N.head e = v := by
    rw [← Finset.mem_compl,hv,Finset.mem_singleton]
  rcases not_and_or.mp hn with ht' | hh'
  · exact Or.inl (ht.mp ht')
  · exact Or.inr (hh.mp hh')

end
end Barnette.Network

end OAI