import Mathlib
import OAI.Algebra.GroupRing.DegreeTwoSuppression

namespace OAI

noncomputable section

namespace TorsionFreeZeroDivisors.CoreStripping
open PortSubdivision
open scoped Classical
variable {V D : Type*} (Γ : PortGraph V D)

def degree (S : Finset D) (v : V) : ℕ := (S.filter (fun d => Γ.origin d=v)).card

def Symmetric (S : Finset D) : Prop := ∀ d ∈ S, Γ.reverse d ∈ S

def delete (S : Finset D) (d : D) : Finset D := (S.erase d).erase (Γ.reverse d)

lemma delete_subset (S : Finset D) (d : D) : delete Γ S d ⊆ S :=
  (Finset.erase_subset _ _).trans (Finset.erase_subset _ _)

lemma degree_pos (S : Finset D) {d : D} (hd : d∈S) : 0 < degree Γ S (Γ.origin d) := by
  exact Finset.card_pos.mpr ⟨d,Finset.mem_filter.mpr ⟨hd,rfl⟩⟩

lemma leaf_unique (S : Finset D) {d : D} (hd : d∈S) (hleaf : degree Γ S (Γ.origin d)=1)
    {e : D} (he : e∈S) (ho : Γ.origin e=Γ.origin d) : e=d := by
  have hu := Finset.card_eq_one.mp hleaf
  obtain ⟨z,hz⟩ := hu
  have hd' : d∈S.filter (fun e => Γ.origin e=Γ.origin d) := by simp [hd]
  have he' : e∈S.filter (fun e => Γ.origin e=Γ.origin d) := by simp [he,ho]
  rw [hz] at hd' he'
  exact (Finset.mem_singleton.mp he').trans (Finset.mem_singleton.mp hd').symm

lemma leaf_not_loop (S : Finset D) (hs : Symmetric Γ S) {d : D} (hd : d∈S)
    (hleaf : degree Γ S (Γ.origin d)=1) : Γ.origin (Γ.reverse d)≠Γ.origin d := by
  intro he
  exact Γ.reverse_ne d (leaf_unique Γ S hd hleaf (hs d hd) he)

lemma delete_symmetric (S : Finset D) (hs : Symmetric Γ S) (d : D) :
    Symmetric Γ (delete Γ S d) := by
  intro e he
  simp only [delete,Finset.mem_erase] at he ⊢
  refine ⟨?_,?_,hs e he.2.2⟩
  · exact fun h => he.2.1 (Γ.reverse_reverse.injective h)
  · intro h
    have hh := congrArg Γ.reverse h
    rw [Γ.reverse_reverse] at hh
    exact he.1 hh

lemma delete_degree_leaf (S : Finset D) {d : D} (hd : d∈S)
    (hleaf : degree Γ S (Γ.origin d)=1) : degree Γ (delete Γ S d) (Γ.origin d)=0 := by
  apply Finset.card_eq_zero.mpr
  apply Finset.eq_empty_iff_forall_notMem.mpr
  intro e he
  obtain ⟨he,ho⟩ := Finset.mem_filter.mp he
  have heq := leaf_unique Γ S hd hleaf (delete_subset Γ S d he) ho
  exact (Finset.mem_erase.mp (Finset.mem_erase.mp he).2).1 heq

lemma delete_degree_neighbor (S : Finset D) (hs : Symmetric Γ S) {d : D} (hd : d∈S)
    (hleaf : degree Γ S (Γ.origin d)=1) :
    degree Γ (delete Γ S d) (Γ.origin (Γ.reverse d))+1 = degree Γ S (Γ.origin (Γ.reverse d)) := by
  have hn := leaf_not_loop Γ S hs hd hleaf
  have he : (delete Γ S d).filter (fun e => Γ.origin e=Γ.origin (Γ.reverse d)) =
      (S.filter (fun e => Γ.origin e=Γ.origin (Γ.reverse d))).erase (Γ.reverse d) := by
    ext e
    simp only [delete,Finset.mem_filter,Finset.mem_erase]
    constructor
    · tauto
    · rintro ⟨he,hs',ho⟩
      refine ⟨⟨he,?_,hs'⟩,ho⟩
      intro hd'
      subst e
      exact hn ho.symm
  unfold degree
  rw [he]
  exact Finset.card_erase_add_one (by simp [hs d hd])

lemma delete_degree_other (S : Finset D) (d : D) {v : V}
    (hu : v≠Γ.origin d) (hv : v≠Γ.origin (Γ.reverse d)) :
    degree Γ (delete Γ S d) v=degree Γ S v := by
  unfold degree
  congr 1
  ext e
  simp only [delete,Finset.mem_filter,Finset.mem_erase]
  constructor
  · tauto
  · rintro ⟨he,ho⟩
    refine ⟨⟨?_,?_,he⟩,ho⟩
    · intro hh; subst e; exact hv ho.symm
    · intro hh; subst e; exact hu ho.symm

/-- Euler surplus without counting isolated vertices. It equals the sum of
branch excesses minus the number of leaves. -/
def surplus (n : ℕ) : ℤ := if n=0 then 0 else (n:ℤ)-2

lemma surplus_succ (n : ℕ) : surplus (n+1) ≤ surplus n+1 := by
  rcases n with _ | n
  · norm_num [surplus]
  · simp only [surplus,Nat.add_eq_zero_iff,one_ne_zero,and_false,ite_false,Nat.cast_add,Nat.cast_one]
    omega

variable [Fintype V]

def potential (S : Finset D) : ℤ := ∑ v, surplus (degree Γ S v)

lemma delete_potential (S : Finset D) (hs : Symmetric Γ S) {d : D} (hd : d∈S)
    (hleaf : degree Γ S (Γ.origin d)=1) : potential Γ S≤potential Γ (delete Γ S d) := by
  have hn := leaf_not_loop Γ S hs hd hleaf
  have hpoint (v : V) : surplus (degree Γ S v) ≤
      surplus (degree Γ (delete Γ S d) v) + (if v=Γ.origin (Γ.reverse d) then 1 else 0) -
        (if v=Γ.origin d then 1 else 0) := by
    by_cases hu : v=Γ.origin d
    · subst v
      rw [hleaf,delete_degree_leaf Γ S hd hleaf]
      simp [surplus,Ne.symm hn]
    · by_cases hv : v=Γ.origin (Γ.reverse d)
      · subst v
        rw [← delete_degree_neighbor Γ S hs hd hleaf]
        simpa only [ite_eq_left rfl,ite_eq_right hn,ite_true,sub_zero] using surplus_succ
          (degree Γ (delete Γ S d) (Γ.origin (Γ.reverse d)))
      · rw [delete_degree_other Γ S d hu hv,ite_eq_right hu,ite_eq_right hv,add_zero,sub_zero]
  have hsum := Finset.sum_le_sum (fun v (_ : v∈Finset.univ) => hpoint v)
  unfold potential
  simpa only [Finset.sum_sub_distrib,Finset.sum_add_distrib,Finset.sum_ite_eq',
    Finset.mem_univ,ite_true,add_sub_cancel_right] using hsum

/-- Actual repeated leaf deletion. The terminal subgraph has minimum degree
two on every surviving dart; Euler surplus can only increase. -/
theorem exists_core (S : Finset D) (hs : Symmetric Γ S) :
    ∃ Q : Finset D, Q⊆S ∧ Symmetric Γ Q ∧
      (∀ d∈Q, 2≤degree Γ Q (Γ.origin d)) ∧ potential Γ S≤potential Γ Q := by
  induction hn : S.card using Nat.strong_induction_on generalizing S with
  | h n ih =>
    by_cases hleaf : ∃ d∈S, degree Γ S (Γ.origin d)=1
    · obtain ⟨d,hd,hleaf⟩ := hleaf
      let S' := delete Γ S d
      have hlt : S'.card<n := by
        have he : S'.card≤(S.erase d).card := Finset.card_le_card (Finset.erase_subset _ _)
        have ht := Finset.card_erase_lt_of_mem hd
        omega
      obtain ⟨Q,hQS,hQ,hdeg,hpot⟩ := ih S'.card hlt S' (delete_symmetric Γ S hs d) rfl
      exact ⟨Q,hQS.trans (delete_subset Γ S d),hQ,hdeg,
        (delete_potential Γ S hs hd hleaf).trans hpot⟩
    · refine ⟨S,Finset.Subset.refl _,hs,?_,le_refl _⟩
      intro d hd
      have hp := degree_pos Γ S hd
      have hn : degree Γ S (Γ.origin d)≠1 := by aesop
      omega

end TorsionFreeZeroDivisors.CoreStripping

namespace TorsionFreeZeroDivisors.ImageComplexity
open PortSubdivision WeightedPortMoore WeightedCycles CoreStripping
open scoped BigOperators Classical
variable {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)

/-- The actual symmetric subgraph on a specified set of original darts. -/
def restrict (Q : Finset D) (hs : Symmetric Γ Q) : PortGraph V Q where
  origin d := Γ.origin d
  reverse d := ⟨Γ.reverse d,hs d d.property⟩
  reverse_reverse d := Subtype.ext (Γ.reverse_reverse d)
  reverse_ne d h := Γ.reverse_ne d (congrArg Subtype.val h)

def inclusion (Q : Finset D) (hs : Symmetric Γ Q) :
    (restrict Γ Q hs).subdivision →g Γ.subdivision where
  toFun := Sum.map id Subtype.val
  map_rel' := by
    intro a b h
    rcases a with a|a <;> rcases b with b|b
    · exact h
    · exact h
    · exact h
    · exact congrArg Subtype.val h

omit [Fintype V] [Fintype D] in
lemma inclusion_injective (Q : Finset D) (hs : Symmetric Γ Q) :
    Function.Injective (inclusion Γ Q hs) := Sum.map_injective.mpr ⟨Function.injective_id,Subtype.val_injective⟩

omit [Fintype V] [Fintype D] in
lemma restrict_degree (Q : Finset D) (hs : Symmetric Γ Q) (v : V) :
    (DegreeTwoSuppression.out (restrict Γ Q hs).origin v).card=degree Γ Q v := by
  classical
  unfold DegreeTwoSuppression.out degree
  apply Finset.card_bij (fun d _ => d.val)
  · intro d hd
    exact Finset.mem_filter.mpr ⟨d.property,(Finset.mem_filter.mp hd).2⟩
  · intro a _ b _ h
    exact Subtype.ext h
  · intro d hd
    refine ⟨⟨d,(Finset.mem_filter.mp hd).1⟩,?_,rfl⟩
    simp only [Finset.mem_filter,Finset.mem_univ,true_and]
    exact (Finset.mem_filter.mp hd).2

omit [Fintype V] [Fintype D] in
lemma inclusion_weight (Q : Finset D) (hs : Symmetric Γ Q) {a b : V ⊕ Q}
    (p : (restrict Γ Q hs).subdivision.Walk a b) :
    weight (edgeWeight (fun _ : D => (1:ℝ))) (p.map (inclusion Γ Q hs)) =
      weight (edgeWeight (fun _ : Q => (1:ℝ))) p := by
  induction p with
  | nil => rfl
  | @cons a b c h p ih =>
    rw [SimpleGraph.Walk.map_cons,weight_cons,weight_cons,ih]
    congr 1
    cases a <;> cases b <;> rfl

omit [Fintype D] in
/-- Vertexwise counting, including loops through their two different darts. -/
lemma fiber_count (S : Finset D) (P : V → Prop) [DecidablePred P] :
    ∑ v, (if P v then degree Γ S v else 0) = (S.filter (fun d => P (Γ.origin d))).card := by
  classical
  unfold degree
  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
  trans ∑ v, ∑ d ∈ S, if Γ.origin d=v ∧ P v then 1 else 0
  · apply Finset.sum_congr rfl
    intro v hv
    by_cases hh : P v <;> simp [hh]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro d hd
  simp [ite_and]

lemma surplus_excess (n : ℕ) : surplus n = ((n-2:ℕ):ℤ) - (if n=1 then 1 else 0) := by
  unfold surplus
  split_ifs <;> omega

lemma surplus_le_branch (n : ℕ) : surplus n ≤ (if n=2 then (0:ℕ) else n) := by
  unfold surplus
  split_ifs <;> omega

omit [Fintype D] in
lemma excess_le_potential_add_leaves (S : Finset D) :
    ((∑ v, (degree Γ S v - 2) : ℕ):ℤ) ≤ potential Γ S +
      ((Finset.univ.filter (fun v => degree Γ S v=1)).card:ℤ) := by
  unfold potential
  simp only [surplus_excess,Finset.sum_sub_distrib,Nat.cast_sum]
  have he : (∑ v : V, (if degree Γ S v=1 then (1:ℤ) else 0)) =
      ((Finset.univ.filter (fun v => degree Γ S v=1)).card:ℤ) := by simp
  rw [he]
  omega

omit [Fintype D] in
lemma branch_degrees_bound_excess (S : Finset D) :
    (S.filter (fun d => 3 ≤ degree Γ S (Γ.origin d))).card ≤
      3 * (∑ v, (degree Γ S v - 2)) := by
  rw [← fiber_count Γ S (fun v => 3 ≤ degree Γ S v),Finset.mul_sum]
  apply Finset.sum_le_sum
  intro v hv
  split_ifs <;> omega

/-- Bounded branching in the actual image, not in a hypothesized bounded-rank
pattern. A bounded number of leaves is the only endpoint correction. -/
theorem bounded_image_branches (C : ℝ) (hC : 0 ≤ C) (leaves : ℕ) :
    ∃ R : ℕ, ∀ {V D : Type} [Fintype V] [Fintype D] (Γ : PortGraph V D)
      (L : ℝ) (_ : 0 < L)
      (_ : (Fintype.card D:ℝ) ≤ 2*C*L)
      (_ : ∀ a (c : Γ.subdivision.Walk a a), c.IsCycle →
        L ≤ weight (edgeWeight (fun _ : D => (1:ℝ))) c)
      (_ : (Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card ≤ leaves),
      (Finset.univ.filter (fun d => 3≤degree Γ Finset.univ (Γ.origin d))).card ≤ R := by
  obtain ⟨R,hR⟩ := SuppressedMoore.bounded_branch_ports C hC
  refine ⟨3*(R+leaves),?_⟩
  intro V D _ _ Γ L hL htot hg hl
  obtain ⟨Q,_hQ,hs,hmin,hpot⟩ := exists_core Γ Finset.univ (by simp [CoreStripping.Symmetric])
  have hsub : (Fintype.card Q:ℝ)≤2*C*L := by
    exact (Nat.cast_le.mpr (by simpa using Finset.card_le_univ Q)).trans htot
  have hbound := hR (restrict Γ Q hs) (fun d => by
    rw [restrict_degree]; exact hmin d d.property) L hL hsub (by
      intro a c hc
      have hp := hg _ (c.map (inclusion Γ Q hs)) (hc.map (inclusion_injective Γ Q hs))
      rwa [inclusion_weight] at hp)
  have hc : (Q.filter (fun d => degree Γ Q (Γ.origin d)≠2)).card≤R := by
    have he : (Finset.univ.filter (fun d : Q =>
        (DegreeTwoSuppression.out (restrict Γ Q hs).origin ((restrict Γ Q hs).origin d)).card≠2)).card =
        (Q.filter (fun d => degree Γ Q (Γ.origin d)≠2)).card := by
      simp only [restrict_degree]
      apply Finset.card_bij (fun d _ => d.val)
      · intro d hd; exact Finset.mem_filter.mpr ⟨d.property,(Finset.mem_filter.mp hd).2⟩
      · intro a _ b _ h; exact Subtype.ext h
      · intro d hd
        exact ⟨⟨d,(Finset.mem_filter.mp hd).1⟩,Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp hd).2⟩,rfl⟩
    rwa [he] at hbound
  have hpQ : potential Γ Q ≤ (R:ℤ) := by
    calc potential Γ Q ≤ ((∑ v : V, (if degree Γ Q v≠2 then degree Γ Q v else 0)):ℕ) := by
          rw [Nat.cast_sum]
          unfold potential
          apply Finset.sum_le_sum
          intro v hv
          simpa only [ite_not] using surplus_le_branch (degree Γ Q v)
      _ = ((Q.filter (fun d => degree Γ Q (Γ.origin d)≠2)).card:ℤ) := by
          rw [fiber_count]
      _ ≤ R := by exact_mod_cast hc
  have hex := excess_le_potential_add_leaves Γ Finset.univ
  have hle : (∑ v, (degree Γ Finset.univ v - 2))≤R+leaves := by
    have hl' : ((Finset.univ.filter (fun v => degree Γ Finset.univ v=1)).card:ℤ)≤leaves := by
      exact_mod_cast hl
    have hh : (((∑ v, (degree Γ Finset.univ v - 2)):ℕ):ℤ)≤(R:ℤ)+leaves := by omega
    exact_mod_cast hh
  exact (branch_degrees_bound_excess Γ Finset.univ).trans (Nat.mul_le_mul_left 3 hle)

end TorsionFreeZeroDivisors.ImageComplexity

namespace TorsionFreeZeroDivisors.SystemLeaves
open SimpleGraph PortSubdivision
open scoped Classical
variable {W : Type*} {G : SimpleGraph W}

/-- The combinatorial leaf condition, stated without assuming local finiteness. -/
def AtMostOneNeighbor (x : W) : Prop := ∀ a b, G.Adj x a → G.Adj x b → a=b

lemma leaf_in_reduced_walk {a b x : W} (p : G.Walk a b)
    (hr : p.edges.IsChain (· ≠ ·)) (hx : AtMostOneNeighbor (G := G) x)
    (hm : x∈p.support) : x=a ∨ x=b := by
  induction p with
  | nil => exact Or.inl (by simpa using hm)
  | @cons a c b h p ih =>
    by_cases he : x=a
    · exact Or.inl he
    have hm' : x∈p.support := by simpa only [Walk.support_cons,List.mem_cons,he,false_or] using hm
    have htail := (List.isChain_cons.mp hr).2
    rcases ih htail hm' with hec | heb
    · subst x
      cases p with
      | nil => exact Or.inr rfl
      | @cons c d b h' p =>
        have hda : d=a := hx d a h' h.symm
        subst d
        have hh := (List.isChain_cons_cons.mp hr).1
        exact False.elim (hh (Sym2.eq_swap))
    · exact Or.inr heb

/-- Including the closing turn, not just linear immersion. -/
def CyclicallyReduced {a : W} (p : G.Walk a a) : Prop :=
  p.edges.IsChain (· ≠ ·) ∧ (¬p.Nil → s(a,p.snd) ≠ s(p.penultimate,a))

lemma leaf_not_in_cyclic {a x : W} (p : G.Walk a a)
    (hr : CyclicallyReduced p) (hne : ¬p.Nil)
    (hx : AtMostOneNeighbor (G := G) x) : x∉p.support := by
  intro hm
  have he : x=a := (leaf_in_reduced_walk p hr.1 hx hm).elim id id
  subst x
  have heq : p.snd=p.penultimate := hx _ _ (p.adj_snd hne) (p.adj_penultimate hne).symm
  exact hr.2 hne (by rw [heq,Sym2.eq_swap])

variable {V D : Type*} [Fintype D] (Γ : PortGraph V D)

def degree (v : V) : ℕ := (Finset.univ.filter (fun d => Γ.origin d=v)).card

lemma leaf_original (v : V) (hv : degree Γ v=1) :
    AtMostOneNeighbor (G := Γ.subdivision) (.inl v) := by
  intro a b ha hb
  rcases a with a|a <;> rcases b with b|b
  · exact False.elim ha
  · exact False.elim ha
  · exact False.elim hb
  · have hsingle := Finset.card_eq_one.mp hv
    obtain ⟨d,hd⟩ := hsingle
    have ha' : a∈Finset.univ.filter (fun e => Γ.origin e=v) := Finset.mem_filter.mpr ⟨Finset.mem_univ _,ha⟩
    have hb' : b∈Finset.univ.filter (fun e => Γ.origin e=v) := Finset.mem_filter.mpr ⟨Finset.mem_univ _,hb⟩
    rw [hd] at ha' hb'
    exact congrArg Sum.inr ((Finset.mem_singleton.mp ha').trans (Finset.mem_singleton.mp hb').symm)

/-- In the actual image of any number of cyclically immersed closed walks and
one immersed interval, every leaf is an endpoint of that interval. -/
lemma actual_image_leaf_endpoints {J : Type*} (base : J → V)
    (loops : ∀ j, Γ.subdivision.Walk (.inl (base j)) (.inl (base j)))
    (hloops : ∀ j, CyclicallyReduced (loops j)) (hne : ∀ j, ¬(loops j).Nil)
    {a b : V} (p : Γ.subdivision.Walk (.inl a) (.inl b))
    (hp : p.edges.IsChain (· ≠ ·))
    (himage : ∀ d : D, Sum.inl (Γ.origin d)∈p.support ∨
      ∃ j, Sum.inl (Γ.origin d)∈(loops j).support)
    (v : V) (hv : degree Γ v=1) : v=a ∨ v=b := by
  have hpos : 0<(Finset.univ.filter (fun d => Γ.origin d=v)).card := by rw [← degree,hv]; decide
  obtain ⟨d,hd⟩ := Finset.card_pos.mp hpos
  have ho := (Finset.mem_filter.mp hd).2
  have hi := himage d
  rw [ho] at hi
  rcases hi with hi | ⟨j,hj⟩
  · have hh := leaf_in_reduced_walk p hp (leaf_original Γ v hv) hi
    exact hh.imp Sum.inl.inj Sum.inl.inj
  · exact False.elim (leaf_not_in_cyclic (loops j) (hloops j) (hne j) (leaf_original Γ v hv) hj)

variable [Fintype V]

lemma actual_image_at_most_two_leaves {J : Type*} (base : J → V)
    (loops : ∀ j, Γ.subdivision.Walk (.inl (base j)) (.inl (base j)))
    (hloops : ∀ j, CyclicallyReduced (loops j)) (hne : ∀ j, ¬(loops j).Nil)
    {a b : V} (p : Γ.subdivision.Walk (.inl a) (.inl b))
    (hp : p.edges.IsChain (· ≠ ·))
    (himage : ∀ d : D, Sum.inl (Γ.origin d)∈p.support ∨
      ∃ j, Sum.inl (Γ.origin d)∈(loops j).support) :
    (Finset.univ.filter (fun v => degree Γ v=1)).card≤2 := by
  classical
  calc (Finset.univ.filter (fun v => degree Γ v=1)).card ≤ ({a,b}:Finset V).card := by
        apply Finset.card_le_card
        intro v hv
        simpa only [Finset.mem_insert,Finset.mem_singleton] using
          actual_image_leaf_endpoints Γ base loops hloops hne p hp himage v (Finset.mem_filter.mp hv).2
    _ ≤ 2 := (Finset.card_insert_le a {b}).trans (by simp)

end TorsionFreeZeroDivisors.SystemLeaves

end

end OAI