lean/OAI/Algebra/GroupRing/FiniteClusters.lean

import Mathlib
import OAI.Algebra.GroupRing.ShortClosure

namespace OAI

noncomputable section

namespace TorsionFreeZeroDivisors.FiniteClusters
open scoped Classical BigOperators
variable {V : Type} [Fintype V] (G : SimpleGraph V)
local instance : Fintype G.ConnectedComponent := Fintype.ofFinite _

def block (c : G.ConnectedComponent) : Finset V :=
  Finset.univ.filter (fun v => G.connectedComponentMk v=c)
lemma mem_block {c : G.ConnectedComponent} {v : V} :
    v∈block G c ↔ G.connectedComponentMk v=c := by simp [block]
lemma block_nonempty (c : G.ConnectedComponent) : (block G c).Nonempty := by
  exact ⟨c.out,(mem_block G).mpr c.out_eq⟩
omit [Fintype V] in
lemma same_of_adj {v w : V} (h : G.Adj v w) : G.connectedComponentMk v=G.connectedComponentMk w :=
  SimpleGraph.ConnectedComponent.connectedComponentMk_eq_of_adj h

omit [Fintype V] in
lemma reachable_closed {B : Finset V}
    (hc : ∀ x∈B,∀ y,G.Adj x y → y∈B) {x y : V}
    (hp : G.Reachable x y) (hx : x∈B) : y∈B := by
  obtain ⟨p⟩ := hp
  induction p with
  | nil => exact hx
  | @cons u v w h p ih => exact ih (hc u hx v h)

lemma block_card {K : ℕ}
    (hs : ∀ x : V,∃ B : Finset V,x∈B ∧ B.card≤K ∧ ∀ y∈B,∀ z,G.Adj y z → z∈B)
    (c : G.ConnectedComponent) : (block G c).card≤K := by
  obtain ⟨x,hx⟩ := block_nonempty G c
  obtain ⟨B,hB,hBK,hclosed⟩ := hs x
  apply (Finset.card_le_card (show block G c⊆B from ?_)).trans hBK
  intro y hy
  apply reachable_closed G hclosed _ hB
  apply SimpleGraph.ConnectedComponent.exact
  exact (mem_block G).mp hx |>.trans ((mem_block G).mp hy).symm

lemma sum_blocks {M : Type*} [AddCommMonoid M] (w : V → M) :
    (∑ c : G.ConnectedComponent,∑ v∈block G c,w v)=∑ v,w v := by
  simp only [block,Finset.sum_filter]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro v _
  simp

lemma block_sum_le {w : V → ℝ} {b : ℝ} (h : ∀ v,w v≤b) (c : G.ConnectedComponent) :
    (∑ v∈block G c,w v)≤(block G c).card*b := by
  calc
    _ ≤ ∑ _v∈block G c,b := Finset.sum_le_sum fun v _ => h v
    _ = _ := by simp
end TorsionFreeZeroDivisors.FiniteClusters

namespace TorsionFreeZeroDivisors.PairingClusters
open scoped Classical BigOperators
variable {O T : Type} [Fintype O] [Fintype T]
    (f : O → T) (α : O → O) (hα : Function.Involutive α) (keep : T → Prop)
abbrev Vertex := {t // keep t}
def Rel (p q : T) : Prop := ∃ o,f o=p ∧ f (α o)=q
include hα in
omit [Fintype O] [Fintype T] in
lemma rel_symm {p q : T} (h : Rel f α p q) : Rel f α q p := by
  obtain ⟨o,ho,hp⟩ := h
  exact ⟨α o,hp,by simpa only [hα o] using ho⟩
def graph : SimpleGraph (Vertex keep) where
  Adj p q := p≠q ∧ Rel f α p.val q.val
  symm := ⟨by
    intro p q h
    exact ⟨Ne.symm h.1,rel_symm f α hα h.2⟩⟩
  loopless := ⟨by intro p h; exact h.1 rfl⟩
local instance : Fintype (graph f α hα keep).ConnectedComponent := Fintype.ofFinite _
abbrev Cluster := (graph f α hα keep).ConnectedComponent

def cluster (t : T) : Option (Cluster f α hα keep) :=
  if h : keep t then some ((graph f α hα keep).connectedComponentMk ⟨t,h⟩) else none
omit [Fintype O] [Fintype T] in
lemma cluster_some {t : T} (h : keep t) :
    cluster f α hα keep t=some ((graph f α hα keep).connectedComponentMk ⟨t,h⟩) := dite_eq_left h
omit [Fintype O] [Fintype T] in
lemma cluster_none {t : T} (h : ¬keep t) : cluster f α hα keep t=none := dite_eq_right h
omit [Fintype O] [Fintype T] in
lemma cluster_exists {t : T} : (∃ c,cluster f α hα keep t=some c) ↔ keep t := by
  by_cases h : keep t
  · simp only [cluster_some f α hα keep h,Option.some.injEq,exists_eq',h]
  · simp only [cluster_none f α hα keep h,reduceCtorEq,exists_false,false_iff]; exact h
omit [Fintype O] [Fintype T] in
lemma cluster_pair {o : O} (h : keep (f o)) (h' : keep (f (α o))) :
    cluster f α hα keep (f o)=cluster f α hα keep (f (α o)) := by
  rw [cluster_some f α hα keep h,cluster_some f α hα keep h']
  apply congrArg some
  by_cases he : (⟨f o,h⟩ : Vertex keep)=⟨f (α o),h'⟩
  · rw [he]
  · apply FiniteClusters.same_of_adj
    exact ⟨he,⟨o,rfl,rfl⟩⟩
omit [Fintype O] [Fintype T] in
lemma same_cluster_partner {o : O} {c : Cluster f α hα keep}
    (hc : cluster f α hα keep (f o)=some c) :
    (cluster f α hα keep (f (α o))=some c ↔ keep (f (α o))) := by
  constructor
  · intro h; exact (cluster_exists f α hα keep).mp ⟨c,h⟩
  · intro h
    rw [←cluster_pair f α hα keep ((cluster_exists f α hα keep).mp ⟨c,hc⟩) h,hc]

def bad (o : O) : Prop := keep (f o) ∧ (α o=o ∨ ¬keep (f (α o)))
def localBad (c : Cluster f α hα keep) (o : O) : Prop :=
  cluster f α hα keep (f o)=some c ∧
    (α o=o ∨ cluster f α hα keep (f (α o))≠some c)
omit [Fintype O] [Fintype T] in
lemma localBad_iff (c : Cluster f α hα keep) (o : O) :
    localBad f α hα keep c o ↔ bad f α keep o ∧ cluster f α hα keep (f o)=some c := by
  constructor
  · rintro ⟨hc,hb⟩
    refine ⟨⟨(cluster_exists f α hα keep).mp ⟨c,hc⟩,?_⟩,hc⟩
    exact hb.imp_right fun hn h => hn ((same_cluster_partner f α hα keep hc).mpr h)
  · rintro ⟨⟨_,hb⟩,hc⟩
    exact ⟨hc,hb.imp_right fun hn h => hn ((same_cluster_partner f α hα keep hc).mp h)⟩

lemma local_bad_sum :
    (∑ c : Cluster f α hα keep,(Finset.univ.filter (localBad f α hα keep c)).card)=
    (Finset.univ.filter (bad f α keep)).card := by
  simp only [Finset.card_eq_sum_ones,Finset.sum_filter]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro o _
  simp only [localBad_iff]
  by_cases hb : bad f α keep o
  · obtain ⟨c,hc⟩ := (cluster_exists f α hα keep).mpr hb.1
    simp [hb,hc]
  · simp [hb]

include hα in
omit [Fintype T] in
lemma total_bad_bound : (Finset.univ.filter (bad f α keep)).card≤
    (Finset.univ.filter (fun o => α o=o)).card+
    (Finset.univ.filter (fun o => ¬keep (f o) ∧ α o≠o)).card := by
  let old := Finset.univ.filter (fun o : O => keep (f o) ∧ α o=o)
  let cut := Finset.univ.filter (fun o : O => keep (f o) ∧ α o≠o ∧ ¬keep (f (α o)))
  have cover : Finset.univ.filter (bad f α keep)⊆old∪cut := by
    intro o ho
    have ho := (Finset.mem_filter.mp ho).2
    by_cases he : α o=o
    · exact Finset.mem_union_left _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ho.1,he⟩)
    · exact Finset.mem_union_right _ (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ho.1,he,ho.2.resolve_left he⟩)
  have hold : old.card≤(Finset.univ.filter (fun o => α o=o)).card := by
    apply Finset.card_le_card
    intro o ho
    exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,(Finset.mem_filter.mp ho).2.2⟩
  have hcut : cut.card≤(Finset.univ.filter (fun o => ¬keep (f o) ∧ α o≠o)).card := by
    apply Finset.card_le_card_of_injOn (f:=α)
    · intro o ho
      have ho := (Finset.mem_filter.mp ho).2
      exact Finset.mem_filter.mpr ⟨Finset.mem_univ _,ho.2.2,by simpa only [hα o] using Ne.symm ho.2.1⟩
    · exact fun _ _ _ _ h => hα.injective h
  exact (Finset.card_le_card cover).trans ((Finset.card_union_le _ _).trans (Nat.add_le_add hold hcut))

lemma total_local_bad_bound :
    (∑ c : Cluster f α hα keep,(Finset.univ.filter (localBad f α hα keep c)).card)≤
    (Finset.univ.filter (fun o => α o=o)).card+
    (Finset.univ.filter (fun o => ¬keep (f o) ∧ α o≠o)).card := by
  rw [local_bad_sum]
  exact total_bad_bound f α hα keep
end TorsionFreeZeroDivisors.PairingClusters

/-! Arithmetic localization of finite-cluster mass and comparison bounds. -/
namespace TorsionFreeZeroDivisors.PlanarLocalization
open scoped Classical BigOperators

lemma bad_mass {Z : Type} [Fintype Z] (h b : Z → ℝ) (ε : ℝ)
    (hb : ∀ z,0 ≤ b z) :
    ε*(∑ z∈Finset.univ.filter (fun z => ε*h z < b z),h z) ≤ ∑ z,b z := by
  calc
    _ = ∑ z∈Finset.univ.filter (fun z => ε*h z < b z),ε*h z := by rw [Finset.mul_sum]
    _ ≤ ∑ z∈Finset.univ.filter (fun z => ε*h z < b z),b z :=
      Finset.sum_le_sum fun z hz => (Finset.mem_filter.mp hz).2.le
    _ ≤ _ := Finset.sum_le_sum_of_subset_of_nonneg (Finset.filter_subset _ _)
      (fun z _ _ => hb z)

/-- Three exact exclusions leave a positive amount of source length. -/
theorem exists_good_cluster {Z : Type} [Fintype Z]
    (h b i : Z → ℝ) (H₀ L ε C C₂ : ℝ)
    (hH₀ : 0 < H₀) (hL : 0 < L) (hε : 0 < ε) (hC₂ : 0 < C₂)
    (hh : ∀ z,0 ≤ h z) (hb : ∀ z,0 ≤ b z) (hi : ∀ z,0 ≤ i z)
    (hupper : ∀ z,h z ≤ C*L)
    (hretained : 15/16*H₀ ≤ ∑ z,h z)
    (hunpaired : ∑ z,b z ≤ ε/16*H₀)
    (hcomparisons : ∑ z,i z ≤ C₂/(16*L)*H₀)
    (hshort : ∑ z∈Finset.univ.filter (fun z => h z < L),h z ≤ H₀/2) :
    ∃ z,L ≤ h z ∧ h z ≤ C*L ∧ b z ≤ ε*h z ∧ i z ≤ C₂*h z/L := by
  let badB := Finset.univ.filter (fun z => ε*h z < b z)
  let badI := Finset.univ.filter (fun z => (C₂/L)*h z < i z)
  let short := Finset.univ.filter (fun z => h z < L)
  have hB : ∑ z∈badB,h z ≤ H₀/16 := by
    have ht := (bad_mass h b ε hb).trans hunpaired
    change ε*(∑ z∈badB,h z) ≤ ε/16*H₀ at ht
    nlinarith
  have hI : ∑ z∈badI,h z ≤ H₀/16 := by
    have ht := (bad_mass h i (C₂/L) hi).trans hcomparisons
    change (C₂/L)*(∑ z∈badI,h z) ≤ C₂/(16*L)*H₀ at ht
    have he : C₂/(16*L)*H₀=(C₂/L)*(H₀/16) := by ring
    rw [he] at ht
    have hp := div_pos hC₂ hL
    nlinarith
  by_contra hn
  have hc : ∀ z,z∈badB ∨ z∈badI ∨ z∈short := by
    intro z
    by_cases hB : b z ≤ ε*h z
    · by_cases hI : i z ≤ C₂*h z/L
      · have hs : h z < L := by
          by_contra hl
          exact hn ⟨z,le_of_not_gt hl,hupper z,hB,hI⟩
        exact Or.inr (Or.inr (Finset.mem_filter.mpr ⟨Finset.mem_univ _,hs⟩))
      · right; left
        apply Finset.mem_filter.mpr
        refine ⟨Finset.mem_univ _,?_⟩
        simpa only [div_mul_eq_mul_div] using lt_of_not_ge hI
    · exact Or.inl (Finset.mem_filter.mpr ⟨Finset.mem_univ _,lt_of_not_ge hB⟩)
  have hsum : (∑ z,h z) ≤ (∑ z∈badB,h z)+(∑ z∈badI,h z)+(∑ z∈short,h z) := by
    rw [Finset.sum_filter,Finset.sum_filter,Finset.sum_filter,←Finset.sum_add_distrib,
      ←Finset.sum_add_distrib]
    apply Finset.sum_le_sum
    intro z _
    have hc := hc z
    simp only [badB,badI,short,Finset.mem_filter,Finset.mem_univ,true_and] at hc
    rcases hc with hc|hc|hc
    · simp only [ite_eq_left hc]
      have h1 : 0 ≤ if C₂/L*h z < i z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
      have h2 : 0 ≤ if h z < L then h z else 0 := by split <;> first | exact hh z | exact le_rfl
      linarith
    · simp only [ite_eq_left hc]
      have h1 : 0 ≤ if ε*h z < b z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
      have h2 : 0 ≤ if h z < L then h z else 0 := by split <;> first | exact hh z | exact le_rfl
      linarith
    · simp only [ite_eq_left hc]
      have h1 : 0 ≤ if ε*h z < b z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
      have h2 : 0 ≤ if C₂/L*h z < i z then h z else 0 := by split <;> first | exact hh z | exact le_rfl
      linarith
  change (∑ z∈short,h z) ≤ H₀/2 at hshort
  linarith

/-- The discarded short exceptional cluster really costs less than half; the
ordinary girth-length boundary is accounted for separately, not silently lost. -/
lemma exceptional_short_cost (h L H₀ : ℝ) (hlen : h < L) (hordinary : h+L ≤ H₀) :
    h < H₀/2 := by linarith

end TorsionFreeZeroDivisors.PlanarLocalization

namespace TorsionFreeZeroDivisors.ClusterLocalization
open scoped Classical BigOperators
open ComparedBlocks
variable {T E : Type} [Fintype T] {len : T → ℕ}
    (C : Comparisons (E:=E) len) (keep : T → Prop)

abbrev graph := PairingClusters.graph (fun x : Position len => x.1)
  C.pairing.partner C.pairing.involutive keep
abbrev Cluster := (graph C keep).ConnectedComponent
local instance : Fintype (Cluster C keep) := Fintype.ofFinite _
def cluster := PairingClusters.cluster (fun x : Position len => x.1)
  C.pairing.partner C.pairing.involutive keep
abbrev belongs (c : Cluster C keep) (t : T) : Prop := cluster C keep t=some c
abbrev localC (c : Cluster C keep) := RestrictComparisons.comparisons C (belongs C keep c)
def mass (c : Cluster C keep) : ℕ := ∑ t∈Finset.univ.filter (belongs C keep c),len t
def bad (c : Cluster C keep) : ℕ :=
  (Finset.univ.filter (PairingClusters.localBad (fun x : Position len => x.1)
    C.pairing.partner C.pairing.involutive keep c)).card
def comparisons [Fintype E] (c : Cluster C keep) : ℕ :=
  Fintype.card {e // RestrictComparisons.Active C (belongs C keep c) e}
def paths (c : Cluster C keep) : Finset T := Finset.univ.filter (belongs C keep c)

omit [Fintype T] in
lemma cluster_exists {t : T} : (∃ c,belongs C keep c t) ↔ keep t :=
  PairingClusters.cluster_exists _ _ _ _
lemma mass_pos (hlen : ∀ t,0<len t) (c : Cluster C keep) : 0 < mass C keep c := by
  obtain ⟨t,ht⟩ := FiniteClusters.block_nonempty (graph C keep) c
  have ht' : belongs C keep c t.val := by
    change PairingClusters.cluster _ _ _ _ t.val=some c
    rw [PairingClusters.cluster_some _ _ _ _ t.property]
    exact congrArg some ((FiniteClusters.mem_block _).mp ht)
  exact Finset.sum_pos' (fun t _ => Nat.zero_le _) ⟨t.val,Finset.mem_filter.mpr ⟨Finset.mem_univ _,ht'⟩,hlen _⟩

lemma mass_sum : (∑ c,mass C keep c)=∑ t∈Finset.univ.filter keep,len t := by
  simp only [mass,Finset.sum_filter]
  rw [Finset.sum_comm]
  apply Finset.sum_congr rfl
  intro t _
  by_cases ht : keep t
  · obtain ⟨c,hc⟩ := (cluster_exists C keep).mpr ht
    change cluster C keep t=some c at hc
    simp [belongs,hc,ht]
  · have hc : cluster C keep t=none := PairingClusters.cluster_none _ _ _ _ ht
    simp [belongs,hc,ht]

lemma mass_original_loss : (∑ t,len t)≤(∑ c,mass C keep c)+∑ t∈Finset.univ.filter (fun t=>¬keep t),len t := by
  rw [mass_sum]
  exact (le_of_eq (Finset.sum_filter_add_sum_filter_not _ _ _).symm)

lemma bad_sum : (∑ c,bad C keep c)≤
    (Finset.univ.filter (fun x : Position len=>C.pairing.partner x=x)).card+
    (Finset.univ.filter (fun x : Position len=>¬keep x.1 ∧ C.pairing.partner x≠x)).card := by
  convert PairingClusters.total_local_bad_bound (fun x : Position len => x.1) C.pairing.partner C.pairing.involutive keep using 1
  · apply Finset.sum_congr (by ext c; simp)
    intro c _
    unfold bad
    congr 1
  · congr 1 <;> congr 1 <;> ext x <;> simp

lemma comparisons_sum [Fintype E] : (∑ c,comparisons C keep c)≤Fintype.card E := by
  simp only [comparisons,Fintype.card_subtype,Finset.card_eq_sum_ones,Finset.sum_filter]
  rw [Finset.sum_comm]
  calc
    _ ≤ ∑ _e : E,1 := by
      apply Finset.sum_le_sum
      intro e _
      by_cases hk : keep (C.source e)
      · obtain ⟨c,hc⟩ := (cluster_exists C keep).mpr hk
        change cluster C keep (C.source e)=some c at hc
        calc
          _ ≤ ∑ d : Cluster C keep, if belongs C keep d (C.source e) then 1 else 0 := by
            apply Finset.sum_le_sum
            intro d _
            by_cases h : belongs C keep d (C.source e)
            · simp only [ite_eq_left h]; split_ifs <;> omega
            · simp only [RestrictComparisons.Active,h,false_and,ite_false,le_refl]
          _ = 1 := by simp [belongs,hc]
      · have hc : cluster C keep (C.source e)=none := PairingClusters.cluster_none _ _ _ _ hk
        simp [RestrictComparisons.Active,belongs,hc]
    _ = _ := by simp

/-- The fixed positions in the literal restricted comparison system are exactly
this cluster's old fixed or lost-partner occurrences. -/
def fixedEquiv (c : Cluster C keep) :
    {x : Position (RestrictComparisons.Length (belongs C keep c) (len:=len)) //
      (localC C keep c).pairing.partner x=x} ≃
    {x : Position len // PairingClusters.localBad (fun x : Position len => x.1)
      C.pairing.partner C.pairing.involutive keep c x} where
  toFun x := ⟨RestrictComparisons.embed _ x.val,x.val.1.property,
    (RestrictComparisons.fixed_iff C _ _).mp x.property⟩
  invFun x := by
    have hx : belongs C keep c x.val.1 ∧
        (C.pairing.partner x.val=x.val ∨ ¬belongs C keep c (C.pairing.partner x.val).1) := x.property
    refine ⟨RestrictComparisons.liftPosition _ x.val hx.1,?_⟩
    apply (RestrictComparisons.fixed_iff C _ _).mpr
    simpa only [RestrictComparisons.embed_local] using hx.2
  left_inv x := by rcases x with ⟨⟨⟨t,ht⟩,q⟩,hx⟩; rfl
  right_inv x := by rcases x with ⟨⟨t,q⟩,hx⟩; rfl
lemma fixed_card (c : Cluster C keep) :
    (Finset.univ.filter (fun x => (localC C keep c).pairing.partner x=x)).card=bad C keep c := by
  simpa only [bad,Fintype.card_subtype] using Fintype.card_congr (fixedEquiv C keep c)

lemma local_mass (c : Cluster C keep) :
    (∑ t : {t // belongs C keep c t},len t.val)=mass C keep c := by
  exact (Finset.sum_subtype (Finset.univ.filter (belongs C keep c)) (by intro t; simp) len).symm

lemma short_member {L : ℕ} (c : Cluster C keep) (hc : mass C keep c<L)
    {t : T} (ht : belongs C keep c t) : len t<L := by
  apply lt_of_le_of_lt _ hc
  exact Finset.single_le_sum (fun _ _=>Nat.zero_le _) (Finset.mem_filter.mpr ⟨Finset.mem_univ _,ht⟩)

/-- With at most one short exceptional piece there is at most one short cluster.
The estimate counts actual retained path lengths, not abstract cluster masses. -/
lemma short_mass {L : ℕ} (root : Option T)
    (ho : ∀ t,root≠some t → L≤len t) :
    (∑ c∈Finset.univ.filter (fun c=>mass C keep c<L),mass C keep c)≤
      ∑ t∈Finset.univ.filter (fun t=>root=some t),len t := by
  simp only [Finset.sum_filter]
  have expand (c : Cluster C keep) :
      (if mass C keep c<L then mass C keep c else 0)=
      ∑ t,if mass C keep c<L then (if belongs C keep c t then len t else 0) else 0 := by
    by_cases h : mass C keep c<L
    · simp only [ite_eq_left h]
      simp only [mass,Finset.sum_filter]
    · simp only [ite_eq_right h,Finset.sum_const_zero]
  simp_rw [expand]
  rw [Finset.sum_comm]
  apply Finset.sum_le_sum
  intro t _
  by_cases hr : root=some t
  · rw [ite_eq_left hr]
    by_cases hk : keep t
    · obtain ⟨c,hc⟩ := (cluster_exists C keep).mpr hk
      change cluster C keep t=some c at hc
      simp only [belongs,hc,Option.some.injEq]
      calc
        _ ≤ ∑ d : Cluster C keep,if c=d then len t else 0 := by
          apply Finset.sum_le_sum
          intro d _
          split_ifs <;> omega
        _ = len t := by simp
    · have hc : cluster C keep t=none := PairingClusters.cluster_none _ _ _ _ hk
      simp [belongs,hc]
  · rw [ite_eq_right hr]
    apply Nat.le_zero.mpr
    apply Finset.sum_eq_zero
    intro c _
    by_cases hc : mass C keep c<L
    · have hnt : ¬belongs C keep c t := fun h => (not_lt_of_ge (ho t hr)) (short_member C keep c hc h)
      simp only [ite_eq_left hc,ite_eq_right hnt]
    · simp only [ite_eq_right hc]
end TorsionFreeZeroDivisors.ClusterLocalization

end

end OAI