import Mathlib
import OAI.GroupTheory.SimpleAmenable.Homology.IntegralHomologyFunctorial

namespace OAI

section
section
open scoped symmDiff
namespace SimpleAmenable
open scoped commutatorElement
open scoped commutatorElement
section ConfigurationSupport
open Classical Finsupp
namespace ConfigurationChains
variable {V : Type*}

theorem linear_expansion (f : Chain V →ₗ[ℤ] Chain V) (c : Chain V) :
    f c=c.sum (fun l n => n • f (single l 1)) := by
  conv_lhs => rw [← Finsupp.sum_single c]
  rw [map_finsuppSum]
  apply Finsupp.sum_congr
  intro l hl
  rw [←map_smul,Finsupp.smul_single,smul_eq_mul,mul_one]

theorem linear_support_subset (f : Chain V →ₗ[ℤ] Chain V) (c : Chain V) :
    (f c).support⊆c.support.biUnion (fun l => (f (single l 1)).support) := by
  rw [linear_expansion f c]
  intro s hs
  obtain ⟨l,hl,hs⟩ := Finset.mem_biUnion.mp (Finsupp.support_sum hs)
  exact Finset.mem_biUnion.mpr ⟨l,hl,Finsupp.support_smul hs⟩

theorem vertices_linear_subset (f : Chain V →ₗ[ℤ] Chain V) (c : Chain V) :
    vertices (f c)⊆c.support.biUnion (fun l => vertices (f (single l 1))) := by
  intro v hv
  obtain ⟨s,hs,hv⟩ := mem_vertices.mp hv
  obtain ⟨l,hl,hs⟩ := Finset.mem_biUnion.mp (linear_support_subset f c hs)
  exact Finset.mem_biUnion.mpr ⟨l,hl,mem_vertices.mpr ⟨s,hs,hv⟩⟩

theorem vertices_linear_card (f : Chain V →ₗ[ℤ] Chain V) (c : Chain V)
    (b : ℕ) (hb : ∀l∈c.support,(vertices (f (single l 1))).card≤b) :
    (vertices (f c)).card≤c.support.card*b := by
  calc
    _ ≤ (c.support.biUnion (fun l => vertices (f (single l 1)))).card :=
      Finset.card_le_card (vertices_linear_subset f c)
    _ ≤ ∑l∈c.support,(vertices (f (single l 1))).card := Finset.card_biUnion_le
    _ ≤ ∑l∈c.support,b := Finset.sum_le_sum hb
    _ = _ := by simp

def Admissible (R : V → V → Prop) (n : ℕ) (c : Chain V) : Prop :=
  ∀l∈c.support,List.Pairwise R l ∧ l.length=n

@[simp] theorem admissible_zero (R : V → V → Prop) (n : ℕ) :
    Admissible R n (0 : Chain V) := by simp [Admissible]

theorem admissible_single {R : V → V → Prop} {n : ℕ} {l : List V}
    (hl : List.Pairwise R l) (hn : l.length=n) (k : ℤ) :
    Admissible R n (single l k) := by
  intro s hs
  have he : s=l := Finset.mem_singleton.mp (Finsupp.support_single_subset hs)
  subst s
  exact ⟨hl,hn⟩

theorem admissible_sub {R : V → V → Prop} {n : ℕ} {c d : Chain V}
    (hc : Admissible R n c) (hd : Admissible R n d) : Admissible R n (c-d) := by
  intro l hl
  rcases Finset.mem_union.mp (Finsupp.support_sub hl) with hl|hl
  · exact hc l hl
  · exact hd l hl

theorem admissible_linear {R : V → V → Prop} {n k : ℕ} {c : Chain V}
    (f : Chain V →ₗ[ℤ] Chain V) (hc : Admissible R n c)
    (hf : ∀l,List.Pairwise R l → l.length=n → Admissible R k (f (single l 1))) :
    Admissible R k (f c) := by
  intro s hs
  obtain ⟨l,hl,hs⟩ := Finset.mem_biUnion.mp (linear_support_subset f c hs)
  exact hf l (hc l hl).1 (hc l hl).2 s hs

theorem admissible_faceSum {R : V → V → Prop} {n : ℕ} {l : List V}
    (hl : List.Pairwise R l) (hn : l.length=n+1) : Admissible R n (faceSum l) := by
  intro s hs
  obtain ⟨hsub,hlen⟩ := faceSum_support hs
  exact ⟨hl.sublist hsub,by omega⟩

theorem admissible_boundary {R : V → V → Prop} {n : ℕ} {c : Chain V}
    (hc : Admissible R (n+1) c) : Admissible R n (boundary c) := by
  apply admissible_linear boundary hc
  intro l hl hn
  simpa using admissible_faceSum hl hn

theorem admissible_cone {R : V → V → Prop} {n : ℕ} {c : Chain V}
    (hc : Admissible R n c) (v : V) (hv : ∀w∈vertices c,R v w) :
    Admissible R (n+1) (cone v c) := by
  intro l hl
  obtain ⟨s,hs,rfl⟩ := Finset.mem_image.mp (cone_support_subset v c hl)
  have h := hc s hs
  refine ⟨List.pairwise_cons.mpr ⟨?_,h.1⟩,by simp [h.2]⟩
  intro w hw
  exact hv w (mem_vertices.mpr ⟨s,hs,hw⟩)

theorem vertices_boundary_subset (c : Chain V) : vertices (boundary c)⊆vertices c := by
  intro v hv
  obtain ⟨l,hl,hv⟩ := Finset.mem_biUnion.mp (vertices_linear_subset boundary c hv)
  simp only [boundary_single,one_smul] at hv
  obtain ⟨s,hs,hv⟩ := mem_vertices.mp hv
  exact mem_vertices.mpr ⟨l,hl,(faceSum_support hs).1.subset hv⟩

theorem linear_eq_on_admissible {R : V → V → Prop} {n : ℕ}
    (f g : Chain V →ₗ[ℤ] Chain V)
    (h : ∀l,List.Pairwise R l → l.length=n → f (single l 1)=g (single l 1))
    {c : Chain V} (hc : Admissible R n c) : f c=g c := by
  rw [linear_expansion f c,linear_expansion g c]
  apply Finsupp.sum_congr
  intro l hl
  rw [h l (hc l hl).1 (hc l hl).2]

end ConfigurationChains
end ConfigurationSupport

section BoundedConfigurationContraction
open Classical Finsupp
namespace ConfigurationChains
variable {V : Type*} {R : V → V → Prop}

structure Step (R : V → V → Prop) (n b : ℕ) where
  previous : Chain V →ₗ[ℤ] Chain V
  current : Chain V →ₗ[ℤ] Chain V
  equation : ∀c,Admissible R n c → boundary (current c)+previous (boundary c)=c
  admissible : ∀l,List.Pairwise R l → l.length=n →
    Admissible R (n+1) (current (single l 1))
  bounded : ∀l,List.Pairwise R l → l.length=n →
    (vertices (current (single l 1))).card≤b

namespace Step
variable {n b : ℕ} (D : Step R n b)

noncomputable def base (v : V) : Step R 0 1 where
  previous := 0
  current := cone v
  equation c hc := by
    have he : boundary c=0 := by
      have hz : ∀l,List.Pairwise R l → l.length=0 → boundary (single l 1)=(0 : Chain V) := by
        intro l hl hn
        have : l=[] := List.length_eq_zero_iff.mp hn
        simp [this,faceSum]
      exact linear_eq_on_admissible boundary 0 hz hc
    simp [boundary_cone,he]
  admissible l hl hn := by
    have : l=[] := List.length_eq_zero_iff.mp hn
    simp only [this,cone_single]
    exact admissible_single (by simp) (by simp) _
  bounded l hl hn := by
    have : l=[] := List.length_eq_zero_iff.mp hn
    simp only [this,cone_single]
    exact (Finset.card_le_card (vertices_single_subset [v] (1:ℤ))).trans (by simp)

noncomputable def residual (l : List V) : Chain V := single l 1-D.current (faceSum l)

theorem residual_admissible {l : List V} (hl : List.Pairwise R l) (hn : l.length=n+1) :
    Admissible R (n+1) (D.residual l) := by
  apply admissible_sub (admissible_single hl hn 1)
  exact admissible_linear D.current (admissible_faceSum hl hn) D.admissible

theorem residual_cycle {l : List V} (hl : List.Pairwise R l) (hn : l.length=n+1) :
    boundary (D.residual l)=0 := by
  have he := D.equation (faceSum l) (admissible_faceSum hl hn)
  simp only [boundary_faceSum,map_zero,add_zero] at he
  simp [residual,he]

theorem residual_bound {l : List V} (hl : List.Pairwise R l) (hn : l.length=n+1) :
    (vertices (D.residual l)).card≤(n+1)+(n+1)*b := by
  have hb : (vertices (D.current (faceSum l))).card≤(n+1)*b := by
    apply (vertices_linear_card D.current (faceSum l) b ?_).trans
      (Nat.mul_le_mul_right b ((faceSum_support_card l).trans hn.le))
    intro s hs
    have had := admissible_faceSum hl hn s hs
    exact D.bounded s had.1 had.2
  calc
    _ ≤ (vertices (single l 1)∪vertices (D.current (faceSum l))).card :=
      Finset.card_le_card (vertices_sub_subset _ _)
    _ ≤ (vertices (single l 1)).card+(vertices (D.current (faceSum l))).card := Finset.card_union_le _ _
    _ ≤ l.toFinset.card+(n+1)*b := Nat.add_le_add
      (Finset.card_le_card (vertices_single_subset _ _)) hb
    _ ≤ (n+1)+(n+1)*b := Nat.add_le_add_right ((List.toFinset_card_le l).trans hn.le) _

variable (hc : ∀S : Finset V,S.card≤(n+1)+(n+1)*b → ∃v,∀w∈S,R v w)

noncomputable def nextVertex (l : List V) (hl : List.Pairwise R l ∧ l.length=n+1) : V :=
  (hc (vertices (D.residual l)) (D.residual_bound hl.1 hl.2)).choose

theorem nextVertex_rel (l : List V) (hl : List.Pairwise R l ∧ l.length=n+1) :
    ∀w∈vertices (D.residual l),R (D.nextVertex hc l hl) w :=
  (hc _ (D.residual_bound hl.1 hl.2)).choose_spec

noncomputable def nextGenerator (l : List V) : Chain V :=
  if hl : List.Pairwise R l ∧ l.length=n+1 then
    cone (D.nextVertex hc l hl) (D.residual l) else 0

noncomputable def next : Chain V →ₗ[ℤ] Chain V :=
  Finsupp.linearCombination ℤ (D.nextGenerator hc)

@[simp] theorem next_single (l : List V) :
    D.next hc (single l 1)=D.nextGenerator hc l := by simp [next]

theorem next_contraction {l : List V} (hl : List.Pairwise R l) (hn : l.length=n+1) :
    boundary (D.next hc (single l 1))+D.current (boundary (single l 1))=single l 1 := by
  rw [next_single,nextGenerator,dite_eq_left ⟨hl,hn⟩,boundary_cone,D.residual_cycle hl hn]
  simp [residual]

theorem next_admissible {l : List V} (hl : List.Pairwise R l) (hn : l.length=n+1) :
    Admissible R (n+1+1) (D.next hc (single l 1)) := by
  rw [next_single,nextGenerator,dite_eq_left ⟨hl,hn⟩]
  exact admissible_cone (D.residual_admissible hl hn) _ (D.nextVertex_rel hc l ⟨hl,hn⟩)

theorem next_bounded {l : List V} (hl : List.Pairwise R l) (hn : l.length=n+1) :
    (vertices (D.next hc (single l 1))).card≤1+(n+1)+(n+1)*b := by
  rw [next_single,nextGenerator,dite_eq_left ⟨hl,hn⟩]
  have hi := Finset.card_le_card (vertices_cone_subset (D.nextVertex hc l ⟨hl,hn⟩) (D.residual l))
  have hj := Finset.card_insert_le (D.nextVertex hc l ⟨hl,hn⟩) (vertices (D.residual l))
  have hb := D.residual_bound hl hn
  omega

noncomputable def extend : Step R (n+1) (1+(n+1)+(n+1)*b) where
  previous := D.current
  current := D.next hc
  equation c h := by
    have he : (boundary.comp (D.next hc)+D.current.comp boundary) c=LinearMap.id c :=
      linear_eq_on_admissible _ _ (fun _ hl hn => D.next_contraction hc hl hn) h
    exact he
  admissible _ := D.next_admissible hc
  bounded _ := D.next_bounded hc

include D in

theorem fills {c : Chain V} (hc : Admissible R n c) (hz : boundary c=0) :
    ∃d,Admissible R (n+1) d ∧ boundary d=c := by
  refine ⟨D.current c,admissible_linear D.current hc D.admissible,?_⟩
  have he := D.equation c hc
  simpa [hz] using he

end Step

def bankBound : ℕ → ℕ
  | 0 => 1
  | n+1 => 1+(n+1)+(n+1)*bankBound n

theorem bankBound_mono : Monotone bankBound := by
  apply monotone_nat_of_le_succ
  intro n
  rw [bankBound]
  have hh : bankBound n≤(n+1)*bankBound n := by nlinarith
  omega

theorem exists_step (N : ℕ)
    (hc : ∀S : Finset V,S.card≤bankBound N → ∃v,∀w∈S,R v w) :
    ∀n≤N,Nonempty (Step R n (bankBound n)) := by
  intro n hn
  induction n with
  | zero =>
    obtain ⟨v,hv⟩ := hc ∅ (by simp)
    exact ⟨Step.base v⟩
  | succ n ih =>
    obtain ⟨D⟩ := ih (by omega)
    refine ⟨D.extend (fun S hS => hc S ?_)⟩
    apply hS.trans
    apply le_trans (by simp only [bankBound]; omega) (bankBound_mono hn)

theorem low_degree_filling
    (hc : ∀S : Finset V,S.card≤31 → ∃v,∀w∈S,R v w)
    {n : ℕ} (hn : n≤3) {c : Chain V} (had : Admissible R n c) (hz : boundary c=0) :
    ∃d,Admissible R (n+1) d ∧ boundary d=c := by
  obtain ⟨D⟩ := exists_step (R:=R) 3 (by simpa [bankBound] using hc) n hn
  exact D.fills had hz

end ConfigurationChains
end BoundedConfigurationContraction

end SimpleAmenable
end
end

end OAI